…rence

The developer-session recording no longer needs a third-party agent binary
or a faked LLM: the 'agent' is a chat presentation (agent-chat-tui.ts, a
renderer in the recorded PTY) driven by chat-theater.ts while the scenario
makes REAL mcporter MCP calls — OAuth, execute, approval pause/resume all
genuine, each on-screen tool spinner bracketing the actual call it
narrates. Runs anywhere bun runs (no opencode capability), ~28s on cloud.

replay-brain.ts stays for the distinct tier where the third-party client's
own protocol behavior is under test (OpenCode/Claude Code); real-inference
evals remain a separate axis (performance distributions, not pass/fail
scenarios).

Runs from chat-theater scenarios produce a terminal.cast (the chat) AND a
session.mp4 (the browser hop). The run page previously picked one
(video ?? cast), hiding the chat that led to the browser. Now both render
under a single 'session' tab in story order — 1 · the chat, in the
terminal; 2 · the browser hop, mid-chat — with autoplay reserved for
video-only runs.

e2e/desk/run.sh builds a Linux image (Xvfb + openbox + xterm + headed
Chromium + ffmpeg) and runs a scenario inside it with E2E_DESK=1: the chat
renderer opens in a visible UTF-8 xterm (events over a FIFO instead of a
PTY), the browser hop is a real headed window raised over it, and a single
x11grab films the whole screen for the whole run — no splicing. The film
replaces session.mp4 in the scenario's run dir; the scenario file itself
is unchanged (chat-theater switches transports on E2E_DESK).

First run builds the image and fills a node_modules volume; subsequent
films of the connect-handoff session take ~2 minutes end to end.

bun scripts/film.ts runs/<target>/<slug> turns a chat-theater run's two
real recordings into one video that plays like a screen capture of a
developer tabbing between full-screen windows: the cast (rendered without
idle compression so cast time == video time) is cut at the browser hop —
located by the scenario's narrator line, falling back to the largest
output gap — and the browser recording fills the gap. Both segments are
the genuine recordings; only the cut is editorial, exactly like tabbing.

The film registers itself in result.json and the viewer plays film.mp4 as
the session when present. Runs anywhere (agg + ffmpeg) — no Docker, no
display server; the Desk remains for when actual window layering matters.

Acting on a window IS focusing it: a Playwright step marks the browser
focused, a chat-theater event marks the terminal focused. Surfaces record
these transitions (plus each recording's start anchor) into the run's
timeline.json as a side effect of normal driving — no scenario changes,
no declared focus anywhere.

film.ts now builds its cut list from that timeline (any number of hops,
each act mapped into its recording's own clock via the anchors), keeping
the narrator-line/largest-gap heuristic only as a fallback for runs
without one. The film is the operations, edited by where they happened.

The emulator serves its own OpenAPI document, so the scenario stops
hand-writing a Resend subset and an explicit auth template — addSpec gets
just the spec URL, exactly what an agent would send, and the platform
derives base URL and the paste-a-token method from the spec itself.

chat.tool now takes the call itself — tool name, the REAL input (the
sandbox code the scenario executes, shown as the indented preview block
agent TUIs draw), and a result-line renderer — instead of a prose label.
The renderer paints name → input block → live spinner → ✓ with the real
duration and the real result's first line. The recording reads like an
actual agent session: what was called, with what, how long it took, what
came back.

film.mp4 was a manual post-step, so any re-run left the viewer showing
the parts (cast + browser video) instead of the spliced session. The
runner now invokes scripts/film.ts after every successful run that has
both terminal.cast and session.mp4 — best-effort, so missing agg/ffmpeg
degrades back to the parts rather than failing the run. Every developer-
session run's page now plays the single film by default.

Every REST emulator now serves its own OpenAPI document; the connect
scenarios register integrations from those live spec URLs instead of
hand-written specs.