PaperlayerView exact revision on arXiv

Source-linked AI summary

Plans You Can Check: Verifier-Grounded Learning of an Open-Weight Planner for Executable Video-Editing

Haoyu Wang, Cheng Feng, Liuyang Bian, Ruiyang Huang, Lei Wei, Yafei Wen, Xiaoxin Chen, Xiaoying Tang

arXiv:2608.25622v1cs.CVcs.CL

TL;DR

Executable video editing requires planning an executable timeline from footage, music, and hard constraints, but valid repairs lack a single ground-truth label. RefineCut trains an open-weight planner with verifier-replayed supervision and self-preference refinement, lifting an 8B planner from 0.620 to 0.924 VES while transferring across backbones and matching frontier teachers in a closed loop.

  • Problem

    Executable video editing lacks a single ground-truth repair, limiting direct imitation of teacher traces despite many valid cuts.

  • Method

    RefineCut uses typed timeline patches, explicit constraint ledgers, deterministic verifier replay, and preference refinement to train an open-weight editing planner.

  • Results

    0.620 to 0.924 VES: verifier-replayed supervision improves an 8B planner, transfers across three model families, and matches or exceeds frontier teachers in the same closed loop.

  • Takeaways & Limitations

    Verifier replay turns heterogeneous teacher trajectories into consistently graded supervision for executable video-editing planning without teacher calls at inference.

  • Takeaways & Limitations

    Evidence is limited to three model families, three task families, one primary asset pool, and controlled-template briefs, leaving broader domains and final-video evaluation for future work.

Abstract

from arXiv · show

Practical video editing is not only pixel generation: an editor must turn a brief, a clip pool, music metadata, and hard constraints into an executable timeline. We study this decision layer as \emph{executable video-editing planning} and introduce RefineCut, which, unlike workflow systems that wrap a prompted frontier model, trains a compact open-weight planner for it. The planner edits a typed timeline through structured patches covering clip selection, trimming, ordering, transitions, and duration and music alignment; a deterministic verifier applies each patch and checks it against an explicit constraint ledger. Because editing has no single ground-truth repair, we do not imitate teachers directly: RefineCut replays every multi-teacher branch through the verifier and keeps verifier-best repairs as supervision. A second stage, RefineCut-Evo, lets the student score its own repairs with the verifier and a task rubric and trains on high-margin preference pairs, so the final $8$B planner runs in a closed verifier loop with no teacher calls at inference. On RefineCut-Bench ($3{,}578$ tasks, $7{,}971$ captioned clips, $499$ music tracks, explicit ledgers), verifier-replayed distillation lifts the planner from $0.620$ to $0.858$ on the protocol-specific Video-Editing Score and RefineCut-Evo reaches $0.924$; the gain transfers to Llama-3.1-8B and GLM-4-9B, and in the same closed loop the $8$B planner matches or exceeds its frontier teachers. Code and RefineCut-Bench are publicly released; see the Data Availability statement.

1 Introduction

RefineCut frames real-world video editing as executable, constraint-checked planning over existing footage and introduces an open-weight planner trained through verifier replay and self-improvement. RefineCut-Bench and the resulting closed verifier loop support this planning-focused approach.

  • Problem formulation: Real-world editing requires selecting, trimming, ordering, transitioning, and synchronizing existing clips under duration, content, pacing, and soundtrack constraints.The output is a structured edit plan executed by a downstream rendering toolchain.
  • Problem formulation: RefineCut formalizes this decision layer as executable video-editing planning with briefs, real clip pools, optional beat-tracked music, timeline state, and explicit constraint ledgers.The planner emits structured RefinePatches that can be checked by a verifier.
  • Training approach: Verifier-replayed trajectory distillation converts noisy frontier-model traces into verified supervised targets and mixed-granularity preference pairs instead of imitating a single repair.Canonical normalization and deterministic replay retain verifier-best candidate branches.
  • Training approach: RefineCut-Evo trains self-improvement with DPO on student-generated repair candidates scored by a deterministic verifier and task-specific rubric.The method uses high-margin preference pairs for verifier-centered, rubric-structured optimization.
  • Contributions and results: RefineCut-Bench provides a planning-level benchmark with real clip and music metadata, explicit constraint ledgers, and multi-teacher trajectories.Across Qwen3-8B, Llama-3.1-8B, and GLM-4-9B, verifier replay beats raw imitation, while the final 8B planner matches its frontier teachers in the same closed loop.

2 Task and Benchmark

RefineCut frames video editing as executable planning over captioned clips, music metadata, typed timeline patches, and explicit constraints checked by a deterministic verifier. RefineCut-Bench packages this task with real assets, canonical tasks, multi-teacher trajectories, and verifier-based evaluation.

  • Task definition: RefineCut plans executable edits from natural-language intent and textual clip captions or metadata, while downstream tools render the final video.The planner does not observe pixels; it operates on captions and visual metadata produced upstream.
  • Task definition: A RefinePatch applies machine-checkable edits to a typed timeline state containing clips, durations, transitions, music synchronization, placeholders, and ledger satisfaction.Typed JSON-Patch-style edits support deterministic application and checking, including placeholder slots for absent content.
  • Task definition: Seven ledger families specify duration, transitions, music synchronization, clip inclusion or exclusion, repeat limits, and pacing requirements.Generated-placeholder requirements are represented as task-structure constraints checked by the same verifier.
  • Evaluation principles: Evaluation first gates schema, patch, and timeline validity, then verifies constraint satisfaction, clip grounding, duration, pacing, and convergence before human-rendered quality assessment.The first two layers are decided entirely by the deterministic verifier; rendered quality covers instruction fit, relevance, coherence, continuity, pacing, rhythm, and overall quality.
  • RefineCut-Bench: RefineCut-Bench contains 7,971 captioned clips, 23,913 caption-anchored frames, 499 music tracks, and 3,578 canonical tasks across three families and 15 subtypes.The benchmark combines real clip and music metadata, explicit constraint ledgers, multi-teacher trajectories, and a deterministic verifier.
  • RefineCut-Bench: Because editing lacks a single ground-truth repair, teacher branches are noisy; the ledger enables their canonicalization and verifier replay instead of direct imitation.The released trajectories come from GPT-5.4, Qwen3-Max, and DeepSeek-V4-Pro, with several candidate branches emitted at each refinement step.

3 Method: Verifier-Replayed Distillation and Verifier-Centered Self-Improvement

RefineCut combines verifier-replayed teacher distillation with verifier- and rubric-scored self-improvement to train an executable video-editing planner. At inference, the planner repeatedly emits patches and receives deterministic verifier feedback without teacher calls.

  • Offline learning: RefineCut’s two offline stages canonicalize multi-teacher trajectories, replay candidate branches through the verifier, and train an initial 8B planner before RefineCut-Evo self-improvement.Stage 1 produces verified SFT targets and mixed-granularity preference pairs; Stage 2 samples K=4 student repairs and scores them with the verifier and rubric ER1–ER7.
  • Verifier-replayed distillation: Each teacher-covered task receives one refinement rollout from GPT-5.4, Qwen3-Max, and DeepSeek-V4-Pro, while verifier selection—not teacher first choice—determines training targets.The method records each teacher’s first-choice flag but does not treat it as ground truth.
  • Verifier-replayed distillation: The verifier replays up to four distinct branches per canonicalized step and scores constraint change, targeted repair, clip recall, applicability, noregression, and locality.Canonicalization maps heterogeneous teacher outputs into patch trajectories with standardized JSON Pointer paths and validated task-local clip aliases.
  • Verifier-replayed distillation: Verified SFT keeps an applicable verifier-best branch that repairs a violation without regressions, while Mixed-Pref pairs it against a lower-scoring executable branch.Preferences come from verifier replay rather than LLM judgments, producing the Mixed-Pref checkpoint.
  • Verifier-centered self-improvement: RefineCut-Evo samples K=4 RefinePatches, filters failures, combines verifier and ER1–ER7 rubric scores, and trains DPO on hard-negative pairs from Mixed-Pref.The rubric covers Intent, Ledger Satisfaction, Clip Grounding, Timeline Coherence, Duration/Pacing, Music/Beat, and Edit Economy.
  • Runtime loop: At test time, the planner emits one RefinePatch from the violated ledger state, and the verifier validates, applies, and recomputes it for at most T=3 steps without teachers.The resulting final state is dispatched to the editing toolchain.

4 Experiments

Experiments show that verifier-replayed supervision substantially improves executable video-editing planning, while RefineCut-Evo adds targeted gains in whole-plan completion. These results transfer across backbones, task splits, instruction styles, and rendered-preview evaluation.

  • RQ1: Training progression: Verifier-replayed SFT lifts VES from 0.620 to 0.858, while RefineCut-Evo reaches 0.924 after preference training over verifier-scored repairs.VES is computed by the same frozen ledger and verifier used for replay and closed-loop feedback, making it an in-protocol measure.
  • RQ2: What Evo adds: HARDPASS rises 0.670→0.820, DUR@2S 0.830→0.980, and CONVERGED@3 0.800→0.950 from Mixed-Pref to RefineCut-Evo.Distillation primarily teaches executable edits, whereas Evo improves completion of plans satisfying the full brief.
  • RQ1: Verifier-replayed supervision: Verifier-best supervision yields VES 0.858 from 3,317 examples, versus 0.620 from teacher-selected imitation using 9,690 examples.Teacher branches usually apply cleanly but rarely satisfy the whole ledger in one step, making first-choice imitation weak supervision.
  • RQ4: Comparison with frontier policies: RefineCut-Evo exceeds GPT-5.4 by +0.030 VES and Qwen3-Max by +0.150, ties DeepSeek-V4-Pro at −0.012, and matches the best Converged@3 locally.Four newer frontier policies score 0.933–0.943 under the same contract.
  • Robustness and instruction style: On canonical-clean, Evo scores 0.917 versus 0.859 for Mixed-Pref; on Human50, it scores 0.902 versus 0.848, staying 0.054 ahead.The ranking remains unchanged on the held-out split and on free-form briefs written by unaffiliated contributors.

5 Conclusion

RefineCut treats video editing as a checkable planning problem, using explicit constraints, executable timeline patches, and a deterministic verifier. The verifier also supports training by converting candidate branches into verified supervision and enabling continued improvement with RefineCut-Evo.

  • Conclusion: RefineCut frames video editing as a planning problem whose outputs can be checked.Its design centers on machine-checkable requirements and executable edits.
  • Conclusion: An explicit constraint ledger turns each brief into machine-checkable requirements.The ledger provides the requirements that the verifier checks.
  • Conclusion: A typed timeline with RefinePatch operations makes the planned edits executable.RefinePatch operations provide the structured editing mechanism within the typed timeline.
  • Conclusion: Replaying every candidate branch with the deterministic verifier turns noisy multi-teacher traces into verified supervision.The verifier is used directly as part of the training process rather than only for output checking.
  • Conclusion: RefineCut-Evo continues improving through the verifier-based training loop.The supplied passage identifies RefineCut-Evo as the continuation of the verifier-driven improvement process.

Limitations

RefineCut is limited to structural executable edit planning: its verifier cannot assess taste or narrative impact, and VES is an in-protocol rather than independent absolute quality measure. Results are also bounded by upstream metadata quality, limited generalization evidence, and offline preference training.

  • Planning-layer scope: The verifier checks schema validity, ledger satisfaction, and duration control but cannot judge whether a cut is tasteful or whether a story lands.Those qualities require rendered-preview evaluation.
  • Planning-layer scope: VES is an in-protocol measure because the verifier supplies both training-time replay and closed-loop feedback.It should not be interpreted as an independent absolute quality score.
  • Upstream perception: Planner quality can be bounded by errors in upstream captions, motion metadata, and music metadata because it reads metadata rather than raw pixels.Controlled semantic-field ablations show textual clip-semantic use but do not establish robustness to real captioners, captioner variation, or raw-pixel perception.
  • Generalization and future work: Evidence covers three model families in the compact 8B–9B regime, three editing-task families, and one primary asset pool, while preference stages train only on Qwen3-8B.RefineCut-Evo is an offline DPO stage rather than a full EvoLM reproduction or online RL, and absolute transfer scores remain below it.
  • Generalization and future work: RefineCut-Bench task briefs and constraint ledgers are LLM-generated under controlled templates.This design constrains the benchmark’s task-generation setting.

Ethical Considerations

RefineCut addresses planning-level video editing, but executable edit plans could enable misleading or undisclosed synthetic edits. Its verifier checks structural correctness rather than factual accuracy, fairness, or social appropriateness, motivating provenance tracking, misuse detection, and oversight.

  • RefineCut targets planning-level editing, yet executable plans could be misused to omit context, create misleading edits, or insert synthetic content without disclosure.The plans can connect to rendering or generation tools.
  • The verifier checks structural correctness, not factual accuracy, fairness, or social appropriateness.The authors frame RefineCut as a research framework for verifier-guided planner training.
  • The paper encourages future work on provenance tracking, misuse detection, and oversight.

Declaration of Generative AI Usage … B.2 Frame Sampling and Captioning

The appendix documents responsible AI use, positions RefineCut among video-generation, workflow, trajectory-learning, and rubric-guided methods, and specifies benchmark construction and caption-driven frame sampling. The planner operates on released caption metadata rather than pixels, with provenance and motion information recorded per clip.

  • Declaration of Generative AI Usage: Authors used AI assistants for polishing, formatting, consistency checking, and coding, while manually verifying and approving all claims, analyses, citations, and final decisions.AI tools did not generate experimental results or automatically validate references.
  • A.1 AI-Assisted Video Editing and Generation: Video-generation research creates or modifies visual content, while trailer, montage, and mashup systems address editing-oriented creation.The cited work spans text-to-video, image-to-video, instruction-based editing, and trailer, montage, and mashup systems.
  • A.2 Workflow Decomposition for Multimodal Creation: Hierarchical multimodal systems decompose complex video creation into staged professional roles such as screenwriting, directing, storyboarding, designing, and generating.DIRECT, LVAS-Agent, and StoryAgent exemplify role-based workflow decomposition.
  • A.3 Tool-Executable Planners from Trajectories: Tool-executable planning research studies agents that reason, act, or revise through trajectories, with training methods improving behavior from interaction and tool-use traces.The supplied examples include ReAct, Self-Refine, Reflexion, AgentTuning, AgentBank, and AgentGym.
  • A.4 Rubric-Guided and Verifier-Guided Self-Improvement: RefineCut adapts rubric-structured self-improvement to executable video-editing planning, using verifier replay to create supervision and DPO to optimize paired repairs.The passage distinguishes RefineCut’s verifier-grounded supervision from alternative preference objectives left for future work.
  • B RefineCut-Bench Construction Details: RefineCut-Bench construction comprises asset collection, captioning, task generation, ledger design, clip-pool sampling, teacher trajectories, and a canonical-id split.The main benchmark overview appears in Figure 2.
  • B.1 Asset Pool and Caption Sources: The asset pool contains 7,971 captioned clips from five public sources, with structured fields and per-row captioner provenance recorded in model_used.The supplementary artifact records the exact model_used distribution.
  • B.2 Frame Sampling and Captioning: Adaptive sampler v2 uses optical-flow motion intensity to select 3, 5, or 7 frames, while the planner reads caption fields and released per-row model_used configurations instead of pixels.Motion buckets are stored in motion_intensity for downstream task generation.

B.3 Task Generation … C Schemas and Interfaces

The appendix defines how RefineCut tasks, constraint ledgers, clip pools, teacher trajectories, dataset splits, licensing, and interface schemas are constructed. These components specify valid planning inputs, repair supervision, evaluation organization, release conditions, and verifier-facing artifacts.

  • B.3 Task Generation: Tasks are LLM-generated from sampled clip pools, family and subtype slots, and family-conditioned ledger templates, with records separating identity, briefs, planner inputs, and subtype structure.
  • B.4 Constraint Ledger Design: Constraint ledgers explicitly specify successful cuts through 14 fine-grained types grouped into seven editing-requirement families.The families cover duration, transition, music synchronization, clip inclusion, clip exclusion, repeat limits, and pacing.
  • B.4 Constraint Ledger Design: Every ledger contains at least four items, always includes target_duration, and checks generated-placeholder requirements separately from field-level constraints.
  • B.5 Clip-Pool Sampling: Clip pools contain 30–60 sampled clips when the candidate pool has at least 30 items, otherwise the entire candidate pool is used, and ledger clip requirements reference existing clips.The verifier flags any planner reference to a clip_id outside the provided clip_pool as invalid.
  • B.6 Teacher Trajectory Generation: For teacher-covered canonical tasks, trajectories are collected from GPT-5.4, Qwen3-Max, and DeepSeek-V4-Pro, with each refine step requiring exactly four RefinePatch branches.Each branch carries operations, ledger-grounded rationale, and structured repair information.
  • B.7 Splits and Canonical IDs: Raw records are deduplicated into canonical task IDs and split into train/dev/test sets of 2,773/596/591 records.Among 591 test records, 518 are canonical-clean and 73 overlap train by canonical ID; the Common-100 intersection contains N = 92 canonical-clean records.
  • B.8 Licensing and Intended Use: Public clip sources permit research use, while music tracks and some in-house clips remain private; RefineCut-Bench and the training/inference code are slated for CC BY-NC 4.0 release upon acceptance.Derived artifacts inherit the research-only restriction of their source assets.
  • C Schemas and Interfaces: The five interfaces formalize planner patches, terminal timelines, ledger entries, verifier outputs, and Evo rubric scores through JSON schemas and worked examples.Illustrative fields include selected sequences, segment durations, transitions, music synchronization, constraint satisfaction evidence, verifier validity flags, and ER1–ER7 aggregate scoring.

D Metric Definitions

The paper separates execution-gate metrics, terminal planning-quality metrics, and fixed weighted scores for evaluating executable video-editing plans and repair branches. It also defines convergence and sensitivity-analysis protocols for closed-loop evaluation.

  • Execution Gate: Execution gates measure schema parsing with SCR, clean patch application with PASR, and renderer-accepted Timeline IR serialization with TIMELINEVALIDITY.These metrics assess whether a proposed patch can be parsed, applied, and serialized into a renderable timeline.
  • Planning Quality: Planning quality includes terminal ledger satisfaction through FINALCSR and HARDPASS, targeted ledger repair, required-clip recall, valid-clip precision, duration tolerance, and stepwise non-regression.CONVERGED@3 requires FINALCSR ≥0.8 within T=3 closed-loop steps.
  • VES: VES is a fixed weighted sum assigning 0.15 each to HardPass, PASR, and FinalReqClipRecall; 0.10 each to DurationPass and TimelineValidity; and 0.05 to NoRegression.The weights define the paper’s aggregate Video-Editing Score.
  • Branch-score signals: Replay branch scores combine ∆CSR, TARGETEDREPAIR, REQCLIPRECALL, PASR, NOREGRESSION, and LOCALITY for each applied candidate branch.Unlike terminal planning-quality metrics, these signals are evaluated on one branch after applying its patch.
  • Branch score weights: Branch-score weights are (w1, w2, w3, w4, w5, w6) = (0.35, 0.20, 0.20, 0.10, 0.10, 0.05), applied in signal order.The order is ∆CSR, TARGETEDREPAIR, REQCLIPRECALL, PASR, NOREGRESSION, and LOCALITY.

E Training Details · F RefineCut-Evo Details

Training uses verifier-grounded supervision and preference optimization, culminating in RefineCut-Evo’s rubric-margin DPO. The pipeline specifies candidate generation, deterministic scoring, pair filtering, decoding, and matched implementation budgets.

  • E Training Details: Verified SFT uses 3,317 verifier-best examples for up to 1,200 steps, with learning rate 5e−5, per-device batch 2, and gradient accumulation 8.It trains with next-token cross-entropy on canonicalized patches.
  • E Training Details: RefineCut-Evo DPO runs for 600 steps at learning rate 1e−6 and β = 0.05, initialized from Mixed-Pref, with step 300 selected on dev100 VES.The intermediate checkpoint is selected on development Video-Editing Score.
  • E Training Details: The core pipeline consumes approximately 14.5 GPU-hours on one NVIDIA A100, while including Raw SFT totals 23.5 GPU-hours.Verified SFT, Mixed-Pref, and RefineCut-Evo consume approximately 7.5, 2.1, and 4.9 hours respectively.
  • E Training Details: Closed-loop evaluation uses R=1 greedy decoding, whereas R=4 verifier reranking of the untrained backbone serves as a frozen-protocol search control.R is the inference-time sampling or reranking pool and differs from the training candidate count K=4.
  • F RefineCut-Evo Details: RefineCut-Evo generates K = 4 candidates across 1,500 training states, producing 6,000 candidates with JSON parse success 0.9968 and patch-apply success 0.9960.The resulting preference construction uses 779 rubric-margin pairs oversampled to 1,651 training rows.
  • F RefineCut-Evo Details: The joint pair-construction score is S(c) = 0.65V(c) + 0.35R(c), while verifier and rubric scores correlate at ρ = 0.94.Mean rubric score is 0.67 with standard deviation 0.13; deterministic proxies support ER1 and judge-side ER3.
  • F RefineCut-Evo Details: 779 chosen / rejected pairs survive a fixed margin threshold, with mean margin 0.18, median margin 0.19, and hard-negative rate 0.987.The training set is oversampled to 1,651 rows, while 635 states fall inside the margin band and are skipped.
  • F RefineCut-Evo Details: Verifier-only DPO reaches 0.909 VES versus 0.924 for the full method, while rubric-structured scoring adds 0.015; temporal-contrast training uses 0 pairs.The ablation attributes the main signal to verifier-scored student self-improvement and the added gain to rubric-structured deterministic scoring.

G Additional Results

Additional experiments show that verifier-grounded training transfers across backbones, outperforms same-loop prompting and search, and produces selective repairs with few degradations. Analyses further characterize semantic-input sensitivity and alignment between verifier margins and blind judgments.

  • Same-loop teacher and frontier policies: Newer frontier policies reached 0.940 (gpt-5.4mini), 0.943 (Qwen3.5-397B), and 0.936 (its workflow-reflection variant) in the identical closed loop.The comparison used the same typed state, ledger, patch schema, verifier feedback, T=3 budget, and CSR≥0.8 stopping rule, without weight updates.
  • Prompting, feedback, and search: +0.090 VES came from verifier feedback over direct prompting, while +0.054 came from R=4 reranking over R=1 sampling on the untrained backbone.The visited-pool oracle still remained 0.212 VES below RefineCut-Evo, with 95% CI [0.170, 0.252].
  • Evo-degraded tasks: Four of five Evo-degraded tasks preserved execution, duration, and convergence while missing exactly one constraint entry.The remaining family-C task had patch applicability 0.33 and a duration overshoot.
  • Plan statistics and reward-hacking diagnostics: RefineCut-Evo’s mean duration deviation fell from 1.55 s (Mixed-Pref) to 0.34 s, with invalid clip references and over-rewrites at 0 and no-regression at 1.0.The accompanying diagnosis attributes improvement to fewer, more selective edits rather than longer outputs.
  • Semantic-input intervention: Removing all clip semantics reduced VES to 0.8502, while shuffling semantic descriptions reduced it to 0.7241.Removing only the short caption yielded 0.9190, indicating that structured subject, action, scene, and motion fields retained most performance.

H Human Evaluation and Human-Written Brief Validation … K Worked Example

The appendix documents blinded human evaluation, validation on 50 human-written briefs, the pipeline’s prompt specifications, deterministic verifier rules, and a worked verifier-replay example. The example shows verifier selection of a repair that satisfies all ledger items while rejecting a duration-only hard negative.

  • H Human Evaluation and Human-Written Brief Validation: Human evaluation used blind randomized A/B rendered-storyboard previews with 150 judged pairs and three annotators per pair.Preference score was defined as (W + 0.5T)/N for the first model in each comparison.
  • H Human Evaluation and Human-Written Brief Validation: Human50 contains 50 independently written free-form briefs, whose ledger entries were revised by research assistants and validated by two professional video editors.The contributors included three vloggers and four editing students unaffiliated with the authors.
  • I Full Prompts: The pipeline prompts specify strict JSON schemas for task generation, clip captioning, frontier-teacher repair branches, closed-loop planning, rubric construction, and blind judging.The unified test-time planner emits one RefinePatch targeting violated ledger items without regressing satisfied items.
  • I Full Prompts: At test time, the unified PatchPlanner prompt requires RFC 6902 add/remove/replace operations on canonical current-state paths and references only valid clip IDs.It also requires rationale aligned with the operations and targets the violated subset without regressing satisfied items.
  • J Verifier Implementation: The verifier deterministically validates and applies each patch, recomputes the ledger, and emits gate signals plus branch-score components.Its denominator and aggregation rules avoid treating undefined clip-recall denominators as successes or failures.
  • K Worked Example: In the worked b_roll_insert example, the initial sequence [C001, C002] totals 15.4s against a 13s target, with required clips already present.The brief requires inserting a short b-roll cutaway between a close-up and a wide street shot.
  • K Worked Example: Branch 1 is selected because it inserts C007, fixes duration, preserves required clips, and changes only ledger-relevant fields; Branch 2 is the hard negative.After Branch 1, all four ledger items pass and the loop ends at step 1.
Loading 2608.25622v1…