v0.45.0: any model in the panel, and video inside graphics

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.44.0: any model in the panel, and video inside graphics.

• The agent panel runs on any OpenRouter model. Type a model id with a
  / in it, like openai/gpt-5.5, and the panel drives the edit through
  that model with your OPENROUTER_API_KEY. It keeps multi-turn
  conversations, a Stop button, pictures for models that can see, and a
  budget cap. Claude stays the default. No OpenRouter model has been scored
  on a full edit yet, so treat this as a way to try them, not a
  recommendation.
• A graphic can show your footage. graphic_new and graphic_edit take
  spans of project clips and cut them into the graphic's folder, so a page's
  <video> can be a picture-in-picture of your own recording. proofcut
  serves each frame itself, so every captured frame is the exact frame
  ffmpeg decodes at that time, and nothing drifts or plays on the wall
  clock.
• That video keeps playing through the hold. A graphic placed longer
  than its animation used to freeze its video at the hold. Now the video
  plays on through the hold and the outro picks up where it left off, so
  you place the graphic over the span you want and never size it by hand.
• A page can make a frame wait until it is ready. Hand a promise to
  window.proofcutWaitFor(promise, label) and each frame waits for it. A
  page that loads data or does slow setup is no longer captured blank for
  its first frames. A font that fails partway through is caught and the
  capture refused, instead of being drawn in a fallback.
• Mac renders stop crashing. melt crashed now and then on Apple Silicon
  and Intel Macs, from a locale race inside MLT. proofcut now renders in a
  way that never triggers it: 0 crashes in 60 soak runs, against 9 in 69
  before. A fix for the race is merged upstream in MLT.
• Whisper falls back to the CPU when the GPU runs out of memory,
  instead of failing the transcription.
• proofcut web says when its port is taken and exits cleanly instead
  of tracing, on Windows as well.

v0.44.0: less waiting, and more caught before the render

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.43.0: less waiting, and more caught before the render.

• The models remember what they already said. Whisper, the vision model
  and the face detector keep their answers in one store outside every
  project, keyed by the media's content and what the model was asked. A
  second project on the same shoot, or a fresh start on the same footage,
  pays no model time. proofcut doctor shows the store, and
  proofcut setup --clear empties it.
• Render on an unchanged edit, and the file comes back at once. When
  nothing has moved since the last render, the window hands back that file
  and runs only the checks.
• A retake the cut kept is named before you render. transcript_checks
  now reads the words the timeline will play and points at any line said
  twice back to back, with both takes' word ranges ready to cut. It lists
  candidates, not verdicts: a script that repeats a line on purpose reads
  the same.
• Animated graphics that run on their own clock just work. A page that
  animates from requestAnimationFrame, performance.now or Date now
  draws the right frame at every instant, without the seek hook it used to
  need. A page that draws nothing at all, usually a script that failed, is
  refused at capture instead of going over the film as a blank.
• Every render says what made it. The render log records a fingerprint
  of the file and the proofcut, melt and ffmpeg versions that wrote it,
  beside the edit it was made from.
• Bookmarks on the ruler. Drop one at the playhead and jump back to it.
  A bookmark sits on the recording, so cutting around it never moves it.
• A melt that crashes is run again. On the Macs, melt now and then died
  mid-render and a plain re-run passed. proofcut retries it twice and says
  so, and a render that still fails reports melt's own error.
• A logo.

Where it runs. Nothing changed since v0.43.0: Linux is where proofcut was
built and measured. An Intel Mac, a Windows laptop and GitHub's Windows and
Apple silicon runners each take the demo to a checked render. No person has
run it on Apple silicon by hand yet, and that is still the report worth
having (issue #1).

Start with docs/DEMO.md.
It takes two minutes and runs on media the repo generates itself. If
proofcut doctor shows a ✗ on your machine, that output is the most useful
thing you can send.

v0.43.0: captions, motion, stickers, transitions, and shorts from a pile

clip.mp4

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.38.0, the film can look like a short. Five releases of captions
that animate, graphics that move, stickers, transitions, and a way to turn a
pile of recordings into several shorts at once.

• A pile of recordings becomes several shorts. seed takes several
  recordings and lays them end to end, each with its silences cut. Cut the
  retakes once, then split the timeline by each short's first and last
  word. Every short becomes its own project beside the pile, holding only
  the recordings it uses. Two shorts sharing material, and any stretch no
  short took, are reported rather than refused.
• Captions reveal word by word. Each word can fade or blur in as it is
  spoken. A span of the film can have captions off, or a look of its own,
  such as one large word at a time. The project's list of words whisper
  mishears, and how each is spelled, now corrects what captions print, and a
  caption look can be saved and loaded into another project.
• Animated graphics. A graphic is a web page an agent writes or fills
  from a template (typing, a highlighter sweep, a letter build, chips),
  captured frame by frame by a headless browser and placed over a span of
  words. It animates in, holds as long as the span lasts, and animates out,
  so a cut never breaks one. proofcut setup installs the browser, and a
  saved graphic carries across projects.
• Stills and stickers. A photo goes in once, upright, whatever its
  camera said. It plays full frame, or rides over the film as a sticker:
  placed, sized, turned, framed as a photo card, popping or sliding in.
  Paste an image into the agent's prompt and it is added.
• Transitions between shots. A crossfade between two pieces of b-roll, a
  scale punch on a cut, and a vignette, all drawn in the preview as the
  render draws them.
• One agent per project. A second agent session is refused a project
  another one is editing, rather than both writing to it. proofcut unlock
  clears a session that died.

Where it runs. Linux is where proofcut was built and measured: from a
bare Ubuntu 24.04 and a bare Fedora 44, following only the docs, the demo
reached a verified render. Intel Mac: one person ran the test kit on
their own Mac, and it reached a checked render: all 34 words heard back, 289
of 289 frames, the master at −16.1 LUFS
(issue #6). Windows:
the author's laptop and GitHub's runner both take the demo to a checked
render, and nobody else has tried it yet
(issue #2). Apple
silicon: GitHub's arm64 runner installs proofcut with setup and takes the
demo to a checked render, on a machine that starts with none of the four
tools. No person has run it by hand, and that is still the report worth
having (issue #1). One
script runs the whole test and removes what it installed.

Start with docs/DEMO.md.
It takes two minutes and runs on media the repo generates itself, so there is
nothing to download and no licence question. If proofcut doctor shows a ✗
on your machine, that output is the most useful thing you can send.

v0.38.0 — setup on Apple silicon

clip.mp4

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.37.0, the Mac install is one command on either chip.

• proofcut setup installs on Apple silicon. It used to refuse there and
  point you at doctor's advice, because the route was assumed to be
  Homebrew and nothing had measured it. It is not Homebrew: it is the same
  pinned downloads an Intel Mac gets, with each file's arm64 build in its
  place — an ffmpeg with libass and libx264, auto-editor's release binary,
  and Shotcut's melt, whose macOS build turned out to be universal already.
  No sudo, no admin password, no package manager, one folder, and
  proofcut setup --uninstall removes exactly what it added and nothing you
  already had. proofcut setup --plan still prints every piece and its size
  before anything is fetched.
• A platform's safe zone can be drawn over the frame. On a vertical
  canvas the window offers a guide showing where TikTok, Reels or Shorts put
  their own captions and buttons over your picture. It is the same geometry
  the card report measures ink against, so the guide on screen is the region
  the check reads, and it is never in the render.
• undo takes --steps. An agent's turn is many snapshots, one per
  operation, and walking it back was that many blind calls. undo --steps N
  rolls back N in one, refuses a count it cannot honour before restoring
  anything, and --plan shows what would come back without writing. undo
  with no arguments is what it was.
• The unattended-run score checks for a stutter. A cut that leaves a
  phrase repeated is something every other check passes and a viewer hears
  immediately, so the trial now fails a run of two or more words repeated
  inside a six-word window.

Where it runs. Linux is where proofcut was built and measured: from a
bare Ubuntu 24.04 and a bare Fedora 44, following only the docs, the demo
reached a verified render. Intel Mac: one person ran the test kit on
their own Mac, and it reached a checked render: all 34 words heard back, 289
of 289 frames, the master at −16.1 LUFS
(issue #6). Windows:
the author's laptop and GitHub's runner both take the demo to a checked
render, and nobody else has tried it yet
(issue #2). Apple
silicon: GitHub's arm64 runner installs proofcut with setup and takes the
demo to a checked render, on a machine that starts with none of the four
tools — but no person has run it by hand, and that is still the report worth
having (issue #1). One
script runs the whole test and removes what it installed.

Start with docs/DEMO.md.
It takes two minutes and runs on media the repo generates itself, so there is
nothing to download and no licence question. If proofcut doctor shows a ✗
on your machine, that output is the most useful thing you can send.

v0.37.0 — the score, and the second take

clip.mp4

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.36.0, the film has a score and a second take. v0.36.0 gave the
film the grammar a launch clip uses; this release is about what you hear, and
about joining two recordings into one film.

• A second recording follows the first, through a dissolve. follow joins
  two takes end to end, and dissolve crossfades the join out of the incoming
  clip's own pre-roll — the seconds of it before its in-point — so the film is
  no length longer for the transition and every declared length stays the
  edit's.
• The score takes a level of its own. A bed can level to a loudness target
  where there is no voice for it to sit under, play on under the end card, and
  fade across the film's last frames rather than after them. A bed can also be
  passages rather than one cue, rotated and crossfaded, and addressed by a
  named event in the footage instead of a timestamp.
• The duck hears every lane. The bed now dips for audible insets and for
  one-shot sounds marked to duck, each gated against its own loudness — not
  only for the voice — so a screen recording with sound still pushes the music
  down. A sound can be trimmed to a slice of its file, and trimming it
  re-rolls no other hit.
• An inset can be levelled to a measured speech level, recorded once as
  its gain rather than guessed at per render.
• A lower third's footnote is its own layer, entering after the headline
  and rising less than it does.
• A head or tail on a project with no cues goes on the edit's own track, so
  a cold open or an end card no longer needs a picture cue to hang from.
• A/B review rounds. proofcut review states the question, says what each
  clip is, and takes one answer, over a page that needs no JavaScript and
  carries its own token — made for deciding between two cuts on a phone.
• The install says what it costs before it does anything.
  proofcut setup --plan prints every piece it would fetch, its size, and
  which doctor row asked for it, then stops without touching your machine.
  § What it puts on your machine
  is the whole footprint — where each piece goes and the command that removes
  it. The two-minute demo no longer needs espeak-ng installed either: it
  synthesises its voice from the same library as a wheel uv fetches, so
  building the demo asks for no package manager.

Fixed. The review page's inline stylesheet was blocked by its own
Content-Security-Policy, so it drew unstyled on a phone with every test green.
A caption burn onto its own render is refused by name instead of destroying
the file. cut_by_time names a span past a retimed render rather than
returning an empty interval.

Where it runs. Linux is where proofcut was built and measured: from a
bare Ubuntu 24.04 and a bare Fedora 44, following only the docs, the demo
reached a verified render. Intel Mac: one person ran the test kit on
their own Mac, and it reached a checked render: all 34 words heard back, 289
of 289 frames, the master at −16.1 LUFS
(issue #6). Windows:
the author's laptop and GitHub's runner both take the demo to a checked
render, and nobody else has tried it yet
(issue #2). Apple
silicon: nobody has run it by hand
(issue #1). One script
runs the whole test and removes what it installed.

Start with docs/DEMO.md.
It takes two minutes and runs on media the repo generates itself, so there is
nothing to download and no licence question. If proofcut doctor shows a ✗
on your machine, that output is the most useful thing you can send.

v0.36.0 — setup on Windows and Intel Macs

clip.mp4

proofcut is an AI video editor that proves its cuts. It is an MCP server
over ffmpeg, whisper, MLT and OpenTimelineIO. An agent, the proofcut
command line, or the browser window takes your recordings and returns a
finished, mastered film: cut by transcript, with b-roll hung off the words,
cards, captions, and a score under the voice. It renders on your own machine,
then transcribes the render and checks that it says what the edit says.
It is source-available under PolyForm Shield 1.0.0: any use is allowed except
building a product that competes with it.

Since v0.25.0, the film can move. v0.25.0 finished the film; these
releases give it the grammar a launch clip uses:

• Speed ramps. A retime plays a stretch of the film, from one word or
  event to another, in however many seconds you give it. The audio is muted
  wherever the speed is off 1x.
• Camera moves that follow what happens. A framing window can be
  addressed by an event in the footage rather than by a timestamp, and it
  can slide there with an easing curve.
• Overlays and insets. A transparent card can ride over the picture, and
  a clip can play inside a rectangle of another recording, following that
  recording's camera as it moves.
• Sounds on events. A one-shot sound can be placed at a word, a phrase or
  an event, or at every event with one name (a keystroke on each key press,
  for example), and a cut re-rolls none of the others.
• Blur-fill. A wide shot in a tall frame shows the whole picture over a
  blurred copy of itself instead of being cropped.
• A cheaper agent. The MCP server's 92 tools now load on demand, so a
  turn that pinged the server costs about a tenth of what it did. Long tools
  report progress, Stop reaches a render that is already running, and
  changes says what the last edits did.
• An easier install. uvx proofcut doctor runs straight from PyPI with
  no git needed, and it prints the fix under anything missing.
  proofcut setup installs what doctor marked ✗, for you alone and with no
  sudo or administrator rights, and --uninstall removes exactly what it
  added. It works on Linux, on Windows and on an Intel Mac. Each of the
  latter two was measured from a machine with none of proofcut's tools on it:
  setup installed all four, the demo rendered, and every check passed.

Where it runs. Linux is where proofcut was built and measured: from a
bare Ubuntu 24.04 and a bare Fedora 44, following only the docs, the demo
reached a verified render. Intel Mac: one person ran the test kit on
their own Mac, and it reached a checked render: all 34 words heard back, 289
of 289 frames, the master at −16.1 LUFS
(issue #6). Windows:
the author's laptop and GitHub's runner both take the demo to a checked
render, and nobody else has tried it yet
(issue #2). Apple
silicon: nobody has run it by hand
(issue #1). One script
runs the whole test and removes what it installed.

Start with docs/DEMO.md.
It takes two minutes and runs on media the repo generates itself, so there is
nothing to download and no licence question. If proofcut doctor shows a ✗
on your machine, that output is the most useful thing you can send.

v0.25.0 — the whole film

clip.mp4

proofcut, the local-first AI video editor. It is an MCP server over
ffmpeg, whisper and OpenTimelineIO. An agent, the proofcut command line, or
the browser window takes your recordings and returns a finished, mastered
film: cut by transcript, with b-roll hung off the words, a score under the
voice, cards, captions, and a master at a loudness target. It renders on your
own machine, then transcribes the render and checks that it says what the
edit says. Source-available under PolyForm Shield 1.0.0: any use except
building a product that competes with it.

This release finishes the film. Until now proofcut cut well and stopped
at the render.

• Score it. A music bed takes placed passages, a rotation and crossfades,
  and it ducks under the voice — gated on the timeline's own audio rather
  than on transcript words, which was measured the better of the two (3.39 dB
  against the audio gate's 2.72; no duck at all was 3.62).
• Master it. export --loudness hits a loudness target with one gain and
  a true-peak limiter. It deliberately does not use loudnorm's second pass,
  which rode the mix and put 5 dB of the duck back at exit 0.
• Hold the film's own audio under the narration, or in a gap, addressed by
  a phrase rather than by word indices.
• An agent does all of it unattended. Handed a goal and no steps, it cut
  the demo, laid the music under the voice, ended on a card, mastered to
  −16 LUFS and checked its own work: 12 of 12 checks, 192 seconds, $2.27.
  The score, the level and the end card were each measured in the delivered
  file, not taken from the project.

Where it runs. Linux is where it was built and measured; from a bare
Ubuntu 24.04 and a bare Fedora 44, following nothing but the docs and
proofcut doctor, the demo reached a verified render. Windows: its author
has now run the whole-film demo end to end on a real Windows 11 laptop — all
seven checks, master −16.0 LUFS, frames delta 0 — so a run by anyone else
is the missing report. macOS: the suite and the demo kit are green on
GitHub's macOS runner, but no person has run it on a Mac yet. If you have
one, the Mac test
is one script and a report, and it removes what it installs.

Start with docs/DEMO.md
— two minutes, on media the repo generates itself, so there is nothing to
download and no licence question. proofcut doctor lists what your machine is
missing and prints the fix under each one. If it says ✗, that output is the
single most useful thing you can send.

v0.23.0 — the rename

clip.mp4

proofcut, the local-first AI video editor. It is an MCP server over
ffmpeg, whisper and OpenTimelineIO. An agent, the proofcut command line, or
the browser window cuts a video by editing its transcript. Everything runs on
your machine. It is source-available under PolyForm Shield 1.0.0: any use
except building a product that competes with it.

lucid is now proofcut. Lucid Software ships an official MCP server named
Lucid and holds a live trademark on the word, so the name had to go before two
servers called lucid met in the same registry. If you used lucid: run
proofcut migrate in each project (it renames lucid.json to
proofcut.json and keeps a backup, and undo still reads the old snapshots),
rename every LUCID_* environment variable to PROOFCUT_*, and
proofcut doctor lists any LUCID_* still set. The plugin is reinstalled
under the new name: /plugin marketplace add tydude001/proofcut, then
/plugin install proofcut@proofcut. Links to the old address redirect.

Start with docs/DEMO.md,
two minutes on media the repo generates itself. proofcut doctor lists what
your machine is missing and how to fix each item. The two unattended runs the
clip above was cut from, uncut and at real time:
the workspace
and Claude Code with proofcut as a plugin.

Where it runs. Updated 2026-09-21: this paragraph is how things stood on
v0.23.0's release day. Since then proofcut has been run by hand on a Windows 11
PC and an Intel Mac, GitHub's Apple silicon runner takes the demo to a checked
render, and proofcut setup installs what is missing on Linux, Windows and
both kinds of Mac. Where each platform stands now is
the README.

Linux is where it was built and measured. From a bare
Ubuntu 24.04 and a bare Fedora 44 container, following nothing but the docs
and proofcut doctor's printed fixes, the demo reached a render proofcut
verified. macOS: the test suite is green on CI, and GitHub's macOS runner
runs the Mac test kit to a checked render: Homebrew's ffmpeg-full, whisper,
and Shotcut's melt, 289 of 289 frames, verify 0.971. No person has run it
on a Mac yet. If you have one, the Mac test
is one script and a report. Windows: the test suite is green on CI,
2,071 passed and none failed, and GitHub's Windows runner runs
the Windows test kit
to a checked render under PowerShell 5.1: portable ffmpeg, whisper, and
Shotcut's melt, 289 of 289 frames, verify 0.971. No person has run it on
Windows yet either; the Windows test
is the same shape, one script and a report. If doctor says ✗ on your
machine, that output is the single most useful thing you can send.

Since v0.22.0. Each item is a section of
HISTORY.md,
the dated record of what shipped and what was measured. The repo keeps no
changelog, on purpose.

• The rename: the package, the proofcut command, the MCP server's name,
  the manifest (proofcut.json), the timeline's metadata key and all twenty
  environment variables carry the new name. proofcut migrate renames an old
  project's manifest and rewrites its timeline's key, and a directory holding
  both manifests is refused rather than guessed at. The demo's voiceover says
  the new name, so its example durations moved.
• The launch: the repo went public, v0.22.0 was released, and the Mac test
  issue is pinned. The Windows half followed the tag and ships here: README §
  Help wanted: the first run on Windows, a Windows test report form, and CI's
  Windows leg now able to fail the run.
• The stamp that was a clock: the check that refuses a second writer to a
  project compares a sha256 of the manifest's bytes, not its modified time,
  which Windows can leave unchanged across two writes inside one clock tick.
• The registry listing: proofcut is in the official MCP registry, now as
  io.github.tydude001/proofcut, and the Claude Code plugin was proven
  installing from the public repo.
• The uncut runs: the two full unattended runs the launch clip is cut
  from, encoded at real time and attached to the release, with no home
  directory drawn in either.

v0.22.0

clip-readme-1080.mp4

lucid, the local-first AI video editor. It is an MCP server over ffmpeg,
whisper and OpenTimelineIO. An agent, the lucid command line, or the
browser window cuts a video by editing its transcript. Everything runs on
your machine. It is source-available under PolyForm Shield 1.0.0: any use
except building a product that competes with it.

Start with docs/DEMO.md,
two minutes on media the repo generates itself. lucid doctor lists what
your machine is missing and how to fix each item.

Where it runs. Linux is where it was built and measured. From a bare
Ubuntu 24.04 and a bare Fedora 44 container, following nothing but the docs
and lucid doctor's printed fixes, the demo reached a render lucid verified.
macOS: the test suite is green on CI, and GitHub's macOS runner runs the
Mac test kit to a checked render: Homebrew's ffmpeg-full, whisper, and
Shotcut's melt, 286 of 286 frames, verify 0.971. No person has run it on a
Mac yet. If you have one, the Mac test
is one script and a report. Windows: the test suite is green on CI,
2,048 passed and none failed, and GitHub's Windows runner runs
the Windows test kit
to a checked render under PowerShell 5.1: portable ffmpeg, whisper, and
Shotcut's melt, 286 of 286 frames, verify 0.971. No person has run it on
Windows yet either. If doctor says ✗ on your machine, that output is the
single most useful thing you can send.

Since v0.21.0. Each item is a section of
HISTORY.md,
the dated record of what shipped and what was measured. The repo keeps no
changelog, on purpose.

• The window on an iPhone home screen: the web UI clears the status bar
  and the island when added to a phone's home screen.
• The repo, readied for strangers: history audit, CI, CONTRIBUTING and
  SECURITY.
• The licence, chosen: PolyForm Shield 1.0.0. Contributions come in under
  MIT.
• The MIT history, rewritten: no earlier tag or commit carries the MIT
  grant it briefly had.
• The Windows crash and the display gate: the crash is fixed, and there
  is no display dance where Qt draws natively.
• The Linux-shaped resolvers, widened: melt, auto-editor, the browser,
  Tailscale and fonts are found on macOS and Windows.
• The GPU workers take a device, and CI runs on three OSes:
  LUCID_TTS_DEVICE and LUCID_VLM_DEVICE; a Mac reports no CUDA instead
  of failing.
• The first run on macOS and Windows, and The second run on macOS and
  Windows: the fixes CI's first run on three OSes asked for, and what the
  second run still found on Windows.
• The launch clip, its three re-cuts, and The launch clip, approved:
  recording an unattended agent session through the window exposed defects
  in the agent pane and the preview, which are fixed. The approved clip is
  two unattended runs of one brief, and its closing numbers are read from
  the run's own verify and check_frames.
• The registry entry and the plugin manifest: lucid is installable as a
  Claude Code plugin (/plugin marketplace add tydude001/lucid), and carries
  a server.json for the official MCP registry. The plugin's server command
  was driven over stdio with the repo's own venv scrubbed from PATH: 90
  tools.
• The Windows queue, made to say what it could not: lucid doctor no
  longer crashes on a Windows pipe, and the two Windows clusters that could
  not be read now report their cause.
• Every tool says what it does to the project: all 90 MCP tools carry
  read-only, destructive and idempotent hints, and a tool without them
  cannot register.
• The launch clip's product defects, fixed: a cut word no longer survives
  as float noise after a save, caption lines balance instead of orphaning a
  word, and a fresh project shows an empty state instead of hanging on
  Loading.
• A stranger's install, on a clean Ubuntu, The Ubuntu run's three calls,
  taken, and A stranger's install, on a clean Fedora: a bare container of
  each reaches a verified render from the docs alone. Along the way: renders
  work without a user session bus, a headless Qt that draws nothing is caught
  by a probe frame, ImageMagick became optional, and doctor catches Fedora's
  ffmpeg-free and its melt that is not melt.
• The plugin, installed the way a stranger installs it: the plugin loads
  through Claude Code's own installer with all 90 tools; README says what to
  do when the first start's download outruns the 30-second MCP timeout.
  Issue forms for install trouble and bugs.
• The Mac test, asked of strangers, The Mac test in CI, and The Mac
  test, green on the runner: scripts/mac_trial.sh runs from a clone and
  writes a report that is safe to post, a Mac issue form takes it, and the
  same script reaches a checked render on GitHub's macOS runner.
• Doctor asks for the text filters: doctor's ffmpeg row checks for
  drawtext and ass, so a build without freetype or libass is caught
  before the demo's first command.
• The Windows run that answered, The Windows fixes and the Windows kit,
  written, and The first windows-demo run: a melt on PATH has to print
  MLT's banner before lucid runs it (Windows ships WiX's melt.EXE),
  overrides keep their backslashes, a Windows caption burn stages its own
  fonts for libass, and scripts/windows_trial.ps1 is the Windows twin of
  the Mac kit.
• The sync the repo went public on: on the tip this release names, the
  Windows suite passes in full and the Windows kit reaches its first checked
  render on GitHub's Windows runner; the Mac kit stays green.