tickmarkr 1.67.0 → 1.69.0

package/dist/run/daemon.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { stringify } from "yaml";
-import { classifyDeadChannel, trailerPattern, writePrompt } from "../adapters/prompt.js";
+import { classifyDeadChannel, NO_TRAILER_SUMMARY, trailerPattern, UNPARSEABLE_TRAILER_SUMMARY, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
@@ -16,6 +16,7 @@ import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
 import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
@@ -601,17 +602,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                     : cfg.visibility.worker === "interactive" && driver.interactive
                         ? adapter.interactiveCommand(promptFile, assignment.model)
                         : null;
-                if (cfg.visibility.worker === "interactive" && icmd === null && !modeFallbackNoted) {
+                // v1.69 T6: adapters that declare interactiveSeed launch the real TUI and inject the prompt as a
+                // user turn; they do NOT need the argv-seeding surface that interactiveCommand represents.
+                const hasSeed = retryMode !== "resume" && cfg.visibility.worker === "interactive" && driver.interactive && !!adapter.interactiveSeed;
+                if (cfg.visibility.worker === "interactive" && icmd === null && !hasSeed && !modeFallbackNoted) {
                     modeFallbackNoted = true;
                     journal.append("worker-mode-fallback", t.id, { reason: driver.interactive ? "adapter" : "driver" });
                 }
-                const interactive = icmd !== null;
+                const interactive = icmd !== null || hasSeed;
                 // OBS-85 (v1.62 T1): both dispatch branches deliver ONE short script invocation — banner,
                 // adapter command, and nonce exit marker live in a per-attempt script beside the prompt
                 // artifact (the same paneDispatchCommand pattern judge/review/consult dispatches use). The
                 // delivered pane line carries no command substitution and no trailing shell text, so paste
                 // timing can never interleave a `$(…)` with what follows it (the codex corruption class).
-                const workerCmd = interactive ? icmd : adapter.invoke(t, wt, assignment, { promptFile }).command;
+                const workerCmd = interactive
+                    ? (hasSeed ? ":" : icmd)
+                    : adapter.invoke(t, wt, assignment, { promptFile }).command;
                 const dispatchScript = promptFile.replace(/\.md$/, ".sh");
                 writeFileSync(dispatchScript, [
                     "export BASH_SILENCE_DEPRECATION_WARNING=1",
@@ -658,95 +664,136 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let output;
                 let exitCode;
                 let timedOut = false;
+                let settleParsed;
+                let seedResult;
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
-                    await driver.run(slot, paneDispatchCommand(dispatchScript));
-                    let paged = false;
-                    // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
-                    // Any other blocked/idle dialog still pages the operator (paged latch below).
-                    let trustAnswered = false;
                     finished = false;
                     exitCode = null;
-                    output = await driver.read(slot, 1000);
-                    // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
-                    // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
-                    const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
-                    // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
-                    // trailer detection, harvest, paging, and quota checks all read the raw pane.
-                    let lastStallSnapshot = normalizeStallSnapshot(output);
-                    let lastOutputAt = Date.now();
-                    while (Date.now() - lastOutputAt < stallWindowMs) {
-                        const sliceStart = Date.now();
-                        const remaining = stallWindowMs - (sliceStart - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
-                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
-                            // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
-                            // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
-                            // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
-                            output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
+                    if (adapter.interactiveSeed) {
+                        // v1.69 T6: launch the real TUI without a prompt, wait for readiness, inject one seed turn,
+                        // then fall through to the normal trailer harvest. A failed seed is recorded as a finished
+                        // failure rather than allowed to race the trailer wait.
+                        seedResult = await runInteractiveSeed({ driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes });
+                        output = seedResult.output;
+                    }
+                    else {
+                        await driver.run(slot, paneDispatchCommand(dispatchScript));
+                        output = await driver.read(slot, 1000);
+                    }
+                    if (seedResult?.seedFailed) {
+                        finished = false;
+                    }
+                    else {
+                        let paged = false;
+                        // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
+                        // Any other blocked/idle dialog still pages the operator (paged latch below).
+                        let trustAnswered = false;
+                        finished = false;
+                        exitCode = null;
+                        // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
+                        // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
+                        const stallWindowMs = taskTimeoutMinutes * 60_000;
+                        // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
+                        // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
+                        // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        let lastStallSnapshot = normalizeStallSnapshot(output);
+                        let lastOutputAt = Date.now();
+                        while (Date.now() - lastOutputAt < stallWindowMs) {
+                            const sliceStart = Date.now();
+                            const remaining = stallWindowMs - (sliceStart - lastOutputAt);
+                            const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
+                                // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
+                                // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
+                                // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
+                                output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
+                                finished = new RegExp(trailerPattern(nonce)).test(output);
+                                const exit = exitRe.exec(output);
+                                if (finished || exit) {
+                                    exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
+                                    await sampleContext(); // final poll-seam sample before leaving the wait
+                                    break;
+                                }
+                            }
+                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            if (currentStallSnapshot !== lastStallSnapshot) {
+                                lastStallSnapshot = currentStallSnapshot;
+                                lastOutputAt = Date.now();
+                            }
+                            // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
+                            await sampleContext();
+                            // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
+                            // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
+                            // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
+                            const st = paged ? "" : await driver.status(slot);
+                            if (!paged && (st === "blocked" || st === "idle")) {
+                                // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
+                                // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
+                                if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
+                                    try {
+                                        const paneText = await driver.read(slot, 80);
+                                        if (matchesTrustDialog(paneText, adapter.trustDialog)) {
+                                            trustAnswered = true;
+                                            // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
+                                            // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
+                                            journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
+                                            await driver.sendKey(slot, adapter.trustDialog.key);
+                                            const spent = Date.now() - sliceStart;
+                                            if (spent < slice)
+                                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                                            continue; // do not page — keep waiting for the trailer
+                                        }
+                                    }
+                                    catch {
+                                        /* read/send failed — fall through to page the operator */
+                                    }
+                                }
+                                paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
+                                const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
+                                await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
+                            }
+                            // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
+                            const spent = Date.now() - sliceStart;
+                            if (spent < slice)
+                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                        }
+                        if (!finished && exitCode === null) {
+                            // timed out (or only ever saw false positives): harvest whatever the pane holds now
+                            timedOut = Date.now() - lastOutputAt >= stallWindowMs;
+                            output = await driver.read(slot, 1000);
                             finished = new RegExp(trailerPattern(nonce)).test(output);
                             const exit = exitRe.exec(output);
-                            if (finished || exit) {
-                                exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
-                                await sampleContext(); // final poll-seam sample before leaving the wait
-                                break;
-                            }
+                            exitCode = exit ? Number(exit[1]) : null;
                         }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
-                        if (currentStallSnapshot !== lastStallSnapshot) {
-                            lastStallSnapshot = currentStallSnapshot;
-                            lastOutputAt = Date.now();
+                        if (finished) {
+                            await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
+                            output = await driver.read(slot, 1000);
                         }
-                        // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
-                        await sampleContext();
-                        // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
-                        // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
-                        // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
-                        const st = paged ? "" : await driver.status(slot);
-                        if (!paged && (st === "blocked" || st === "idle")) {
-                            // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
-                            // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
-                            if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
-                                try {
-                                    const paneText = await driver.read(slot, 80);
-                                    if (matchesTrustDialog(paneText, adapter.trustDialog)) {
-                                        trustAnswered = true;
-                                        // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
-                                        // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
-                                        journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
-                                        await driver.sendKey(slot, adapter.trustDialog.key);
-                                        const spent = Date.now() - sliceStart;
-                                        if (spent < slice)
-                                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
-                                        continue; // do not page — keep waiting for the trailer
-                                    }
-                                }
-                                catch {
-                                    /* read/send failed — fall through to page the operator */
-                                }
+                        // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
+                        // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
+                        // the existing pane-read seam once or twice before recording a malformed-trailer cause.
+                        if (interactive) {
+                            const stallWindowMs = taskTimeoutMinutes * 60_000;
+                            const settleDeadline = attemptStart + stallWindowMs;
+                            const settleDelayMs = 1_000;
+                            const maxSettleRetries = 2;
+                            let settleTries = 0;
+                            settleParsed = adapter.parse(output, nonce);
+                            while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
+                                const remaining = settleDeadline - Date.now();
+                                if (remaining <= 0)
+                                    break;
+                                await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                                output = await driver.read(slot, 1000);
+                                settleParsed = adapter.parse(output, nonce);
+                                settleTries++;
+                            }
+                            if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
+                                finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
                             }
-                            paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
-                            const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
-                            await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
                         }
-                        // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
-                        const spent = Date.now() - sliceStart;
-                        if (spent < slice)
-                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
-                    }
-                    if (!finished && exitCode === null) {
-                        // timed out (or only ever saw false positives): harvest whatever the pane holds now
-                        timedOut = Date.now() - lastOutputAt >= stallWindowMs;
-                        output = await driver.read(slot, 1000);
-                        finished = new RegExp(trailerPattern(nonce)).test(output);
-                        const exit = exitRe.exec(output);
-                        exitCode = exit ? Number(exit[1]) : null;
-                    }
-                    if (finished) {
-                        await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
-                        output = await driver.read(slot, 1000);
                     }
                 }
                 else {
@@ -800,7 +847,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     tokens = addUsage(tokens, attemptUsage);
                     metered++;
                 }
-                const result = adapter.parse(output, nonce);
+                const result = settleParsed ?? adapter.parse(output, nonce);
                 const cause = classifyWorkerResultCause({ output, ok: result.ok, finished, exitCode, summary: result.summary, timedOut });
                 journal.append("worker-result", t.id, {
                     ok: result.ok, summary: result.summary, deviations: result.deviations, finished, exitCode,

package/dist/run/git.d.ts

@@ -1,5 +1,7 @@
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
+export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export declare const DEFAULT_FORK_CAP = "6";
 export interface ShResult {
     code: number;
     stdout: string;

package/dist/run/git.js

@@ -5,6 +5,12 @@ import { shq } from "../adapters/types.js";
 import { tickmarkrDir } from "../graph/graph.js";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
+// OBS-110: gate/baseline/tip-verify children are vitest suites; without a fork cap, concurrent
+// full-suite gate runs fork a worker-per-core pool per worktree and saturate the operator box.
+// Default to a modest cap through the environment so vitest honors it natively; never pass it
+// as argv (OBS-55) so child test oracles stay intact. The operator's own export wins.
+export const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export const DEFAULT_FORK_CAP = "6";
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 function shell(cmd, cwd, timeoutMs, login) {
@@ -15,6 +21,9 @@ function shell(cmd, cwd, timeoutMs, login) {
     const env = { ...process.env };
     for (const k of ROUTING_ENV_SEAMS)
         delete env[k];
+    // OBS-110: apply the default fork cap only when the operator has not already set one.
+    if (!(FORK_CAP_ENV in env))
+        env[FORK_CAP_ENV] = DEFAULT_FORK_CAP;
     return new Promise((resolve) => {
         // detached: bash gets its own process group so a timeout can kill the whole tree —
         // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes

package/dist/run/interactive-seed.d.ts

@@ -0,0 +1,15 @@
+import type { Assignment, WorkerAdapter } from "../adapters/types.js";
+import type { ExecutorDriver, Slot } from "../drivers/types.js";
+export interface InteractiveSeedResult {
+    output: string;
+    seedFailed: boolean;
+    seedError?: string;
+}
+export declare function runInteractiveSeed(opts: {
+    driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;
+    slot: Slot;
+    adapter: WorkerAdapter;
+    assignment: Assignment;
+    promptFile: string;
+    taskTimeoutMinutes: number;
+}): Promise<InteractiveSeedResult>;

package/dist/run/interactive-seed.js

@@ -0,0 +1,25 @@
+// v1.69 T6: launch-then-seed handoff for adapters whose real TUI cannot be argv-seeded.
+// Both the launch command and the seed line are delivered through the driver's existing `run`
+// primitive (pane-run on herdr). After the seed line is injected we read the pane back and
+// treat a seed that is still sitting in the input box as a hard failure (OBS-105 discipline).
+export async function runInteractiveSeed(opts) {
+    const seed = opts.adapter.interactiveSeed;
+    await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
+    const ready = await opts.driver.waitOutput(opts.slot, seed.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    if (!ready) {
+        const output = await opts.driver.read(opts.slot, 1000);
+        return { output, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+    }
+    const seedText = seed.seedLine(opts.promptFile);
+    await opts.driver.run(opts.slot, seedText);
+    let output = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await new Promise((r) => setTimeout(r, 200));
+        output = await opts.driver.read(opts.slot, 1000);
+        const bottom = output.trimEnd().split("\n").pop() ?? "";
+        if (!bottom.includes(seedText)) {
+            return { output, seedFailed: false };
+        }
+    }
+    return { output, seedFailed: true, seedError: "seed line never left the input box" };
+}

package/dist/tui/app.d.ts

@@ -9,6 +9,8 @@ export type View = {
         cols: number;
         rows: number;
     }): string[];
+    /** Optional per-view key handler (e.g. up/down cursor movement). */
+    key?(name: string): void;
 };
 export type StudioOptions = {
     input: InputStream;
@@ -59,6 +61,7 @@ export declare class StudioApp {
     private closeSave;
     private handleRevert;
     private setView;
+    private forwardViewKey;
     private showNotice;
     private paint;
     private buildFrame;

package/dist/tui/app.js

@@ -3,6 +3,7 @@ import { createFleetView } from "./views/fleet-view.js";
 import { createPreviewView } from "./views/preview-view.js";
 import { createProfileView } from "./views/profile-view.js";
 import { createRoutingView } from "./views/routing-view.js";
+import { createRunsView } from "./views/runs-view.js";
 import { renderDiffModal } from "./views/diff-modal.js";
 import { buildSaveProposal, confirmSave } from "./save.js";
 import { FleetStaging } from "./staging.js";
@@ -42,7 +43,7 @@ export class StudioApp {
         this.repoRoot = opts.repoRoot ?? process.cwd();
         this.globalDir = opts.globalDir;
         this.staging = new FleetStaging(opts.loaded ?? emptyFleetEditable());
-        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView()];
+        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView(), createRunsView()];
         this.exited = new Promise((resolve) => {
             this.resolveExit = resolve;
         });
@@ -91,6 +92,13 @@ export class StudioApp {
                     this.setView(idx);
             });
         }
+        // per-view navigation
+        for (const name of ["up", "down"]) {
+            this.engine.key(name, () => {
+                if (!this.isModalOpen)
+                    this.forwardViewKey(name);
+            });
+        }
         // help overlay
         this.engine.key("?", () => {
             if (!this.confirmingQuit && !this.showingSave) {
@@ -250,6 +258,10 @@ export class StudioApp {
         this.notice = null;
         this.paint();
     }
+    forwardViewKey(name) {
+        this.views[this.active]?.key?.(name);
+        this.paint();
+    }
     showNotice() {
         this.notice = READONLY_NOTICE;
         this.paint();
@@ -305,7 +317,7 @@ export class StudioApp {
     renderHelp() {
         return [
             "Key bindings",
-            "1-4      switch view",
+            "1-5      switch view",
             "tab      cycle views",
             "?        show this help",
             "esc / q  quit",

package/dist/tui/views/consult-dossier.d.ts

@@ -0,0 +1,49 @@
+import type { ConsultVerdict } from "../../run/consult.js";
+import type { JournalEvent } from "../../run/journal.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export declare const DOSSIER_PLACEHOLDER = "consult dossier viewer \u2014 stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export declare function renderDossierPlaceholder(): string;
+export type ConsultAction = ConsultVerdict["action"];
+/** One recorded consult verdict, with its persisted prompt content injected by the caller. */
+export interface DossierVerdict {
+    action: ConsultAction;
+    reason?: string;
+    notes?: string;
+    guidance?: string;
+    /** Persisted prompt content (the consults/<task>-<n>.md artifact), loaded by the caller. */
+    prompt?: string;
+}
+/** Everything the dossier panel renders — loaded by the caller, never by the render path. */
+export interface ConsultDossierData {
+    taskId: string;
+    /** Verdicts in dispatch order (journal order). */
+    verdicts: DossierVerdict[];
+}
+export interface ConsultDossierPanel {
+    /** Change the selected task. Any selection change invalidates every cached prompt render. */
+    select(data: ConsultDossierData | undefined): void;
+    /** "up"/"down" move the verdict cursor; "enter" toggles the selected verdict's dossier. */
+    key(name: string): void;
+    /** Render the panel body lines (chrome/divider lines are the host view's job). */
+    render(): string[];
+    /** Index of the expanded verdict, or null when collapsed. */
+    readonly expandedIndex: number | null;
+}
+/** Fold one task's consult-verdict journal events into dossier verdicts, in dispatch order.
+ *  Pure function over injected events. opts.prompts carries the persisted prompt contents in
+ *  the same dispatch order (the caller reads the consults/ artifacts); a verdict whose artifact
+ *  was not loaded simply has no prompt. Malformed events are skipped, never fatal. */
+export declare function foldConsultVerdicts(events: JournalEvent[], taskId: string, opts?: {
+    prompts?: string[];
+}): DossierVerdict[];
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export declare function translatePromptContent(content: string): string[];
+/** A verdict's guidance field is "imperative steps for the worker (newline-separated ok)" —
+ *  already list-shaped, so it renders as a bullet list, never a wall of prose. Pure. */
+export declare function renderGuidanceSteps(guidance: string): string[];
+/** The consult dossier panel. Stateful over injected data: a verdict cursor, at most one
+ *  expanded dossier, and a per-verdict render cache cleared only when the selection changes. */
+export declare function createConsultDossierPanel(initial?: ConsultDossierData, opts?: {
+    translate?: (content: string) => string[];
+}): ConsultDossierPanel;

package/dist/tui/views/consult-dossier.js

@@ -0,0 +1,169 @@
+// T2 (v1.68): consult dossier viewer — the Runs cockpit's detail panel.
+// Lists every consult verdict recorded for the selected task (action + reason, dispatch order)
+// and expands one verdict's persisted prompt content on request. Pure render over INJECTED data:
+// this module never touches the filesystem — the caller folds journal events and loads the
+// consults/ artifacts, then hands both in. The prompt-content translator is a hand-written
+// line-oriented pass over a known narrow subset (headings, blockquotes, bullets, fenced blocks),
+// never a markdown-AST dependency. Rendered prompt lines are cached per verdict and invalidated
+// only on selection change — never re-parsed on repaint (opencode's opentui regression lesson).
+// Read-only by construction: there is no edit or delete path for a dossier or a verdict.
+import { GLYPHS, bold, dim, warn } from "../../brand.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export const DOSSIER_PLACEHOLDER = "consult dossier viewer — stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export function renderDossierPlaceholder() {
+    return `  ${DOSSIER_PLACEHOLDER}`;
+}
+const ACTIONS = ["retry", "reroute", "decompose", "human"];
+/** Fold one task's consult-verdict journal events into dossier verdicts, in dispatch order.
+ *  Pure function over injected events. opts.prompts carries the persisted prompt contents in
+ *  the same dispatch order (the caller reads the consults/ artifacts); a verdict whose artifact
+ *  was not loaded simply has no prompt. Malformed events are skipped, never fatal. */
+export function foldConsultVerdicts(events, taskId, opts = {}) {
+    const verdicts = [];
+    for (const e of events) {
+        if (e.taskId !== taskId || e.event !== "consult-verdict")
+            continue;
+        const d = e.data;
+        if (typeof d.action !== "string" || !ACTIONS.includes(d.action))
+            continue;
+        verdicts.push({
+            action: d.action,
+            ...(typeof d.reason === "string" ? { reason: d.reason } : {}),
+            ...(typeof d.notes === "string" ? { notes: d.notes } : {}),
+            ...(typeof d.guidance === "string" ? { guidance: d.guidance } : {}),
+        });
+    }
+    if (opts.prompts) {
+        for (const [i, prompt] of opts.prompts.entries()) {
+            if (verdicts[i])
+                verdicts[i].prompt = prompt;
+        }
+    }
+    return verdicts;
+}
+// ── prompt-content translator ────────────────────────────────────────────────
+// Hand-written, line-oriented, pure. Known subset only: ATX headings (# = bold, deeper = dim),
+// `> ` blockquotes (dim `│ ` bar prefix), `- `/`* ` bullets (• marker), ``` fenced blocks
+// (dim, indented), everything else passes through plain. No markdown-AST dependency.
+const HEADING_RE = /^(#{1,6})[ \t]+(.*)$/;
+const QUOTE_RE = /^>[ \t]?(.*)$/;
+const BULLET_RE = /^[-*][ \t]+(.*)$/;
+const FENCE_RE = /^\s*```/;
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export function translatePromptContent(content) {
+    const out = [];
+    let fenced = false;
+    for (const raw of content.split("\n")) {
+        const line = raw.replace(/\s+$/, "");
+        if (FENCE_RE.test(line)) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced) {
+            out.push(line.trim() ? dim(`    ${line}`) : "");
+            continue;
+        }
+        const heading = HEADING_RE.exec(line);
+        if (heading) {
+            out.push(heading[1].length === 1 ? bold(heading[2]) : dim(heading[2]));
+            continue;
+        }
+        const quote = QUOTE_RE.exec(line);
+        if (quote) {
+            out.push(dim(`│ ${quote[1]}`));
+            continue;
+        }
+        const bullet = BULLET_RE.exec(line);
+        if (bullet) {
+            out.push(`• ${bullet[1]}`);
+            continue;
+        }
+        out.push(line);
+    }
+    return out;
+}
+/** A verdict's guidance field is "imperative steps for the worker (newline-separated ok)" —
+ *  already list-shaped, so it renders as a bullet list, never a wall of prose. Pure. */
+export function renderGuidanceSteps(guidance) {
+    return guidance
+        .split(/\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => `• ${s}`);
+}
+/** The consult dossier panel. Stateful over injected data: a verdict cursor, at most one
+ *  expanded dossier, and a per-verdict render cache cleared only when the selection changes. */
+export function createConsultDossierPanel(initial, opts = {}) {
+    const translate = opts.translate ?? translatePromptContent;
+    let data = initial;
+    let cursor = 0;
+    let expanded = null;
+    // Per-verdict cached render of the expanded dossier block — parsed once, reused on every
+    // later expand of the same verdict within the same selection; never re-parsed per repaint.
+    const cache = new Map();
+    const dossierBlock = (verdict, index) => {
+        const hit = cache.get(index);
+        if (hit)
+            return hit;
+        const lines = [];
+        lines.push(dim(`── persisted prompt · consult · ${data?.taskId ?? "?"} · verdict ${index + 1} ──`));
+        if (verdict.prompt !== undefined)
+            lines.push(...translate(verdict.prompt));
+        else
+            lines.push(dim("(no persisted prompt content recorded for this verdict)"));
+        lines.push(`action: ${verdict.action}`);
+        const steps = verdict.guidance ? renderGuidanceSteps(verdict.guidance) : [];
+        if (steps.length > 0) {
+            lines.push("guidance:");
+            for (const s of steps)
+                lines.push(`  ${s}`);
+        }
+        cache.set(index, lines);
+        return lines;
+    };
+    return {
+        get expandedIndex() {
+            return expanded;
+        },
+        select(next) {
+            data = next;
+            cursor = 0;
+            expanded = null;
+            cache.clear();
+        },
+        key(name) {
+            if (!data || data.verdicts.length === 0)
+                return;
+            if (name === "up")
+                cursor = Math.max(cursor - 1, 0);
+            else if (name === "down")
+                cursor = Math.min(cursor + 1, data.verdicts.length - 1);
+            else if (name === "enter")
+                expanded = expanded === cursor ? null : cursor;
+        },
+        render() {
+            if (!data)
+                return [];
+            if (data.verdicts.length === 0) {
+                return [
+                    `  no consult verdicts recorded for ${data.taskId} — every attempt finished without needing a consult.`,
+                ];
+            }
+            const lines = [];
+            data.verdicts.forEach((verdict, i) => {
+                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
+                // Consult actions are not pass/fail: human → warn (needs the operator), the rest plain.
+                const actionWord = verdict.action === "human" ? warn(verdict.action) : verdict.action;
+                const reason = verdict.reason ?? verdict.notes;
+                const hint = dim(i === expanded ? "[enter: collapse]" : "[enter: expand]");
+                lines.push(`  ${pointer}${i + 1}. ${actionWord}${reason ? ` — ${reason}` : ""}  ${hint}`);
+                if (i === expanded) {
+                    for (const l of dossierBlock(verdict, i))
+                        lines.push(`     ${l}`);
+                }
+            });
+            return lines;
+        },
+    };
+}