tickmarkr 1.79.0 → 1.81.0

package/dist/adapters/kimi.js

@@ -176,19 +176,36 @@ const KIMI_ANSI_SGR_RE = /\u001B\[[0-9;]*m/g;
 const KIMI_EDITOR_TOP_RE = /^╭─+╮$/;
 const KIMI_EDITOR_INPUT_RE = /^│ > .*│$/;
 const KIMI_EDITOR_EMPTY_RE = /^│ > +│$/;
+// OBS-181: any interior row of the box. An editor carrying a prompt renders one or more blank
+// continuation rows beneath it, so the bottom border is not always the very next line.
+const KIMI_EDITOR_ROW_RE = /^│.*│$/;
 const KIMI_EDITOR_BOTTOM_RE = /^╰─+╯$/;
 function matchesKimiEditorBox(paneText, empty) {
     // OBS-152: kimi renders its whole TUI indented one column, so `^`-anchored row matches never fire
     // on a LIVE editor box — probe 6 timed out readiness against a frame whose box was fully painted
     // and interactive. Trim per line: the left margin is chrome, and what actually distinguishes the
-    // editor from the welcome panel (also a bordered box) is the three-row adjacency asserted below.
+    // editor from the welcome panel (also a bordered box) is the border adjacency asserted below.
+    //
+    // `match` means THE EDITOR BOX IS PAINTED (readiness), and is deliberately true for an empty box.
+    // `emptyMatch` is the stricter "painted AND carrying nothing". Callers deciding submission must
+    // therefore test emptyMatch FIRST — see HerdrDriver.submissionRegistered.
+    //
+    // OBS-181: the adjacency used to demand the bottom border on the line directly below the prompt.
+    // A wedged worker pane rendered FOUR rows — top, prompt, a blank continuation row, bottom — so
+    // NEITHER matcher fired, and the driver's submission check fell through to a fallback that always
+    // answers "delivered". Walk the interior to the border instead of assuming a three-row box.
     const lines = paneText.replace(KIMI_ANSI_SGR_RE, "").split("\n").map((line) => line.trim());
     const input = empty ? KIMI_EDITOR_EMPTY_RE : KIMI_EDITOR_INPUT_RE;
-    return lines.some((line, index) => input.test(line)
-        && index > 0
-        && index + 1 < lines.length
-        && KIMI_EDITOR_TOP_RE.test(lines[index - 1])
-        && KIMI_EDITOR_BOTTOM_RE.test(lines[index + 1]));
+    return lines.some((line, index) => {
+        if (!input.test(line))
+            return false;
+        if (index === 0 || !KIMI_EDITOR_TOP_RE.test(lines[index - 1]))
+            return false;
+        let below = index + 1;
+        while (below < lines.length && KIMI_EDITOR_ROW_RE.test(lines[below]))
+            below++;
+        return below < lines.length && KIMI_EDITOR_BOTTOM_RE.test(lines[below]);
+    });
 }
 // v1.75 T1 / OBS-136: Kimi's actual editor is a three-line bordered box whose content row starts
 // `│ > `. The welcome panel separately contains "Send /help..." and is only launch-liveness

package/dist/brand.d.ts

@@ -2,6 +2,10 @@ import type { OwnedName } from "./drivers/types.js";
 export declare const BANNER: string;
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export declare const PLAIN_BANNER: string;
+/** Two-line run-cockpit lockup, sliced from BANNER so its mark and product name cannot drift. */
+export declare const COMPACT_LOCKUP: string;
+/** ANSI-stripped, trailing-space-trimmed twin of COMPACT_LOCKUP for colourless surfaces. */
+export declare const PLAIN_COMPACT_LOCKUP: string;
 export declare const PANE_IDENTITY_ENV = "TICKMARKR_PANE_IDENTITY";
 /** One-line pane identity through the T1 ownership contract: role · task · attempt · run. */
 export declare function paneIdentityLine(o: OwnedName): string;

package/dist/brand.js

@@ -12,6 +12,10 @@ export const BANNER = [
 ].join("\n");
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export const PLAIN_BANNER = BANNER.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
+/** Two-line run-cockpit lockup, sliced from BANNER so its mark and product name cannot drift. */
+export const COMPACT_LOCKUP = BANNER.split("\n").slice(1, 3).join("\n");
+/** ANSI-stripped, trailing-space-trimmed twin of COMPACT_LOCKUP for colourless surfaces. */
+export const PLAIN_COMPACT_LOCKUP = COMPACT_LOCKUP.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
 // T5: the pane identity every visible pane announces under the logo. HerdrDriver seeds this env var
 // into each pane shell at slot() time (paneIdentityLine of the pane's T1 owned name); the banner's
 // identity line reads it at pane runtime, so every role — worker/judge/review/consult — wears the

package/dist/cli/commands/ui.d.ts

@@ -2,7 +2,7 @@ type StudioIO = {
     input: NodeJS.ReadStream;
     output: NodeJS.WriteStream;
 };
-export declare function ui(_argv: string[], io?: Partial<StudioIO>): Promise<string | {
+export declare function ui(argv: string[], io?: Partial<StudioIO>, cwd?: string): Promise<string | {
     out: string;
     code: number;
 }>;

package/dist/cli/commands/ui.js

@@ -1,11 +1,52 @@
-const NON_TTY_MSG = "tickmarkr ui: studio requires a TTY — use `tickmarkr fleet --print` or `tickmarkr status --watch` for line-mode output";
-export async function ui(_argv, io = {}) {
+const NON_TTY_MSG = "tickmarkr ui: the cockpit requires a TTY — use `tickmarkr fleet --print` or `tickmarkr status --watch` for line-mode output";
+export async function ui(argv, io = {}, cwd = process.cwd()) {
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
     if (input.isTTY !== true || output.isTTY !== true) {
         return { out: NON_TTY_MSG, code: 1 };
     }
-    const { runStudioInk } = await import("../../tui/ink/studio-app.js");
-    await runStudioInk({ input, output });
+    if (argv.includes("--demo")) {
+        const { runCockpitDemo } = await import("../../tui/cockpit/demo.js");
+        const { version } = await import("./version.js");
+        await runCockpitDemo({
+            input,
+            output,
+            binaryVersion: await version(),
+        });
+        return "ui: closed";
+    }
+    const unknownFlag = argv.find((arg) => arg.startsWith("-"));
+    if (unknownFlag) {
+        return { out: `tickmarkr ui: unknown flag ${unknownFlag}`, code: 1 };
+    }
+    const live = await import("../../tui/cockpit/live.js");
+    const { version } = await import("./version.js");
+    const binaryVersion = await version();
+    const explicit = argv.find((arg) => !arg.startsWith("-"));
+    let runId;
+    try {
+        runId = live.selectEngagementRunId(cwd, explicit);
+    }
+    catch (error) {
+        return { out: `tickmarkr ui: ${error.message}`, code: 1 };
+    }
+    if (runId === null) {
+        return {
+            out: "tickmarkr ui: no engagement found — start one with `tickmarkr run` first",
+            code: 1,
+        };
+    }
+    // Refuse before drawing anything: unreadable journal bytes must never
+    // become a plausible surface derived from nothing.
+    try {
+        live.deriveLiveRunCockpitData(live.loadEngagementSource(cwd, runId), binaryVersion);
+    }
+    catch (error) {
+        return {
+            out: `tickmarkr ui: cannot read engagement ${runId}: ${error.message}`,
+            code: 1,
+        };
+    }
+    await live.runLiveCockpit({ input, output, cwd, runId, binaryVersion });
     return "ui: closed";
 }

package/dist/drivers/herdr.js

@@ -156,9 +156,29 @@ export class HerdrDriver {
             return true;
         if (promptAt < 0)
             return inputBox !== undefined && matchesEmptyInputBox(transcript, inputBox);
-        if (inputBox && matchesInputBox(transcript, inputBox)) {
-            return hay.lastIndexOf(norm(inputBox.fingerprint)) > promptAt;
+        if (inputBox) {
+            // OBS-181: an EMPTY declared input box is positive evidence of submission even while the
+            // prompt is still visible above as the echoed user turn — which is exactly how every TUI
+            // renders the moment after Enter lands. Test it FIRST: `match` means "the box is painted" and
+            // is deliberately true for an empty box, so asking `match` first cannot decide submission.
+            if (matchesEmptyInputBox(transcript, inputBox))
+                return true;
+            // The box is painted and is NOT empty: the prompt is still sitting in it. Only a fingerprint
+            // appearing AFTER the prompt — a fresh input line below the submitted text — counts.
+            //
+            // This is the branch a wedged kimi pane belongs in, and could not reach: its occupied editor
+            // renders a blank continuation row, the matcher demanded the bottom border immediately below
+            // the prompt, so NEITHER matcher fired and the positional fallback below answered "delivered"
+            // for a pane that had processed nothing. The matcher fix (adapters/kimi.ts) is what routes it
+            // here; keeping the fallback unreachable for a painted box is what stops the next one.
+            if (matchesInputBox(transcript, inputBox)) {
+                return hay.lastIndexOf(norm(inputBox.fingerprint)) > promptAt;
+            }
         }
+        // No declared box, or the box is not on screen at all (it may have scrolled out of the read
+        // window). Positional evidence only — weaker, and unsound for any surface that paints chrome
+        // below its prompt, which is why a declared box must be able to recognise its own OCCUPIED
+        // state. Every adapter declaring an inputBox needs a captured occupied frame in its tests.
         return promptAt + needle.length < hay.length;
     }
     static available() {
@@ -583,10 +603,12 @@ export class HerdrDriver {
             transcript = read.stdout || transcript;
             const waitedMs = this.time.now() - started;
             if (read.code !== 0) {
-                // Once at least one valid frame has been observed, a read that consumes the remainder of
-                // the readiness budget is the bounded window expiring, not a new submission/protocol
-                // identity. A first-read timeout and every non-timeout read failure remain structural.
-                if (read.timedOut && previous !== undefined && waitedMs >= timeoutMs) {
+                // Once at least one valid frame has been observed, a timed-out read IS the bounded window
+                // expiring: the read was given exactly the remaining readiness budget as its real timeout,
+                // so real time genuinely elapsed even when an injected clock has not advanced (an injected
+                // clock never moves during a read, so a wall-clock comparison here can never hold under
+                // one). A first-read timeout and every non-timeout read failure remain structural.
+                if (read.timedOut && previous !== undefined) {
                     throw new DeliveryReadinessError(waitedMs, transcript);
                 }
                 const detail = read.stderr || read.stdout || `exit ${read.code}`;

package/dist/tui/cockpit/capture.d.ts

@@ -0,0 +1,117 @@
+import { type ReactNode } from "react";
+import { type DemoCaptures } from "./demo.js";
+export type CockpitName = "run" | "setup";
+export type CockpitRenderer = "frame" | "plain";
+export type RendererCaptureOptions = {
+    readonly columns: number;
+    readonly rows: number;
+    readonly colour: boolean;
+};
+export type FrameRenderer = (node: ReactNode, options: RendererCaptureOptions) => Promise<string>;
+export type CockpitEmission = {
+    readonly renderer: CockpitRenderer;
+    readonly output: string;
+};
+export type CaptureCockpitOptions = {
+    readonly cockpit: CockpitName;
+    readonly output: NodeJS.WriteStream;
+    readonly binaryVersion: string;
+    readonly columns?: number;
+    readonly rows?: number;
+    readonly interactive?: boolean;
+    readonly colour?: boolean;
+    readonly ci?: boolean;
+    readonly captures?: DemoCaptures;
+    readonly plainRenderer?: (cockpit: CockpitName, binaryVersion: string, captures: DemoCaptures) => string;
+    readonly frameRenderer?: FrameRenderer;
+};
+export type WidthBandCase = {
+    readonly arrangement: "stacked" | "folded-keys" | "three-column";
+    readonly columns: number;
+};
+export declare const WIDTH_BAND_CASES: readonly [{
+    readonly arrangement: "stacked";
+    readonly columns: 80;
+}, {
+    readonly arrangement: "folded-keys";
+    readonly columns: 100;
+}, {
+    readonly arrangement: "three-column";
+    readonly columns: 140;
+}];
+export declare const HEIGHT_TIER_BOUNDARIES: readonly [14, 18, 24, 40];
+export type GoldenFrameCase = {
+    readonly id: string;
+    readonly fixture: string;
+    readonly cockpit: CockpitName;
+    readonly axis: "width" | "height" | "variant";
+    readonly columns: number;
+    readonly rows: number;
+    readonly interactive: boolean;
+    readonly colour: boolean;
+    readonly ci: boolean;
+};
+export declare const GOLDEN_FRAME_CASES: readonly GoldenFrameCase[];
+export type ColourFrameCase = {
+    readonly id: "healthy-colour" | "healthy-no-colour" | "warning-failure-colour";
+    readonly fixture: string;
+    readonly sourceFileName: string;
+    readonly columns: number;
+    readonly rows: number;
+    readonly colour: boolean;
+};
+/**
+ * The colour corpus has a deliberately separate manifest from the layout
+ * corpus. Layout cases stay colourless; these cases alone exercise real ink.
+ */
+export declare const COLOUR_FRAME_CASES: readonly [{
+    readonly id: "healthy-colour";
+    readonly fixture: "run-20260718-000943.colour.140x24.txt";
+    readonly sourceFileName: "run-20260718-000943.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: true;
+}, {
+    readonly id: "healthy-no-colour";
+    readonly fixture: "run-20260718-000943.no-colour.140x24.txt";
+    readonly sourceFileName: "run-20260718-000943.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: false;
+}, {
+    readonly id: "warning-failure-colour";
+    readonly fixture: "run-20260725-025004.interrupted.colour.140x24.txt";
+    readonly sourceFileName: "run-20260725-025004.interrupted.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: true;
+}];
+/**
+ * Capture exactly the bytes Ink writes for one static paint. Debug mode is
+ * deliberate: it exposes the complete frame rather than terminal patch
+ * instructions, so the committed corpus is the renderer's frame output.
+ */
+export declare function captureRendererOutput(node: ReactNode, options: RendererCaptureOptions): Promise<string>;
+/**
+ * The single interactive/plain boundary. It decides before mounting Ink, then
+ * falls back again if a renderer returns an empty paint.
+ */
+export declare function captureCockpitOutput(options: CaptureCockpitOptions): Promise<CockpitEmission>;
+export type RegeneratedGoldenFrame = GoldenFrameCase & {
+    readonly renderer: CockpitRenderer;
+    readonly output: string;
+    readonly emitted: string;
+};
+export declare function regenerateGoldenFrames(binaryVersion?: string): Promise<readonly RegeneratedGoldenFrame[]>;
+export declare function findGoldenFrameMismatches(regenerated: readonly RegeneratedGoldenFrame[], committed: ReadonlyMap<string, string>): string[];
+export type RegeneratedColourFrame = ColourFrameCase & {
+    readonly output: string;
+    readonly emitted: string;
+};
+/**
+ * Regenerate only the colour contract corpus from its own manifest. Historical
+ * run sources are read and rendered byte-for-byte with their captured daemon
+ * stopped, matching the demo path and avoiding live-process state in committed
+ * bytes.
+ */
+export declare function regenerateColourFrames(binaryVersion?: string): Promise<readonly RegeneratedColourFrame[]>;

package/dist/tui/cockpit/capture.js

@@ -0,0 +1,329 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PassThrough } from "node:stream";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { render } from "ink";
+import { cloneElement, createElement, isValidElement, } from "react";
+import { GLYPHS } from "../../brand.js";
+import { version } from "../../cli/commands/version.js";
+import { KEYBAR_KEYS } from "./components.js";
+import { loadDemoCaptures } from "./demo.js";
+import { resolveCockpitLayout, } from "./layout.js";
+import { deriveRunCockpitData, RunCockpitFrame, } from "./run-cockpit.js";
+import { deriveSetupCockpitData, SetupCockpitFrame, } from "./setup-cockpit.js";
+export const WIDTH_BAND_CASES = [
+    { arrangement: "stacked", columns: 80 },
+    { arrangement: "folded-keys", columns: 100 },
+    { arrangement: "three-column", columns: 140 },
+];
+export const HEIGHT_TIER_BOUNDARIES = [14, 18, 24, 40];
+const fixtureName = (cockpit, id, columns, rows) => `${cockpit}.${id}.${columns}x${rows}.txt`;
+const goldenCasesFor = (cockpit) => [
+    ...WIDTH_BAND_CASES.map(({ arrangement, columns }) => ({
+        id: `${cockpit}-width-${arrangement}`,
+        fixture: fixtureName(cockpit, `width-${arrangement}`, columns, 24),
+        cockpit,
+        axis: "width",
+        columns,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: false,
+    })),
+    ...HEIGHT_TIER_BOUNDARIES.map((rows) => ({
+        id: `${cockpit}-height-${rows}`,
+        fixture: fixtureName(cockpit, `height-${rows}`, 140, rows),
+        cockpit,
+        axis: "height",
+        columns: 140,
+        rows,
+        interactive: true,
+        colour: false,
+        ci: false,
+    })),
+    {
+        id: `${cockpit}-no-colour`,
+        fixture: fixtureName(cockpit, "no-colour", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: false,
+    },
+    {
+        id: `${cockpit}-non-tty`,
+        fixture: fixtureName(cockpit, "non-tty", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: false,
+        colour: false,
+        ci: false,
+    },
+    {
+        id: `${cockpit}-ci`,
+        fixture: fixtureName(cockpit, "ci", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: true,
+    },
+];
+export const GOLDEN_FRAME_CASES = [
+    ...goldenCasesFor("run"),
+    ...goldenCasesFor("setup"),
+];
+/**
+ * The colour corpus has a deliberately separate manifest from the layout
+ * corpus. Layout cases stay colourless; these cases alone exercise real ink.
+ */
+export const COLOUR_FRAME_CASES = [
+    {
+        id: "healthy-colour",
+        fixture: "run-20260718-000943.colour.140x24.txt",
+        sourceFileName: "run-20260718-000943.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: true,
+    },
+    {
+        id: "healthy-no-colour",
+        fixture: "run-20260718-000943.no-colour.140x24.txt",
+        sourceFileName: "run-20260718-000943.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: false,
+    },
+    {
+        id: "warning-failure-colour",
+        fixture: "run-20260725-025004.interrupted.colour.140x24.txt",
+        sourceFileName: "run-20260725-025004.interrupted.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: true,
+    },
+];
+const COLOUR_SOURCE_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "../../../tests/fixtures/cockpit/colour/sources");
+function derivedData(cockpit, binaryVersion, captures) {
+    if (cockpit === "setup") {
+        return {
+            cockpit,
+            data: deriveSetupCockpitData(captures, binaryVersion),
+        };
+    }
+    const source = captures.journals.find((capture) => capture.fileName === "run-20260724-231138.journal.jsonl");
+    if (!source)
+        throw new Error("healthy cockpit capture is missing");
+    return {
+        cockpit,
+        data: deriveRunCockpitData(source, binaryVersion),
+    };
+}
+function stateGlyph(state) {
+    if (state === "active" || state === "pass")
+        return GLYPHS.pass;
+    if (state === "inactive")
+        return GLYPHS.toggleInactive;
+    if (state === "fail")
+        return GLYPHS.fail;
+    if (state === "warn")
+        return GLYPHS.attention;
+    return GLYPHS.neutral;
+}
+function defaultPlainRenderer(cockpit, binaryVersion, captures) {
+    const derived = derivedData(cockpit, binaryVersion, captures);
+    if (derived.cockpit === "run") {
+        const data = derived.data;
+        return [
+            `tickmarkr v${binaryVersion}`,
+            `${data.runId} ${data.status} ${data.elapsed}`,
+            ...data.statusItems.map((item) => `${stateGlyph(item.state)} ${item.text}`),
+            `keys ${KEYBAR_KEYS.run.map((item) => `${item.key} ${item.label}`).join(" · ")}`,
+            "",
+        ].join("\n");
+    }
+    const data = derived.data;
+    return [
+        `tickmarkr v${binaryVersion}`,
+        `setup ${data.counts.found} found ${data.counts.authenticated} authed ${data.counts.routable} routable`,
+        ...data.harnesses.map((harness) => `${stateGlyph(harness.state)} ${harness.stateWord} ${harness.id}`),
+        ...data.deniedChannels.map((denied) => `${GLYPHS.fail} denied ${denied.channel} - ${denied.reason}`),
+        `${GLYPHS.pass} base untouched`,
+        `${GLYPHS.attention} ${data.stagedChanges.length} changes unsaved`,
+        `keys ${KEYBAR_KEYS.setup.map((item) => `${item.key} ${item.label}`).join(" · ")}`,
+        "",
+    ].join("\n");
+}
+function frameNode(derived, columns, rows) {
+    if (derived.cockpit === "run") {
+        return createElement(RunCockpitFrame, {
+            data: derived.data,
+            columns,
+            rows,
+        });
+    }
+    return createElement(SetupCockpitFrame, {
+        data: derived.data,
+        columns,
+        rows,
+    });
+}
+/**
+ * Capture exactly the bytes Ink writes for one static paint. Debug mode is
+ * deliberate: it exposes the complete frame rather than terminal patch
+ * instructions, so the committed corpus is the renderer's frame output.
+ */
+export async function captureRendererOutput(node, options) {
+    const sizedNode = isValidElement(node)
+        && (node.type === RunCockpitFrame || node.type === SetupCockpitFrame)
+        ? cloneElement(node, { rows: options.rows })
+        : node;
+    const output = new PassThrough();
+    output.isTTY = true;
+    output.columns = options.columns;
+    output.rows = options.rows;
+    const writes = [];
+    const write = output.write.bind(output);
+    output.write = ((chunk, ...args) => {
+        writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+        return Reflect.apply(write, output, [chunk, ...args]);
+    });
+    const previousColourLevel = chalk.level;
+    const previousNoColour = process.env.NO_COLOR;
+    chalk.level = options.colour ? 3 : 0;
+    if (options.colour)
+        delete process.env.NO_COLOR;
+    else
+        process.env.NO_COLOR = "1";
+    let painted;
+    const firstPaint = new Promise((resolve) => {
+        painted = resolve;
+    });
+    const app = render(sizedNode, {
+        stdout: output,
+        debug: true,
+        patchConsole: false,
+        onRender: painted,
+    });
+    try {
+        await firstPaint;
+        return writes.at(-1) ?? "";
+    }
+    finally {
+        app.unmount();
+        app.cleanup();
+        chalk.level = previousColourLevel;
+        if (previousNoColour === undefined)
+            delete process.env.NO_COLOR;
+        else
+            process.env.NO_COLOR = previousNoColour;
+    }
+}
+/**
+ * The single interactive/plain boundary. It decides before mounting Ink, then
+ * falls back again if a renderer returns an empty paint.
+ */
+export async function captureCockpitOutput(options) {
+    const columns = options.columns ?? options.output.columns ?? 80;
+    const rows = options.rows ?? options.output.rows ?? 24;
+    const interactive = options.interactive
+        ?? options.output.isTTY === true;
+    const colour = options.colour
+        ?? process.env.NO_COLOR === undefined;
+    const ci = options.ci ?? process.env.CI === "true";
+    const captures = options.captures ?? loadDemoCaptures();
+    const plain = () => (options.plainRenderer ?? defaultPlainRenderer)(options.cockpit, options.binaryVersion, captures);
+    const layout = resolveCockpitLayout(columns, rows);
+    if (!interactive || options.output.isTTY !== true || ci || layout.renderer === "plain") {
+        const plainOutput = plain();
+        options.output.write(plainOutput);
+        return { renderer: "plain", output: plainOutput };
+    }
+    const derived = derivedData(options.cockpit, options.binaryVersion, captures);
+    const frameOutput = await (options.frameRenderer ?? captureRendererOutput)(frameNode(derived, columns, rows), { columns, rows, colour });
+    if (frameOutput.length === 0) {
+        const plainOutput = plain();
+        options.output.write(plainOutput);
+        return { renderer: "plain", output: plainOutput };
+    }
+    options.output.write(frameOutput);
+    return { renderer: "frame", output: frameOutput };
+}
+export async function regenerateGoldenFrames(binaryVersion) {
+    const resolvedVersion = binaryVersion ?? await version();
+    const captures = loadDemoCaptures();
+    const regenerated = [];
+    for (const golden of GOLDEN_FRAME_CASES) {
+        const output = new PassThrough();
+        output.isTTY = golden.interactive;
+        output.columns = golden.columns;
+        output.rows = golden.rows;
+        const writes = [];
+        const write = output.write.bind(output);
+        output.write = ((chunk, ...args) => {
+            writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return Reflect.apply(write, output, [chunk, ...args]);
+        });
+        const emission = await captureCockpitOutput({
+            cockpit: golden.cockpit,
+            output: output,
+            binaryVersion: resolvedVersion,
+            columns: golden.columns,
+            rows: golden.rows,
+            interactive: golden.interactive,
+            colour: golden.colour,
+            ci: golden.ci,
+            captures,
+        });
+        regenerated.push({
+            ...golden,
+            ...emission,
+            emitted: writes.join(""),
+        });
+    }
+    return regenerated;
+}
+export function findGoldenFrameMismatches(regenerated, committed) {
+    const expected = new Set(regenerated.map((frame) => frame.fixture));
+    return [
+        ...regenerated.flatMap((frame) => committed.get(frame.fixture) === frame.output ? [] : [frame.fixture]),
+        ...[...committed.keys()].filter((fixture) => !expected.has(fixture)),
+    ].sort();
+}
+/**
+ * Regenerate only the colour contract corpus from its own manifest. Historical
+ * run sources are read and rendered byte-for-byte with their captured daemon
+ * stopped, matching the demo path and avoiding live-process state in committed
+ * bytes.
+ */
+export async function regenerateColourFrames(binaryVersion) {
+    const resolvedVersion = binaryVersion ?? await version();
+    const regenerated = [];
+    for (const colourCase of COLOUR_FRAME_CASES) {
+        const source = {
+            fileName: colourCase.sourceFileName,
+            raw: readFileSync(join(COLOUR_SOURCE_DIRECTORY, colourCase.sourceFileName), "utf8"),
+        };
+        const data = deriveRunCockpitData(source, resolvedVersion, {
+            isDaemonAlive: () => false,
+        });
+        const output = await captureRendererOutput(frameNode({ cockpit: "run", data }, colourCase.columns, colourCase.rows), {
+            columns: colourCase.columns,
+            rows: colourCase.rows,
+            colour: colourCase.colour,
+        });
+        regenerated.push({
+            ...colourCase,
+            output,
+            emitted: output,
+        });
+    }
+    return regenerated;
+}