Resolve Tighten Recording

Resolve Tighten Recording

Turns one long raw take into a tightened variant timeline. The variant is the deliverable; the original timeline is never touched.

Everything below was measured live against Resolve Studio 21.0.1.11 / MCP v2.80.1 on 2026-08-06, on a real 28.5-minute 30fps screen recording, unless a different date is given.

The deliverable contract

Deliver a tightened variant timeline, plan → review → confirm. Do not grade, caption, or add anything; a tighten is pure subtraction. The variant runs generous on purpose — recovering over-cut material is slow and invisible, trimming further is fast and visible.

Two things always go back to the editor with the variant:

• The largest lifts. A lift is only silence to the microphone. Measured on real material (2026-07-31): a 29s lift was 70% silent on-screen demonstration — real content, cut because nobody spoke over it. Anything over ~15s deserves a human look before the variant is trusted.
• What silence-driven tightening cannot hear — see the last section.

Workflow

1. Lift the analysis caps for long media — media_analysis set_caps_preset {preset: "unlimited"}. The standard preset carries a 90-second wall clock; multi-hour material dies on it. Restore standard when done (step 7).

2. Transcribe — media_analysis start_batch_job with {clip_id, vision: false, transcription: {enabled: true, ...}}, then run_batch_job_slice {job_id}. Two traps in one call pair:

   • Batch jobs do not advance themselves. start_batch_job returns a durable job in queued and nothing runs until a slice call drives it.
   • run_batch_job_slice blocks until the slice completes — budget roughly 4-7x realtime for local whisper (measured: 28.5min of Chinese speech in 5m14s via mlx_whisper) and run it from a background process, not the main conversation.

   Copy clip_id from media_pool probe_media_pool output. Never type it from memory: one transposed hex pair (measured 2026-06: b9ab → 9bab) fails every downstream call in ways that look like engine bugs.

3. Plan — edit_engine plan_tighten {timeline_name}. Dry run; nothing moves. min_pause_seconds raises the bar when the default cuts too fine-grained. The plan persists on disk — planning and executing in different sessions is fine.

4. Review with the editor: lift count, estimated removed seconds, and the largest lifts (sorted by duration). This is the approval gate the whole tool sequence exists for — do not skip it because the numbers look reasonable.

5. Execute — edit_engine execute_tighten {plan_id} returns a confirm_token (TTL 300s); re-call with the token. Both calls in the same MCP session is verified; a token across a server restart is not — don't bet on it.

6. Verify, in this order:

   • timeline detect_gaps_overlaps on the variant → must be 0 / 0.
   • readback.after.clip_count in the execute response ≈ 2× the video keep-range count when audio is mirrored (113 video + 113 audio = 226 measured). If it equals the video count alone, the variant is silent — stop and say so.
   • Spot-check placement with timeline clip_where {track_type, track_index} against the plan's keep ranges (coordinate rules below). clip_where reads the current timeline only — set_current to the variant first; it takes no timeline_name argument.
   • Total duration ≈ original − estimated_removed_seconds.

7. Clean up — restore set_caps_preset {preset: "standard"}, project_manager save, and list timelines: execute_tighten archives the source timeline once (_versioning.archived: true, by design), so a *_archived_vNN appears. Surface it; deleting is the editor's call.

Coordinate rules — the trap that assembles the wrong content

The plan and the execute response describe ranges in different coordinate systems, and both look like plausible frame pairs:

Feeding structural_diff.added numbers anywhere a source range is expected places every clip at the wrong moment of the right file — cut lengths stay correct, nothing errors, and the timeline renders. When any endpoint semantics are in doubt, place one range, read it back with clip_where, verify position + duration + source span, then batch the rest.

Multi-layer recordings

A camera track stacked over a screen-capture track (V1 + V2, same session) is common for tutorials. execute_tighten assembles only the analyzed source; the other layer is dropped from the variant, silently. To rebuild it:

1. Establish the constant offset between the two layers — and verify it by audio cross-correlation between the two source files (extract matching windows with ffmpeg, correlate; residual under 50ms passes). Eyeballing waveforms does not survive a 20-minute assembly.
2. Take the plan's keep_ranges (source frames), add the offset, and append with media_pool append_to_timeline clip_infos: {clip_id, start_frame, end_frame, record_frame, record_frame_mode: "absolute", track_index: 2, media_type: 1} (media_type: 1 = video only; keep the analyzed layer's audio).
3. Verify counts and first/middle/last placements before trusting it.

Multicam compound clips do not reach the transcription engine at all — a tighten on multicam material silently skips it. Keep plain stacked tracks and use the recipe above instead.

What silence-driven tightening cannot hear

plan_tighten measures the microphone, not the meaning. Three classes survive every threshold, and each needs a different instrument:

• Audible fillers and tight restarts — plan_transcript_tighten covers these at word level (fillers, immediate ≤4-word restarts under 0.6s, collapsible pauses) and emits the same keep_ranges shape. Note its filler set is English hesitation words; other languages pass through unflagged.
• Real retakes — a sentence re-read seconds later, or reworded. Out of scope for the heuristics by design ("a real re-take and a human should choose"). This is an editor pass over the transcript, not a tool call.
• Retakes whisper never even reports — an immediate re-read is often emitted once, with the pause and second take absorbed into one word's duration (issue #125). Neither the transcript nor any silence threshold can see these; on measured material they were the majority of what a human still had to cut by hand. Treat word timestamps near suspected retakes as soft.

Report all three as known limits when handing over the variant, instead of letting the tightened timeline imply "everything removable was removed".

Common mistakes

• Trusting detect_gaps_overlaps alone — it proves the assembly is gapless, not that the right frames were kept. Duration check and spot placement reads are part of verification, not extras.
• Verifying audio by "the response said success" — count the variant's audio items.
• Renaming the variant with a default name kept. Name it for the action (tightened, dead-air pass, a version tag) so a project with several passes stays readable.
• Cutting fine pauses on instructional material. A pause while the presenter operates the screen is pacing, not dead air — raise min_pause_seconds and review the big lifts instead.
• Leaving the caps preset on unlimited after the run.

Source-media safety (AGENTS.md)

The tighten pipeline reads source media and writes analysis artifacts to the analysis root only. The variant references existing Media Pool items — no transcode, no proxy, no relink, and the original timeline is archived by the tool, never mutated.