tickmarkr 1.78.0 → 1.80.0

package/dist/cli/commands/status.js

@@ -1,7 +1,7 @@
 import { BANNER, GLYPHS, dim, fail, legend, ok, rule, statusRow, title, warn } from "../../brand.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
-import { formatOwnedName } from "../../drivers/types.js";
-import { blockedTasks, graphDefinitionHash, loadGraph } from "../../graph/graph.js";
+import { formatOwnedName, } from "../../drivers/types.js";
+import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
@@ -18,6 +18,89 @@ const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇",
 const ASCII_SPINNER = ["|", "/", "-", "\\"];
 const SAVE_TERMINAL_TITLE = "\x1b[22;0t";
 const RESTORE_TERMINAL_TITLE = "\x1b[23;0t";
+const decisionEvidence = (stateDir, runId, sequence) => `${stateDir}/runs/${runId}/journal.jsonl#L${sequence}`;
+// v1.79 T4: a deterministic JSONL projection over journal truth. Sequence/evidence come from the
+// append-only line position, timestamps and claims come from the row, and no watcher-local clock or
+// filesystem write participates. Re-reading the same bytes therefore returns the same event bytes.
+export const decisionEventsFromJournal = (events, runId, stateDir = ".tickmarkr") => events.flatMap((event, index) => {
+    const sequence = index + 1;
+    const base = {
+        version: 1,
+        sequence,
+        ts: event.ts,
+        runId,
+        evidence: decisionEvidence(stateDir, runId, sequence),
+        ...(event.taskId ? { taskId: event.taskId } : {}),
+    };
+    if (event.event === "phase-start" && typeof event.data.phase === "string") {
+        return [{ ...base, type: "phase-change", tier: "routine", phase: event.data.phase }];
+    }
+    if (event.event === "gate-result" && typeof event.data.gate === "string") {
+        const verdict = event.data.skipped === true
+            ? "skipped"
+            : event.data.pass === true
+                ? "passed"
+                : event.data.pass === false
+                    ? "failed"
+                    : "unknown";
+        return [{
+                ...base,
+                type: "gate-verdict",
+                tier: verdict === "failed" ? "decision" : "routine",
+                gate: event.data.gate,
+                verdict,
+            }];
+    }
+    if (event.event === "escalation") {
+        return [{
+                ...base,
+                type: "escalation",
+                tier: "decision",
+                ...(typeof event.data.step === "string" ? { step: event.data.step } : {}),
+                ...(typeof event.data.attempt === "number" ? { attempt: event.data.attempt } : {}),
+            }];
+    }
+    if (event.event === "task-human" && event.taskId) {
+        return [{
+                ...base,
+                type: "human-decision-required",
+                tier: "decision",
+                approvalCommand: `tickmarkr approve ${runId} ${event.taskId}`,
+                ...(typeof event.data.kind === "string" ? { kind: event.data.kind } : {}),
+                ...(typeof event.data.reason === "string" ? { reason: event.data.reason } : {}),
+            }];
+    }
+    if (event.event === "run-end") {
+        return [{
+                ...base,
+                type: "run-end",
+                tier: "decision",
+                summary: event.data,
+            }];
+    }
+    return [];
+});
+const optionValue = (argv, name) => {
+    const inline = argv.find((arg) => arg.startsWith(`${name}=`));
+    if (inline)
+        return inline.slice(name.length + 1) || undefined;
+    const index = argv.indexOf(name);
+    const value = index >= 0 ? argv[index + 1] : undefined;
+    return value && !value.startsWith("-") ? value : undefined;
+};
+const defaultPostWebhook = (url, event) => fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(event),
+}).then(() => undefined);
+const postWebhookFireAndForget = (post, url, event) => {
+    try {
+        void Promise.resolve(post(url, event)).catch(() => undefined);
+    }
+    catch {
+        // Webhooks are observational. A synchronous bridge failure is as inert as a rejected request.
+    }
+};
 const taskPhase = (value) => {
     if (value === "worker" || value === "gates" || value === "judge" || value === "review" || value === "merge")
         return value;
@@ -204,6 +287,91 @@ const terminalFailureCause = (events) => {
     }
     return undefined;
 };
+const tipFailureEvidence = (events, start, end) => {
+    const gates = new Set();
+    let fingerprints = 0;
+    let hasFingerprintCount = false;
+    for (let i = start; i <= end; i++) {
+        const event = events[i];
+        if (event.event !== "tip-verify-failed")
+            continue;
+        if (typeof event.data.gate === "string" && event.data.gate.trim())
+            gates.add(event.data.gate.trim());
+        if (Array.isArray(event.data.fingerprints)) {
+            fingerprints += event.data.fingerprints.length;
+            hasFingerprintCount = true;
+        }
+    }
+    return { gates: [...gates], ...(hasFingerprintCount ? { fingerprints } : {}) };
+};
+const priorLifecycleIndex = (events, end) => {
+    for (let i = end; i >= 0; i--) {
+        if (events[i].event === "run-start" || events[i].event === "run-resume")
+            return i;
+    }
+    return 0;
+};
+// OBS-146: tip verification is a run phase, folded exclusively from append-only journal facts.
+// A completed run-end owns passed/failed; a later resume keeps the prior failure visible while
+// recording a re-verification attempt; an active run becomes pending only after a recorded merge
+// and recorded non-empty command set make a tip verification applicable. Unknown evidence stays
+// unknown rather than borrowing optimistic state from graph.json.
+const tipVerifyPhase = (events) => {
+    let lastRunEnd = -1;
+    let lastLifecycle = -1;
+    let attempts = 0;
+    let hasCommands = false;
+    let hasMerge = false;
+    for (let i = 0; i < events.length; i++) {
+        const event = events[i];
+        if (event.event === "run-start" || event.event === "run-resume") {
+            lastLifecycle = i;
+            attempts++;
+            if (event.event === "run-start" && typeof event.data.commands === "object" && event.data.commands !== null
+                && !Array.isArray(event.data.commands) && Object.keys(event.data.commands).length > 0) {
+                hasCommands = true;
+            }
+        }
+        else if (event.event === "run-end") {
+            lastRunEnd = i;
+        }
+        else if (event.event === "merge") {
+            hasMerge = true;
+        }
+    }
+    if (lastRunEnd >= 0 && events[lastRunEnd].data.tipVerify === "failed") {
+        const failureStart = priorLifecycleIndex(events, lastRunEnd);
+        const priorFailure = tipFailureEvidence(events, failureStart, lastRunEnd);
+        if (lastLifecycle > lastRunEnd) {
+            const currentFailure = tipFailureEvidence(events, lastLifecycle, events.length - 1);
+            if (currentFailure.gates.length > 0 || currentFailure.fingerprints !== undefined) {
+                return { state: "failed", ...currentFailure };
+            }
+            return { state: "re-verifying", ...priorFailure, attempt: Math.max(2, attempts) };
+        }
+        return { state: "failed", ...priorFailure };
+    }
+    if (lastLifecycle > lastRunEnd) {
+        const currentFailure = tipFailureEvidence(events, lastLifecycle, events.length - 1);
+        if (currentFailure.gates.length > 0 || currentFailure.fingerprints !== undefined) {
+            return { state: "failed", ...currentFailure };
+        }
+        if (hasCommands && hasMerge)
+            return { state: "pending", gates: [] };
+    }
+    return undefined;
+};
+const tipVerifyText = (phase) => {
+    if (phase.state === "pending")
+        return "tip-verify: pending";
+    const gates = phase.gates.length ? phase.gates.join(", ") : "gate unknown";
+    const failed = `tip-verify: FAILED (${gates})`;
+    const reverify = phase.state === "re-verifying" ? ` → re-verifying (attempt ${phase.attempt})` : "";
+    const fingerprints = phase.fingerprints === undefined
+        ? ""
+        : ` · ${phase.fingerprints} fingerprint${phase.fingerprints === 1 ? "" : "s"}`;
+    return `${failed}${reverify}${fingerprints}`;
+};
 const liveness = (events, now = Date.now()) => {
     const last = events.at(-1);
     if (!last)
@@ -289,6 +457,7 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     const width = process.stdout.columns ?? 120;
     const done = effective.tasks.filter((t) => t.status === "done").length;
     const ended = comparable && runHasEnded(events);
+    const tipPhase = comparable ? tipVerifyPhase(events) : undefined;
     const taskIds = new Set(g.tasks.map((task) => task.id));
     const phases = comparable ? livePhases(events) : new Map();
     for (const taskId of phases.keys())
@@ -326,7 +495,7 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
         });
         const header = runId
-            ? `tickmarkr status${divider}run ${runId}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, now).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
+            ? `tickmarkr status${divider}run ${runId}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, now).replaceAll(" · ", divider)}${tipPhase ? `${divider}${tipVerifyText(tipPhase)}` : ""}${divider}${tipPhase ? `${done}/${g.tasks.length} tasks done${divider}run not verified` : `${done}/${g.tasks.length} done`}`
             : `tickmarkr status${divider}no runs yet${divider}${done}/${g.tasks.length} done`;
         const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
         return {
@@ -344,18 +513,25 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     const anyFailed = cells.some((c) => c.redTier);
     const gaugeCells = 10;
     const fill = g.tasks.length ? Math.round((done / g.tasks.length) * gaugeCells) : 0;
-    const gauge = (fill ? (anyFailed ? fail : ok)("█".repeat(fill)) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
+    const tipFailed = tipPhase?.state === "failed";
+    const progressTone = anyFailed || tipFailed ? fail : tipPhase ? warn : ok;
+    const gauge = (fill ? progressTone("█".repeat(fill)) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
     const live = liveness(events, now)
         .replace(/\bdead\b/, fail("dead"))
         .replace(/\bfinished\b/, dim("finished"))
         .replace(/\balive\b/, ok("alive"))
         .replaceAll(" · ", dot);
-    const tally = `${done}/${g.tasks.length} done`;
+    const tally = tipPhase
+        ? `${progressTone(`${done}/${g.tasks.length} tasks done`)}${dot}${progressTone("run not verified")}`
+        : `${done}/${g.tasks.length} done`;
+    const tipStatus = tipPhase
+        ? `${tipFailed ? fail(tipVerifyText(tipPhase)) : warn(tipVerifyText(tipPhase))}${dot}`
+        : "";
     const header = ` ${title(runId ? `run ${runId}` : "tickmarkr")}${dot}` +
         (runId
-            ? `${supersededBy ? `${warn(`superseded by ${supersededBy}`)}${dot}` : ""}${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}`
+            ? `${supersededBy ? `${warn(`superseded by ${supersededBy}`)}${dot}` : ""}${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}${tipStatus}`
             : `no runs yet${dot}`) +
-        `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
+        `${gauge} ${tipPhase ? tally : done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
     const hr = rule(Math.min(width, 100));
     // OBS-104 run-level now line: names the most recent journal event. TTY frame only — the non-TTY
     // machine surface is byte-pinned (status-brand golden) and must not drift. Rendered BELOW the task
@@ -417,15 +593,21 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         const { content } = renderFrame(cwd, opts.now?.() ?? Date.now());
         return visual() ? BANNER + content : content;
     }
+    const eventStream = argv.some((arg) => arg === "--events" || arg === "--jsonl" || arg === "--decision-events");
+    const webhookUrl = opts.webhookUrl
+        ?? optionValue(argv, "--webhook")
+        ?? process.env.TICKMARKR_DECISION_WEBHOOK;
+    const postWebhook = opts.postWebhook ?? defaultPostWebhook;
     const iterations = opts.iterations ?? Infinity;
     const sleep = opts.sleep ?? defaultSleep;
     const now = opts.now ?? Date.now;
     const bounded = Number.isFinite(iterations);
     const frames = [];
+    const eventLines = [];
     const sep = "\n---\n";
-    const tty = visual();
+    const tty = !eventStream && visual();
     const workerLiveness = new Map();
-    const herdr = HerdrDriver.available() ? new HerdrDriver() : undefined;
+    const herdr = !eventStream && HerdrDriver.available() ? new HerdrDriver() : undefined;
     const readWorkerOutput = opts.readWorkerOutput ?? (herdr
         ? async (taskId, attempt, runId) => {
             const name = formatOwnedName({ role: "worker", taskId, attempt, runId });
@@ -467,6 +649,30 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             prior.snapshot = snapshot;
         }));
     };
+    let decisionRunId;
+    let journalCursor = 0;
+    const consumeDecisionEvents = () => {
+        const runId = Journal.latestRunId(cwd, { withJournal: true });
+        if (!runId)
+            return [];
+        if (decisionRunId !== runId) {
+            decisionRunId = runId;
+            journalCursor = 0;
+        }
+        const journalEvents = Journal.open(cwd, runId).read();
+        if (journalEvents.length < journalCursor)
+            journalCursor = 0;
+        const fresh = decisionEventsFromJournal(journalEvents, runId, stateDirName(cwd))
+            .filter((event) => event.sequence > journalCursor);
+        journalCursor = journalEvents.length;
+        if (webhookUrl) {
+            for (const event of fresh) {
+                if (event.tier === "decision")
+                    postWebhookFireAndForget(postWebhook, webhookUrl, event);
+            }
+        }
+        return fresh;
+    };
     let titleSaved = false;
     const restoreTitle = () => {
         if (!titleSaved)
@@ -492,18 +698,31 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     try {
         for (let i = 0; i < iterations; i++) {
             const nowMs = now();
-            const frame = renderFrame(cwd, nowMs, i, workerLiveness);
-            if (tty) {
-                updateTitle(frame.hotPhase, nowMs);
-                process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame.content}\n${legend(` watching · refresh ${REFRESH_MS / 1000}s · ^C to quit`)}`);
+            const decisionEvents = eventStream || webhookUrl ? consumeDecisionEvents() : [];
+            let frame;
+            if (eventStream) {
+                for (const event of decisionEvents) {
+                    const line = JSON.stringify(event);
+                    process.stdout.write(line + "\n");
+                    if (bounded)
+                        eventLines.push(line);
+                }
             }
             else {
-                process.stdout.write(frame.content + sep);
+                frame = renderFrame(cwd, nowMs, i, workerLiveness);
+                if (tty) {
+                    updateTitle(frame.hotPhase, nowMs);
+                    process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame.content}\n${legend(` watching · refresh ${REFRESH_MS / 1000}s · ^C to quit`)}`);
+                }
+                else {
+                    process.stdout.write(frame.content + sep);
+                }
+                if (bounded)
+                    frames.push(frame.content);
             }
-            if (bounded)
-                frames.push(frame.content);
             if (i + 1 < iterations) {
-                await observeWorkerOutput(frame.workerPhases, frame.runId, nowMs);
+                if (frame)
+                    await observeWorkerOutput(frame.workerPhases, frame.runId, nowMs);
                 await sleep(REFRESH_MS);
             }
         }
@@ -514,5 +733,5 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             restoreTitle();
         }
     }
-    return bounded ? frames.join(sep) : "";
+    return bounded ? eventStream ? eventLines.join("\n") : frames.join(sep) : "";
 }

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>): Promise<string | {
     out: string;
     code: number;
 }>;

package/dist/cli/commands/ui.js

@@ -1,10 +1,20 @@
 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 = {}) {
+export async function ui(argv, io = {}) {
     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 };
     }
+    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 { runStudioInk } = await import("../../tui/ink/studio-app.js");
     await runStudioInk({ input, output });
     return "ui: closed";

package/dist/drivers/herdr.js

@@ -112,7 +112,14 @@ export class HerdrDriver {
     }
     // ponytail: narrow panes hard-wrap the input line — collapse whitespace before comparing.
     deliveryMatches(transcript, cmd) {
-        const norm = (s) => s.replace(/\s+/g, "");
+        // OBS-154: a TUI editor re-wraps a long delivery across its own bordered rows, so the pane text
+        // carries `│` between fragments we typed as ONE line. Stripping whitespace alone left the needle
+        // uncontainable, so the read-back could not recognize its own SUCCESSFUL delivery and the OBS-85
+        // guard then refused to retype onto what it had been told was corruption (probe 6b).
+        // This is the opposite question to shellExecutionEchoed, which deliberately REJECTS box rows: a
+        // shell echo must come from a shell prompt, whereas here we only ask whether our text landed —
+        // and inside the editor box is exactly where it is supposed to land.
+        const norm = (s) => s.replace(/[│┃|]/g, "").replace(/\s+/g, "");
         const hay = norm(transcript);
         const needle = norm(cmd);
         return needle.length > 0 && hay.includes(needle);
@@ -149,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() {
@@ -576,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/drivers/types.d.ts

@@ -5,11 +5,32 @@ export interface Slot {
     tabId?: string;
     group?: string;
 }
-export type NotifyTier = "routine" | "attention";
+export type NotifyTier = "routine" | "attention" | "decision";
 export interface NotifyOpts {
     tier?: NotifyTier;
     sound?: "none" | "done" | "request";
 }
+export type DecisionEventType = "phase-change" | "gate-verdict" | "escalation" | "human-decision-required" | "run-end";
+export interface DecisionEvent {
+    version: 1;
+    sequence: number;
+    type: DecisionEventType;
+    tier: "routine" | "decision";
+    ts: string;
+    runId: string;
+    taskId?: string;
+    evidence: string;
+    phase?: string;
+    gate?: string;
+    verdict?: "passed" | "failed" | "skipped" | "unknown";
+    step?: string;
+    attempt?: number;
+    kind?: string;
+    reason?: string;
+    approvalCommand?: string;
+    summary?: Record<string, unknown>;
+}
+export type DecisionWebhookPost = (url: string, event: DecisionEvent) => void | Promise<unknown>;
 export interface SlotOpts {
     group?: string;
     label?: string;

package/dist/gates/acceptance.d.ts

@@ -14,6 +14,11 @@ export interface JudgeVerdict {
         reason: string;
         evidence: string | EvidenceCitation;
     }>;
+    comments?: Array<{
+        path: string;
+        line: number;
+        body: string;
+    }>;
 }
 export declare function judgeCriterionId(index: number): string;
 export declare function testFiltered(testCmd: string, name: string): string;

package/dist/gates/acceptance.js

@@ -4,7 +4,7 @@ import { DEFAULT_DIFF_CAP } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { sh } from "../run/git.js";
 import { checkDiffCap, fetchTaskDiff } from "./review.js";
-import { COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
 // Fable F4: acceptance judge shares review's 900s timeout — 300s default killed frontier judges on cap-sized diffs.
 const JUDGE_TIMEOUT_MS = 900_000;
 const CitationSchema = z.object({ path: z.string(), line: z.number().int() });
@@ -278,9 +278,10 @@ ${citable || "(the diff changes no lines)"}
 ${verdictNonceLine(nonce)}
 
 Respond with ONLY this JSON (no prose before or after):
-{"nonce": "${nonce}", "pass": true|false, "criteria": [{"criterion": "c1", "met": true|false, "reason": "...", "evidence": {"path": "path/to/file", "line": 42}}]}
+{"nonce": "${nonce}", "pass": true|false, "criteria": [{"criterion": "c1", "met": true|false, "reason": "...", "evidence": {"path": "path/to/file", "line": 42}}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback"}]}
 Each criteria[].criterion MUST be the stable id from the rubric (c1, c2, ...) exactly once.
 Each criteria[].evidence MUST be a structured citation {"path", "line"} whose "path" and "line" appear in the "Citable evidence lines" list above (a new-file line number inside a changed hunk); a citation outside every changed hunk or to an untouched file voids the whole verdict.
+The top-level comments array is optional. Use it only for actionable line-anchored feedback.
 `;
     const raw = await runLlm(judge.adapter, judge.model, prompt, worktree, via, JUDGE_TIMEOUT_MS);
     const extracted = extractVerdictJson(raw, nonce);
@@ -309,5 +310,6 @@ Each criteria[].evidence MUST be a structured citation {"path", "line"} whose "p
     if (!v.pass)
         lines.push("judge verdict pass=false");
     lines.push(...inconsistencies);
-    return { gate: "acceptance", pass, details: warn + detBlock + (lines.join("\n") || "judge passed") };
+    const prose = warn + detBlock + (lines.join("\n") || "judge passed");
+    return { gate: "acceptance", pass, details: appendAnchoredReview(prose, extracted) };
 }

package/dist/gates/llm.d.ts

@@ -4,6 +4,14 @@ export declare const GATE_PANE_SEP = " \u00B7 ";
 export declare const COMPLETION_FAKING_CHECKLIST = "## Completion-faking checklist\nHunt for these concrete completion-faking shortcuts before ruling on any criterion:\n- hardcoded-result: output or fixture hardcoded to satisfy the stated criterion instead of real logic\n- test-weakening: tests skipped, deleted, or assertions loosened until failing behavior looks green\n- vacuous-assertion: a test that cannot fail (asserts a constant, asserts its own setup, no assertion)\n- fixture-overfit: implementation narrowed to the exact test inputs rather than the described behavior\n- echo-not-implement: criterion text echoed in names, comments, or strings without the behavior itself\n- stub-left-behind: TODO, throw, or no-op stub where the real implementation should be\n- error-swallowing: catch or fallback that hides failures instead of handling them\n- self-mocking: the code under test mocked or faked so the test exercises the mock\n- check-bypass: lint, type, or CI checks disabled, relaxed, or excluded to get green\n- rename-as-work: code moved or renamed and presented as the requested change\n- scope-padding: unrelated edits padding the diff while the criterion's behavior is untouched\nWhen a criterion fails, the verdict MUST name which shortcut above it matches, or state that none does.";
 /** Fable F3: per-call nonce echoed in verdict JSON and gate exit markers. */
 export declare function generateVerdictNonce(): string;
+export interface AnchoredComment {
+    path: string;
+    line: number;
+    body: string;
+}
+export declare function parseAnchoredComments(verdict: unknown): AnchoredComment[];
+export declare function renderAnchoredReview(verdict: unknown): string;
+export declare function appendAnchoredReview(prose: string, verdict: unknown): string;
 export declare function verdictNonceLine(nonce: string): string;
 export declare function extractPromptNonce(prompt: string): string | null;
 export declare function gateExitTrailer(nonce: string): string;
@@ -32,6 +40,7 @@ export declare function captureLlmOutput<T>(run: () => Promise<T>): Promise<{
 }>;
 export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
 export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;
+export declare function dewrapPaneVerdict(out: string, nonce: string): string;
 export declare function runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<string>;
 export declare function extractJson<T>(raw: string): T | null;
 /** Fable F3: verdict JSON must echo the call nonce — skip unbound or mismatched objects. */

package/dist/gates/llm.js

@@ -27,6 +27,39 @@ When a criterion fails, the verdict MUST name which shortcut above it matches, o
 export function generateVerdictNonce() {
     return randomBytes(4).toString("hex");
 }
+// v1.79 T5: comments are an optional side channel on an otherwise authoritative verdict. The whole
+// block is accepted only when every row names one actionable path:line; absent or malformed input
+// becomes no comments and therefore preserves the pre-comments prose bytes and verdict semantics.
+export function parseAnchoredComments(verdict) {
+    if (!verdict || typeof verdict !== "object")
+        return [];
+    const raw = verdict.comments;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return [];
+    const comments = [];
+    for (const row of raw) {
+        if (!row || typeof row !== "object")
+            return [];
+        const { path, line, body } = row;
+        const cleanPath = typeof path === "string" ? path.trim() : "";
+        const cleanBody = typeof body === "string" ? body.trim() : "";
+        if (!cleanPath || /[\r\n]/.test(cleanPath) || !Number.isInteger(line) || line < 1 || !cleanBody) {
+            return [];
+        }
+        comments.push({ path: cleanPath, line: line, body: cleanBody });
+    }
+    return comments;
+}
+export function renderAnchoredReview(verdict) {
+    const comments = parseAnchoredComments(verdict);
+    if (comments.length === 0)
+        return "";
+    return `## Anchored review\n${comments.map((c) => `- ${c.path}:${c.line} — ${c.body}`).join("\n")}`;
+}
+export function appendAnchoredReview(prose, verdict) {
+    const block = renderAnchoredReview(verdict);
+    return block ? `${prose}\n\n${block}` : prose;
+}
 export function verdictNonceLine(nonce) {
     return `VERDICT_NONCE: ${nonce}`;
 }
@@ -128,6 +161,47 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
     if (!via.keep)
         await via.driver.close(slot);
     out = augmentFakeVerdictOutput(adapter, out, nonce, prompt);
+    return dewrapPaneVerdict(out, nonce);
+}
+// OBS-155: a TUI renders the verdict as a bullet and HARD-wraps it at pane width with a 2-space
+// continuation indent, splitting words mid-token — so literal newlines land inside JSON string
+// literals and ZERO lines begin with `{`. `--source recent-unwrapped` cannot undo it: the wrap is
+// the TUI's own rendering, not a terminal soft wrap (driver.read already requests that source, and
+// the captured k3 transcript arrived wrapped anyway). A perfect verdict was therefore scored a
+// flake and rescued by a retry on another channel — 70 such judge-retries are on record across
+// k3, fable AND sol, so this is a width-dependent flake generator under every pane-mode gate.
+//
+// Fail-closed by construction, per the overseer's constraints: reconstruction is bounded to the
+// brace-delimited region, the rejoined text must PARSE, and it must carry THIS call's nonce.
+// Anything else returns the bytes untouched, so an unparseable verdict stays a failure. The
+// reconstruction is APPENDED, never substituted: extractJson takes the last balanced object, so
+// the good copy wins while the original rendering survives verbatim for the evidence capture.
+export function dewrapPaneVerdict(out, nonce) {
+    if (!out.includes(nonce))
+        return out;
+    const lines = out.split("\n");
+    const start = lines.findIndex((line) => /^\s*(?:[•*-]\s+)?\{/.test(line));
+    if (start < 0)
+        return out;
+    for (let end = start; end < lines.length; end++) {
+        const joined = lines
+            .slice(start, end + 1)
+            .map((line, i) => (i === 0 ? line.replace(/^\s*(?:[•*-]\s+)?/, "") : line.replace(/^\s+/, "")))
+            .join("")
+            .trimEnd();
+        if (!joined.endsWith("}"))
+            continue;
+        try {
+            const parsed = JSON.parse(joined);
+            // the nonce IS the acceptance test — never reconstruct a verdict this call did not ask for
+            if (parsed && typeof parsed === "object" && parsed.nonce === nonce) {
+                return `${out}\n${joined}`;
+            }
+        }
+        catch {
+            /* not yet a complete object — keep extending within the bounded region */
+        }
+    }
     return out;
 }
 export async function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {

package/dist/gates/review.d.ts

@@ -14,6 +14,11 @@ export interface ReviewVerdict {
     approve?: boolean;
     issues?: string[];
     findings?: ReviewFinding[];
+    comments?: Array<{
+        path: string;
+        line: number;
+        body: string;
+    }>;
 }
 export declare function fetchTaskDiff(worktree: string, baseRef: string): Promise<{
     full: string;