verify
Transcribe a finished render and diff it against the timeline to catch surviving retakes and dropped words.
Instructions
Transcribe a finished render and diff it against what the timeline says.
Run this after rendering, before calling an edit done. It transcribes the render with whisper and compares that word sequence to the one the timeline should play, which is the only check that catches a retake still in the picture: whisper collapses an immediate repeat into a single utterance, so a doubled phrase can be invisible in the source transcript and still be in the render.
Read repeated first — an entry there is a phrase the render plays more
times than the timeline expects, i.e. a surviving retake, with the heard word
index to look at. dropped is the opposite: words the timeline expects that
the render never says, usually a cut that reached too far.
A clean single-pass result is not proof. This check has a known blind
spot: the render's transcript is itself one whisper pass, which collapses a
repeat the same way the source transcript did — three retakes survived a
correct run of it on a real video. Set windowed=True to transcribe in
short overlapping windows instead, which is what found them. It costs one
whisper run over 2x the audio and uses a deliberately smaller model, so
run the default first and escalate to it before calling an edit finished.
loud_gaps comes back either way and trusts no transcript: it measures the
render's own energy and reports holes in the heard word map that hold sound
anyway. An entry is a place to listen, not a verdict — a music bed or an
attenuated noise can produce one. Read speech_db/threshold_db beside it.
similarity around 0.97 is normal on a clean render — whisper spells its
own output differently on a second pass ("whodunit" / "who done it", "4" /
"four"). Treat it as triage; diff is the artifact. Transcription takes
minutes on a long render, and the result is cached under
cache/verify/ and reported as heard_transcript — pass it back as
transcript_path to re-diff without re-transcribing.
Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | The project directory to act on. Omit it — the usual case — when this server is bound to a project (started as `proofcut -C DIR mcp`, or inside a project; `ping` says which): it then resolves to that one bound project, a relative path resolves against it, and a path outside it is refused by name. Unbound, `path` is the whole address and omitting it refuses rather than guessing. | |
| model | No | The whisper model for the single-pass transcription. | |
| render | Yes | The finished render to transcribe and diff against the timeline. The expected words include a sound's or an inset's own when its clip has a transcript (`placed_audio`) — a narrator take placed as a sound is the film's voice. A voice sound (`ducks`) with no transcript is listed in `voice_sounds_untranscribed` and not checked: transcribe it first. | |
| window | No | Length of each window in the windowed pass, in seconds. | |
| clip_id | No | Diff against one transcript's expected words rather than all of them. | |
| overlap | No | How far each window overlaps the one before, in seconds. | |
| language | No | Force a language code for it. | |
| windowed | No | Transcribe in short overlapping windows instead of one pass. **A clean single-pass result is not proof** — one pass collapses an immediate repeat the same way the source transcript did, and three surviving retakes passed a correct single-pass run on a real video. It costs a run over twice the audio and a smaller model. | |
| transcript_path | No | An existing transcription of `render` — what a previous run cached and reported as `heard_transcript`. Pass it back to re-diff without spending the minutes again. |
Output Schema
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||