@iowarp/clio-coder 0.3.9 → 0.4.0

package/src/interactive/overlays/side-question.ts

@@ -112,6 +112,7 @@ export function openSideQuestionOverlay(tui: TUI, options: OpenSideQuestionOverl
 	const handle = showClioOverlayFrame(tui, body, {
 		anchor: "center",
 		width: sideQuestionOverlayWidth(options.columns),
+		markerId: "side-question",
 		title: SIDE_QUESTION_OVERLAY_TITLE,
 		// Esc means two things here and the footer names the live one: it aborts a
 		// round that is still streaming, and it closes one that has settled.

package/src/interactive/overlays/skills-hub.ts

@@ -26,6 +26,7 @@ import type { NoticeLevel } from "../command-output.js";
 import { clioTheme, GLYPH } from "../theme/index.js";
 import type { LibraryInstallConfirmSubject } from "./library-install-confirm.js";
 import { openLibraryInstallConfirmOverlay } from "./library-install-confirm.js";
+import { isLibraryTab, LIBRARY_TABS } from "./library-tabs.js";
 import { type ListOverlayItem, type ListOverlayTab, openListOverlay } from "./list-overlay.js";
 
 /**
@@ -53,23 +54,13 @@ const GROUP_DIAGNOSTICS = "Diagnostics";
 const GROUP_INSTALLED = "Installed";
 const GROUP_AVAILABLE = "Available";
 
-/** The hub's tabs, in the order ←/→ walks them. `skill` is the original view. */
-export const LIBRARY_TABS: ReadonlyArray<{ id: LibraryEntryKind; label: string }> = [
-	{ id: "skill", label: "Skills" },
-	{ id: "agent", label: "Agents" },
-	{ id: "prompt", label: "Prompts" },
-	{ id: "fleet", label: "Fleets" },
-];
+export { isLibraryTab, LIBRARY_TABS };
 
 export const SKILLS_HUB_TITLE = "Skills Hub";
 
 /** Row id prefix for a library row, which is how an action tells the tabs apart. */
 export const LIBRARY_ROW_PREFIX = "library:";
 
-export function isLibraryTab(value: string): value is LibraryEntryKind {
-	return LIBRARY_TABS.some((tab) => tab.id === value);
-}
-
 /** @internal exported for contract tests */
 export const SKILLS_HUB_EMPTY =
 	"no skills installed and no local marketplace configured. install one with `clio-coder skills install <path|github-url>`, or point CLIO_CODER_SKILL_CATALOG_DIR at a skills/ catalog.";
@@ -557,6 +548,7 @@ export function openSkillsHub(tui: TUI, deps: SkillsHubDeps): OverlayHandle {
 	};
 
 	handle = openListOverlay(tui, {
+		markerId: "skills-hub",
 		title: SKILLS_HUB_TITLE,
 		items: [],
 		tabs,

package/src/interactive/overlays/tree-selector.ts

@@ -416,6 +416,7 @@ export function openTreeOverlay(tui: TUI, deps: OpenTreeOverlayDeps): OverlayHan
 	return showClioOverlayFrame(tui, box, {
 		anchor: "center",
 		width: TREE_OVERLAY_WIDTH,
+		markerId: "tree",
 		title: "Session Tree",
 		footerHint: () => view.getHint(),
 	});

package/src/interactive/pane-policy.ts

@@ -0,0 +1,46 @@
+/**
+ * The one decision function for opening a run-watching pane.
+ *
+ * Policy, stated whole: panes are pulled by the operator, never pushed by the
+ * fleet. A dispatch starting, detaching, backgrounding, or failing opens
+ * nothing; the native surfaces (transcript, Alt+W board, footer) already carry
+ * that state, and the v0.3/v0.4 behavior of opening a hidden viewer pane per
+ * dispatch produced panes nobody had asked for. A pane opens only when the
+ * operator names a run: Enter in the workers view, `/panes show`, or the
+ * `panes` tool acting on the conversation's behalf.
+ *
+ * The `dispatch` source is the seam for ever marking a dispatch watchable at
+ * enqueue time. It exists so the decision stays in this one function; today it
+ * always refuses, and any future exception must be argued here, not in a
+ * config key.
+ *
+ * This module is a leaf on purpose: `panes-runtime.ts` is a boundaries seam
+ * whose value closure must stay off the render graph, so the policy cannot
+ * live beside the dispatch board that shares its status vocabulary.
+ */
+
+export type PaneWatchSource = "workers-view" | "slash" | "tool" | "dispatch";
+
+/** Statuses with a live process behind them, in the dispatch board's vocabulary. */
+const WATCHABLE_STATUSES = new Set(["running", "stale", "cancelling", "enqueued", "retrying"]);
+
+export interface PaneWatchRequest {
+	source: PaneWatchSource;
+	/** The run's lifecycle status; anything unrecognized reads as terminal. */
+	runStatus: string;
+}
+
+export type PaneWatchDecision = { open: true } | { open: false; reason: string };
+
+export function paneWatchDecision(request: PaneWatchRequest): PaneWatchDecision {
+	if (request.source === "dispatch") {
+		return { open: false, reason: "dispatches run headless; watch a run from the workers view or /panes show" };
+	}
+	if (!WATCHABLE_STATUSES.has(request.runStatus)) {
+		return {
+			open: false,
+			reason: `run is ${request.runStatus}; use \`clio-coder fleet view <runId>\` for the post-mortem`,
+		};
+	}
+	return { open: true };
+}

package/src/interactive/panes-runtime.ts

@@ -0,0 +1,292 @@
+/**
+ * The one implementation of `PanesOperations`, shared by `/panes` and the
+ * `panes` orchestrator tool.
+ *
+ * Two rules run through it. Presets probe their binary through the toolchain
+ * ladder *before* the pane is split: `openUtilityPane` delivers its command by
+ * sending `exec <argv>` into the pane's shell, so a binary that is not there
+ * kills the pane the instant it appears, and the operator sees a flicker
+ * instead of an install hint (phase 1 report, open question 3). And every
+ * mutation is scoped to panes Clio created, because the contract's registry
+ * refuses anything else.
+ *
+ * `show` targets running dispatches, not panes: it resolves a fuzzy agent id
+ * or run-id prefix against the live dispatch snapshot and points the shared
+ * watch pane at the match, under the one policy decision in
+ * `pane-policy.ts`. There is no per-run pane inventory to search any more.
+ */
+
+import type { ClioSettings } from "../core/config.js";
+import type { DispatchSnapshot } from "../domains/dispatch/contract.js";
+import {
+	newestRunEventJournalRunId,
+	runEventJournalPath,
+	runEventJournalRoot,
+} from "../domains/dispatch/run-event-journal.js";
+import type { MuxContract, MuxPaneRecord } from "../domains/mux/index.js";
+import {
+	PANES_PRESETS,
+	type PanesCloseResult,
+	type PanesInventoryEntry,
+	type PanesOpenResult,
+	type PanesOperations,
+	type PanesShowResult,
+	type PanesStatus,
+	type PanesWatchController,
+	type PanesYaziController,
+	type PanesYaziStatus,
+} from "../domains/mux/operations.js";
+import { resolveBinary } from "../tools/executables.js";
+import { type PaneWatchSource, paneWatchDecision } from "./pane-policy.js";
+
+export interface PanesRuntimeDeps {
+	mux: MuxContract;
+	getSettings: () => Readonly<ClioSettings>;
+	/** Live dispatch state, used to turn a fuzzy agent id into a run id. */
+	getDispatchSnapshot: () => DispatchSnapshot;
+	getCwd: () => string;
+	/** Injection seam for tests; production uses the toolchain ladder. */
+	resolveBinaryPath?: (name: string) => string | null;
+	/** Journal root override for tests. */
+	journalRoot?: () => string;
+	/** Newest run whose journal exists, for the `logs` preset. */
+	newestJournalRunId?: () => string | null;
+}
+
+const UNAVAILABLE = "the pane layer is not available in this session";
+
+function inventory(records: ReadonlyArray<MuxPaneRecord>): ReadonlyArray<PanesInventoryEntry> {
+	return records.map((record) => ({
+		paneId: record.ref.paneId,
+		tabId: record.ref.tabId,
+		purpose: record.purpose,
+		label: record.label,
+		adopted: record.adopted === true,
+	}));
+}
+
+export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
+	const probe = deps.resolveBinaryPath ?? resolveBinary;
+	const journalRoot = deps.journalRoot ?? runEventJournalRoot;
+	let yaziController: PanesYaziController | null = null;
+	let watchController: PanesWatchController | null = null;
+	let nextPendingOpen = 0;
+	const pendingOpens = new Map<string, PanesInventoryEntry>();
+	const beginPendingOpen = (label: string): string => {
+		nextPendingOpen += 1;
+		const id = `pending:${nextPendingOpen}`;
+		pendingOpens.set(id, {
+			paneId: id,
+			tabId: "pending",
+			purpose: "utility",
+			label,
+			adopted: false,
+			pending: true,
+		});
+		return id;
+	};
+	const closedYaziStatus = (): PanesYaziStatus => ({
+		mode: "closed",
+		paneId: null,
+		paneCwd: null,
+		lastLineAt: null,
+		droppedLines: 0,
+	});
+
+	/**
+	 * Resolve one operator- or model-supplied target to a live dispatched run.
+	 *
+	 * Fuzzy agent id first, then runId prefix, most recent run winning: "the
+	 * tester" is what an operator types; a run id is what a tool call carries.
+	 * Retrying runs count as live; the watch pane shows them coming back.
+	 */
+	const matchRun = (target: string): { runId: string; agentId: string; status: string } | null => {
+		const needle = target.trim().toLowerCase();
+		if (needle.length === 0) return null;
+		const snapshot = deps.getDispatchSnapshot();
+		const live = [
+			...snapshot.running.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "running" })),
+			...snapshot.retrying.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "retrying" })),
+		];
+		// Newest first, so "the tester" means the tester the operator just started.
+		const newestFirst = [...live].reverse();
+		const byAgent = newestFirst.find((run) => run.agentId.toLowerCase().includes(needle));
+		if (byAgent) return byAgent;
+		return newestFirst.find((run) => run.runId.toLowerCase().startsWith(needle)) ?? null;
+	};
+
+	/** argv for one preset, once its binary has been found. */
+	const presetArgv = (presetId: string, binaryPath: string): ReadonlyArray<string> | null => {
+		if (presetId === "shell") return [binaryPath, "-l"];
+		if (presetId === "logs") {
+			const runId = (deps.newestJournalRunId ?? (() => newestRunEventJournalRunId(journalRoot())))();
+			if (runId === null) return null;
+			// `-F` rather than `-f`: the journal is recreated when its run's
+			// directory is pruned, and a viewer following an inode would silently
+			// stop at that point.
+			return [binaryPath, "-n", "200", "-F", runEventJournalPath(runId, journalRoot())];
+		}
+		return null;
+	};
+
+	const show = async (target: string, source: PaneWatchSource): Promise<PanesShowResult> => {
+		if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+		const match = matchRun(target);
+		if (match === null) {
+			// The candidate list is what turns a miss into a next step: it names
+			// the runs that are actually live right now.
+			const snapshot = deps.getDispatchSnapshot();
+			const candidates = [
+				...new Set([...snapshot.running.map((run) => run.agentId), ...snapshot.retrying.map((run) => run.agentId)]),
+			];
+			return { status: "not-found", target, candidates };
+		}
+		const decision = paneWatchDecision({ source, runStatus: match.status });
+		if (!decision.open) return { status: "refused", reason: decision.reason };
+		if (watchController === null) {
+			return { status: "unavailable", reason: "the watch pane is not wired in this session" };
+		}
+		const watched = await watchController.watch(match.runId);
+		if (watched.status !== "watching") return { status: "unavailable", reason: watched.reason };
+		return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
+	};
+
+	return {
+		status(): PanesStatus {
+			const detection = deps.mux.detection();
+			const panes = deps.getSettings().panes;
+			return {
+				mode: deps.mux.mode,
+				available: deps.mux.available(),
+				reason: detection.reason,
+				socketPath: detection.socketPath,
+				server: detection.server,
+				settings: {
+					enabled: panes.enabled,
+					notifications: panes.notifications,
+					journal: panes.journal,
+					yazi: { ...panes.yazi },
+				},
+				yazi: yaziController?.status() ?? closedYaziStatus(),
+				panes: [...inventory(deps.mux.list()), ...pendingOpens.values()],
+			};
+		},
+
+		show(target: string): Promise<PanesShowResult> {
+			// The slash command and the tool share this implementation; the policy
+			// treats both as operator pull, so the source only matters for logs.
+			return show(target, "slash");
+		},
+
+		async open(request: { preset?: string; argv?: ReadonlyArray<string>; once?: boolean }): Promise<PanesOpenResult> {
+			const cwd = deps.getCwd();
+			if (request.preset !== undefined) {
+				const preset = PANES_PRESETS.find((entry) => entry.id === request.preset);
+				if (!preset) {
+					return { status: "refused", reason: `unknown preset: ${request.preset}` };
+				}
+				if (preset.id === "yazi") {
+					if (!deps.getSettings().panes.yazi.enabled) {
+						return { status: "refused", reason: "the files pane is disabled by panes.yazi.enabled" };
+					}
+					if (!yaziController) {
+						return { status: "unavailable", reason: "the files-pane return path is not ready" };
+					}
+					const pendingId = beginPendingOpen(preset.id);
+					try {
+						const result = await yaziController.open(request.once ? { once: true } : undefined);
+						if (result.status === "opened") {
+							return { status: "opened", label: preset.id, paneId: result.paneId };
+						}
+						if (result.status === "missing-binary") {
+							return {
+								status: "missing-binary",
+								preset: preset.id,
+								binary: result.binary,
+								installHint: preset.installHint,
+								detail: result.detail,
+							};
+						}
+						return {
+							status: result.status === "profile-error" ? "refused" : "unavailable",
+							reason: result.reason,
+						};
+					} finally {
+						pendingOpens.delete(pendingId);
+					}
+				}
+				if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+				const binaryPath = probe(preset.binary);
+				if (binaryPath === null) {
+					return {
+						status: "missing-binary",
+						preset: preset.id,
+						binary: preset.binary,
+						installHint: preset.installHint,
+						detail: `${preset.binary} was not found (install with \`${preset.installHint}\`)`,
+					};
+				}
+				const argv = presetArgv(preset.id, binaryPath);
+				if (argv === null) {
+					return { status: "refused", reason: `preset ${preset.id} has nothing to show yet` };
+				}
+				const pendingId = beginPendingOpen(preset.id);
+				try {
+					const ref = await deps.mux.openUtilityPane({ argv, cwd, label: preset.id });
+					if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${preset.id}` };
+					return { status: "opened", label: preset.id, paneId: ref.paneId };
+				} finally {
+					pendingOpens.delete(pendingId);
+				}
+			}
+			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			const argv = request.argv ?? [];
+			if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
+			const label = argv[0] ?? "pane";
+			const pendingId = beginPendingOpen(label);
+			try {
+				const ref = await deps.mux.openUtilityPane({ argv, cwd, label });
+				if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${label}` };
+				return { status: "opened", label, paneId: ref.paneId };
+			} finally {
+				pendingOpens.delete(pendingId);
+			}
+		},
+
+		async close(target: string): Promise<PanesCloseResult> {
+			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			const owned = deps.mux.list();
+			if (target === "all") {
+				const labels: string[] = [];
+				// Snapshot first: closing mutates the registry the list came from.
+				for (const record of [...owned]) {
+					if (await deps.mux.closePane(record.ref.paneId)) labels.push(record.label);
+				}
+				return { status: "closed", closed: labels.length, labels };
+			}
+			const needle = target.trim().toLowerCase();
+			const newestFirst = [...owned].reverse();
+			const match =
+				newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ??
+				newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ??
+				newestFirst.find((record) => record.purpose === needle);
+			if (!match) return { status: "not-found", target };
+			const closed = await deps.mux.closePane(match.ref.paneId);
+			return closed ? { status: "closed", closed: 1, labels: [match.label] } : { status: "not-found", target };
+		},
+
+		attachYazi(controller: PanesYaziController): () => void {
+			yaziController = controller;
+			return () => {
+				if (yaziController === controller) yaziController = null;
+			};
+		},
+
+		attachWatch(controller: PanesWatchController): () => void {
+			watchController = controller;
+			return () => {
+				if (watchController === controller) watchController = null;
+			};
+		},
+	};
+}

package/src/interactive/renderers/compaction-summary.ts

@@ -49,6 +49,35 @@ export function renderCompactionSummaryLine(input: CompactionSummaryLineInput):
 	return `[context engine] llm_summary: ${input.messagesSummarized} messages summarized to ${input.summaryChars} chars; ~${input.tokensBefore} tokens before${tail}`;
 }
 
+/** Why the non-destructive stage had nothing to do before a summary ran. */
+export type EvictionSkipReason = "all-protected" | "nothing-evictable" | "disabled";
+
+export interface EvictionSkipLineInput {
+	reason: EvictionSkipReason;
+	/** Turn starts in the visible slice the policy was offered. */
+	turns: number;
+	protectLastTurns: number;
+	policyId: string;
+}
+
+/**
+ * One line saying the working-set stage was considered and declined, in the
+ * same `[context engine] working set:` voice its eviction notice uses. Without
+ * it a short session falls from the pressure threshold straight into the
+ * destructive summary with nothing in the transcript explaining why the cheap
+ * stage did not run (smoke pass 2, G1).
+ */
+export function renderEvictionSkipLine(input: EvictionSkipLineInput): string {
+	const turnWord = input.turns === 1 ? "turn" : "turns";
+	const cause =
+		input.reason === "disabled"
+			? "eviction is off (context.workingSet.enabled false)"
+			: input.reason === "all-protected"
+				? `nothing evictable, all ${input.turns} ${turnWord} are inside the protected window (protectLastTurns ${input.protectLastTurns})`
+				: `nothing evictable by ${input.policyId} above the protected window (protectLastTurns ${input.protectLastTurns})`;
+	return `[context engine] working set: ${cause}; llm_summary runs instead`;
+}
+
 export interface RenderCompactionSummaryOptions {
 	/** Override the default markdown theme. Defaults to the local theme above. */
 	theme?: MarkdownTheme;

package/src/interactive/renderers/worker-entry.ts

@@ -21,10 +21,16 @@
  * Pure: no I/O, no module-level mutable state beyond the shared theme handle.
  */
 
+import { parseJsonObjectPayload } from "../../core/json-payload.js";
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
 import { formatFooterTokens } from "../footer-panel.js";
 import { type ClioToken, clioTheme, fitUnits, formatCompactMs, GLYPH } from "../theme/index.js";
-import { type WorkerEntryState, type WorkerReceiptSummary, workerAskedByModel } from "../worker-stream.js";
+import {
+	type WorkerEntryState,
+	type WorkerPresentedResultContract,
+	type WorkerReceiptSummary,
+	workerAskedByModel,
+} from "../worker-stream.js";
 
 const theme = clioTheme();
 const dim = (text: string): string => theme.fg("dim", text);
@@ -110,7 +116,7 @@ function isPending(entry: WorkerEntryState): boolean {
  * rendered as zero: an ACP peer reports no tokens at all, so its footer names
  * the tool calls it mediated instead of claiming it spent nothing.
  */
-function footerUnits(receipt: WorkerReceiptSummary): string[] {
+function footerUnits(entry: WorkerEntryState, receipt: WorkerReceiptSummary): string[] {
 	const units = [outcomeUnit(receipt, true)];
 	if (receipt.exitCode !== undefined && receipt.exitCode !== 0) {
 		units.push(theme.fg("error", `exit=${receipt.exitCode}`));
@@ -122,6 +128,8 @@ function footerUnits(receipt: WorkerReceiptSummary): string[] {
 	}
 	if (receipt.durationMs !== undefined) units.push(dim(formatCompactMs(receipt.durationMs)));
 	if (receipt.contract !== undefined) units.push(dim(`contract ${receipt.contract}`));
+	const presentation = presentedContractAnswer(entry);
+	if (presentation?.footer !== undefined) units.push(dim(presentation.footer));
 	if (receipt.abandonedDetail !== undefined) units.push(theme.fg("warning", receipt.abandonedDetail));
 	else if (receipt.receiptUnavailable === true) units.push(theme.fg("warning", "receipt unavailable"));
 	return units;
@@ -133,23 +141,120 @@ function railLines(text: string, token: ClioToken, width: number): string[] {
 	return wrapTextWithAnsi(text, contentWidth).map((row) => `${dim(RAIL)}${theme.fg(token, row)}`);
 }
 
-/** A worker's terminal answer when it is one JSON object, as a structured result contract asks for. */
+/** A worker's terminal JSON payload, using the same tolerant reader as its result contract. */
 function structuredAnswer(text: string): Record<string, unknown> | null {
-	const trimmed = text.trim();
-	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
-	try {
-		const parsed: unknown = JSON.parse(trimmed);
-		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-			? (parsed as Record<string, unknown>)
-			: null;
-	} catch {
-		return null;
-	}
+	const parsed = parseJsonObjectPayload(text);
+	return parsed.ok ? parsed.value : null;
 }
 
 const isStringArray = (value: unknown): value is string[] =>
 	Array.isArray(value) && value.every((entry) => typeof entry === "string");
 
+function reportString(value: unknown): string | null {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+interface PresentedContractAnswer {
+	lines: string[];
+	footer?: string;
+}
+
+function debuggerReport(value: Record<string, unknown>): PresentedContractAnswer | null {
+	const diagnosis = reportString(value.diagnosis);
+	const reproduction = value.reproduction;
+	if (
+		diagnosis === null ||
+		(reproduction !== "reproduced" && reproduction !== "not-reproduced" && reproduction !== "unknown") ||
+		!isStringArray(value.evidence)
+	) {
+		return null;
+	}
+	return {
+		lines: [
+			diagnosis,
+			...(value.evidence.length === 0 ? ["Evidence: none"] : ["Evidence:", ...value.evidence.map((item) => `- ${item}`)]),
+		],
+		footer: `reproduction ${reproduction}`,
+	};
+}
+
+function verifierReport(value: Record<string, unknown>): PresentedContractAnswer | null {
+	if ((value.verdict !== "pass" && value.verdict !== "fail") || !Array.isArray(value.checks)) return null;
+	const lines: string[] = [];
+	for (const raw of value.checks) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+		const check = raw as Record<string, unknown>;
+		const name = reportString(check.name);
+		const evidence = reportString(check.evidence);
+		if (name === null || evidence === null || typeof check.passed !== "boolean") return null;
+		lines.push(`${check.passed ? GLYPH.ok : GLYPH.error} ${name}: ${evidence}`);
+	}
+	return { lines: lines.length === 0 ? ["No checks reported."] : lines, footer: `verdict ${value.verdict}` };
+}
+
+function researchReport(value: Record<string, unknown>): PresentedContractAnswer | null {
+	if ((value.source !== "local" && value.source !== "external") || !Array.isArray(value.findings)) return null;
+	const lines: string[] = [];
+	for (const raw of value.findings) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+		const finding = raw as Record<string, unknown>;
+		const claim = reportString(finding.claim);
+		const evidence = reportString(finding.evidence);
+		if (claim === null || evidence === null) return null;
+		lines.push(`- ${claim}`, `  citation: ${evidence}`);
+	}
+	return { lines: lines.length === 0 ? ["No findings reported."] : lines, footer: `source ${value.source}` };
+}
+
+function scoutReport(value: Record<string, unknown>): PresentedContractAnswer | null {
+	if (!Array.isArray(value.findings) || typeof value.needsSplit !== "boolean") return null;
+	const lines: string[] = [];
+	for (const raw of value.findings) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+		const finding = raw as Record<string, unknown>;
+		const claim = reportString(finding.claim);
+		if (claim === null) return null;
+		const path = reportString(finding.path);
+		const line = typeof finding.line === "number" && Number.isSafeInteger(finding.line) ? finding.line : null;
+		lines.push(path !== null && line !== null ? `- ${claim} — ${path}:${line}` : `- ${claim} (ungrounded lead)`);
+	}
+	if (value.needsSplit) {
+		if (!Array.isArray(value.proposedSubtasks)) return null;
+		lines.push("Split recommended:");
+		for (const raw of value.proposedSubtasks) {
+			if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+			const subtask = raw as Record<string, unknown>;
+			const task = reportString(subtask.task);
+			const id = reportString(subtask.id);
+			if (task === null || id === null) return null;
+			lines.push(`- ${id}: ${task}`);
+		}
+	}
+	return {
+		lines: lines.length === 0 ? ["No findings reported."] : lines,
+		footer: value.needsSplit ? "split needed" : "no split needed",
+	};
+}
+
+function presentedContractAnswer(entry: WorkerEntryState): PresentedContractAnswer | null {
+	if (entry.receipt?.contract !== "pass" || entry.receipt.contractKind === undefined || entry.droppedLines !== 0) {
+		return null;
+	}
+	const value = structuredAnswer(entry.text);
+	if (value === null) return null;
+	const kind: WorkerPresentedResultContract = entry.receipt.contractKind;
+	switch (kind) {
+		case "debugger-report":
+			return debuggerReport(value);
+		case "verifier-report":
+			return verifierReport(value);
+		case "research-report":
+			return researchReport(value);
+		case "scout-report":
+			return scoutReport(value);
+	}
+}
+
 /**
  * A mutation report as prose: the paths it changed, each validation with its
  * verdict and evidence, then the summary and commit line. Null when the object
@@ -184,6 +289,8 @@ function mutationReportLines(value: Record<string, unknown>): string[] | null {
 function bodySourceLines(entry: WorkerEntryState): string[] {
 	const structured = entry.droppedLines === 0 ? structuredAnswer(entry.text) : null;
 	if (structured === null) return entry.text.split("\n");
+	const presented = presentedContractAnswer(entry);
+	if (presented !== null) return presented.lines;
 	return mutationReportLines(structured) ?? JSON.stringify(structured, null, 2).split("\n");
 }
 
@@ -236,7 +343,8 @@ function failureLines(entry: WorkerEntryState, width: number): string[] {
 
 /** The receipt line, whole units only; a unit that would not fit is dropped behind a dim ellipsis. */
 function footerLine(entry: WorkerEntryState, width: number): string {
-	const units = isPending(entry) || entry.receipt === undefined ? [pendingUnit(entry)] : footerUnits(entry.receipt);
+	const units =
+		isPending(entry) || entry.receipt === undefined ? [pendingUnit(entry)] : footerUnits(entry, entry.receipt);
 	return fitUnits(theme, dim(FOOTER), units, width);
 }