@iowarp/clio-coder 0.4.4 → 0.4.6

package/src/interactive/renderers/tool-execution.ts

@@ -1,3 +1,6 @@
+import type { TranscriptDetailPolicy } from "../transcript-detail.js";
+import { transcriptDetail } from "../transcript-detail.js";
+import { previewBudget, previewRows } from "./preview.js";
 /**
  * Structured renderer for tool-execution chat segments (Slice A of the
  * pi-coding-agent parity work). pi-coding-agent renders every tool call as
@@ -12,6 +15,7 @@
  * two surfaces stay byte-identical.
  */
 
+import { trustStateWord } from "../../domains/evidence/trust-projection.js";
 import { sanitizeCallTargetText } from "../../domains/safety/call-target.js";
 import { redactSecretString, redactToolArgs } from "../../domains/safety/redaction.js";
 import { formatSize } from "../../engine/truncate.js";
@@ -47,10 +51,7 @@ const ARG_PREVIEW_LIMIT = 60;
 const WEB_FETCH_ARG_PREVIEW_LIMIT = 140;
 const FULL_RESULT_PREVIEW_LIMIT = 60_000;
 const FULL_RESULT_ROW_LIMIT = 120;
-const STREAMING_RESULT_ROW_LIMIT = 20;
 const ARGS_BODY_LINE_LIMIT = 24;
-/** Rows of mutation diff a folded edit/write row keeps visible before it defers to the body. */
-const FOLDED_DIFF_ROW_LIMIT = 24;
 const STATUS_OK_GLYPH = GLYPH.ok;
 const STATUS_ERROR_GLYPH = GLYPH.error;
 
@@ -110,6 +111,8 @@ export interface ToolBodyRenderOptions {
 	unbounded?: boolean;
 	/** Live rows color mutation diffs; replay and export deliberately use plain text. */
 	diffStyle?: "color" | "plain";
+	detail?: TranscriptDetailPolicy;
+	terminalRows?: number;
 }
 
 /** Row cap for a tool body: unbounded lifts both the row and char limits. */
@@ -320,7 +323,22 @@ function outcomeSummary(finished: ToolExecutionFinished): string | null {
 	if (finished.toolName === "dispatch") {
 		const receipts = numberField(details, "receiptCount");
 		const failed = numberField(details, "failedCount") ?? 0;
-		if (receipts !== null) return `${receipts} task${receipts === 1 ? "" : "s"} -> ${receipts - failed} ok`;
+		if (receipts !== null) {
+			const runs = Array.isArray(details?.runs) ? details.runs.slice(0, receipts) : [];
+			const qualityCounts = new Map<string, number>();
+			for (const run of runs) {
+				const trust = isPlainObject(run) && isPlainObject(run.trust) ? run.trust : null;
+				const axes = isPlainObject(trust?.axes) ? trust.axes : null;
+				const word = trustStateWord("validationGrounding", stringField(axes, "validationGrounding") ?? "unknown");
+				qualityCounts.set(word, (qualityCounts.get(word) ?? 0) + 1);
+			}
+			if (runs.length < receipts) {
+				const unknown = trustStateWord("validationGrounding", "unknown");
+				qualityCounts.set(unknown, (qualityCounts.get(unknown) ?? 0) + receipts - runs.length);
+			}
+			const quality = [...qualityCounts].map(([word, count]) => `${count} ${word}`).join(", ");
+			return `${receipts} task${receipts === 1 ? "" : "s"} -> ${receipts - failed} execution ok${failed > 0 ? `, ${failed} execution failed` : ""}${quality ? `; quality: ${quality}` : ""}`;
+		}
 		return null;
 	}
 	if (finished.toolName === "tasks") {
@@ -1094,30 +1112,6 @@ function renderResultBlock(
 	return renderOutputRows(resultText(unwrapped, resultCharLimit(opts)), width, isError, resultRowLimit(opts));
 }
 
-/**
- * Header-only render for a tool call that has not yet finished. Used by the
- * live chat panel from streamed argument formation through execution. The
- * lifecycle tail distinguishes a forming call, a ready call, and a running
- * call without inventing execution time before Pi starts the tool.
- */
-export function renderToolCallHeader(call: ToolExecutionStart, width: number): string[] {
-	return wrap(
-		headerLine(call.toolName, call.args, call.phase ?? "running", {
-			elapsedMs: call.elapsedMs,
-		}),
-		width,
-	);
-}
-
-/** Running-only footer used when an operator pauses live output; execution continues. */
-export function renderToolRunningStatus(call: ToolExecutionStart, width: number): string[] {
-	const elapsed = optionalCompactMs(call.elapsedMs);
-	return [
-		...renderToolCallHeader(call, width),
-		...indentAndWrap(dim(elapsed ? `live output paused · ${elapsed}` : "live output paused"), width, false),
-	];
-}
-
 function sublineStatus(call: ToolExecutionStart | ToolExecutionFinished): HeaderStatus {
 	// Discriminate on `result` rather than `isError`: only `ToolExecutionFinished`
 	// carries a `result` field, so a `ToolExecutionStart` with a stray
@@ -1127,59 +1121,8 @@ function sublineStatus(call: ToolExecutionStart | ToolExecutionFinished): Header
 	return call.isError ? "error" : "ok";
 }
 
-/**
- * One-line subline form of a tool call. Format:
- *   ▸ <body><status>
- * `status` is "" for in-flight, " ✓" green for success, " ✗" red for error.
- * Output is width-wrapped via wrapTextWithAnsi.
- *
- * When `expandKey` is supplied AND the call has finished, a dim ` (<key>)`
- * discoverability hint rides at the very end of the atomic status tail so users
- * see how to expand the collapsed block. Composing the full line (facts, status
- * glyph, duration, offload, and hint) before wrapping keeps the status glyph
- * and duration together on one row. The hint is suppressed for in-flight calls
- * (still running, no useful body to expand yet) and when `expandKey` is
- * empty/undefined (no key bound, hint would be misleading). The renderer never
- * imports the keybindings manager directly; the caller resolves the key string
- * and passes it in to keep this module pure.
- */
-export interface ToolSublineRenderOptions {
-	/** Live rows color the folded mutation diff; replay and export request plain rows. */
-	diffStyle?: "color" | "plain";
-	/**
-	 * Whether the folded row carries the extras its tool's presentation asks
-	 * for (today the bounded mutation diff). The bare subline level drops them;
-	 * the failure excerpt is not one of them and always rides the row.
-	 */
-	foldedExtras?: "per-tool" | "none";
-}
-
-/**
- * The bounded diff a folded mutation row keeps under itself, when the tool's
- * presentation asks for one and the result carries one. A folded `edit` that
- * hid its change told the operator nothing they could act on.
- */
-function foldedDiffRows(finished: ToolExecutionFinished, width: number, opts: ToolSublineRenderOptions): string[] {
-	if (opts.foldedExtras === "none") return [];
-	if (finished.isError || isNonExecutedOutcome(finished.outcome)) return [];
-	const presentation =
-		toolResultPresentationPolicy(finished.result) ?? toolPresentationPolicy(finished.toolName, finished.args);
-	if (!presentation.showDiffWhenFolded) return [];
-	const diff = resultDiff(finished.result);
-	if (diff === null) return [];
-	return truncateRowsMiddle(
-		renderMutationDiffBlock(diff, width, opts.diffStyle !== "plain"),
-		FOLDED_DIFF_ROW_LIMIT,
-		false,
-	);
-}
-
-export function renderToolSubline(
-	call: ToolExecutionStart | ToolExecutionFinished,
-	width: number,
-	expandKey?: string,
-	opts: ToolSublineRenderOptions = {},
-): string[] {
+/** Stable action identity, outcome, and captured-result metadata. */
+export function renderToolSubline(call: ToolExecutionStart | ToolExecutionFinished, width: number): string[] {
 	const status = sublineStatus(call);
 	const meta: StatusMeta =
 		"result" in call
@@ -1192,11 +1135,7 @@ export function renderToolSubline(
 			: { elapsedMs: call.elapsedMs };
 	const parts = sublineParts(call, status, meta);
 	const excerpt = "result" in call ? failureExcerpt(call, width) : "";
-	const showHint = "result" in call && expandKey !== undefined && expandKey.length > 0;
-	const tail = showHint ? `${parts.tail}${dim(` (${expandKey})`)}` : parts.tail;
-	const lines = wrapSublineWithTail(`${parts.lead}${excerpt}`, tail, width);
-	if ("result" in call) lines.push(...foldedDiffRows(call, width, opts));
-	return lines;
+	return wrapSublineWithTail(`${parts.lead}${excerpt}`, parts.tail, width);
 }
 
 /**
@@ -1284,6 +1223,7 @@ export function renderToolResultOnly(
 	width: number,
 	opts: ToolBodyRenderOptions = {},
 ): string[] {
+	if (!opts.unbounded && opts.detail) return renderToolPreview(finished, width, opts.detail, opts);
 	const status: HeaderStatus = finished.isError ? "error" : "ok";
 	const statusMeta: StatusMeta = {
 		durationMs: finished.durationMs,
@@ -1299,50 +1239,6 @@ export function renderToolResultOnly(
 	return out;
 }
 
-/**
- * Streaming render for an in-flight tool call whose expanded block should
- * surface the latest partial output. Used by the chat panel between
- * `tool_execution_start` and `tool_execution_end` when the user has expanded
- * the tool segment. The header carries the running lifecycle tail, secondary
- * arguments remain visible, and the latest cumulative Pi result renders under
- * a labeled live-output rail capped at the streaming row limit. An empty result renders
- * `(no output yet)` so the user can distinguish a slow start from a stalled
- * call.
- */
-export function renderToolStreamingExecution(
-	call: ToolExecutionStart,
-	width: number,
-	partialResult: unknown,
-): string[] {
-	const out: string[] = [];
-	out.push(...renderToolCallHeader({ ...call, phase: "running" }, width));
-	out.push(...renderArgsBody(call.toolName, call.args, width, false));
-	const partial: ToolExecutionFinished = {
-		toolCallId: call.toolCallId,
-		toolName: call.toolName,
-		args: call.args,
-		result: partialResult,
-		isError: false,
-	};
-	out.push(...renderOutputMeta(partial, width, false, "live output"));
-	const partialOutput = unwrapResultEnvelope(partialResult);
-	if (isEmptyResult(partialOutput)) {
-		out.push(...indentAndWrap(dim("(no output yet)"), width, false));
-	} else {
-		if (call.toolName === "bash") {
-			const bashArgs = asBashArgs(redactToolArgs(call.args));
-			if (bashArgs !== null) {
-				const commandLine = `${cyanBold("$")} ${highlightBashCommand(stripShellWrapperForDisplay(bashArgs.command))}`;
-				out.push(...indentAndWrap(commandLine, width, false));
-			}
-		}
-		out.push(
-			...renderOutputRows(resultText(partialOutput, FULL_RESULT_PREVIEW_LIMIT), width, false, STREAMING_RESULT_ROW_LIMIT),
-		);
-	}
-	return out;
-}
-
 /** Display-only lifecycle for operator-issued `!` and `!!` bash commands. */
 export interface BashTranscriptExecution {
 	command: string;
@@ -1356,13 +1252,6 @@ export interface BashTranscriptExecution {
 	fullOutputPath?: string | undefined;
 	excludeFromContext?: boolean | undefined;
 	error?: string | undefined;
-	/**
-	 * Whether the block draws its one-line row instead of the full body. The
-	 * caller resolves this from the transcript detail policy and the operator's
-	 * override, the same way the panel resolves a model bash call. Omitted means
-	 * folded.
-	 */
-	folded?: boolean | undefined;
 }
 
 /**
@@ -1373,7 +1262,7 @@ export interface BashTranscriptExecution {
 export function renderBashTranscriptExecution(
 	execution: BashTranscriptExecution,
 	width: number,
-	expandKey?: string,
+	_expandKey?: string,
 	bodyOptions: ToolBodyRenderOptions = {},
 ): string[] {
 	const shownBytes = Buffer.byteLength(execution.output, "utf8");
@@ -1393,30 +1282,12 @@ export function renderBashTranscriptExecution(
 		content: [{ type: "text", text: execution.output }],
 		details,
 	};
-	const folded = execution.folded !== false;
 	if (execution.running) {
-		if (folded) {
-			return renderToolSubline(
-				{
-					toolCallId: "local-bash",
-					toolName: "bash",
-					args,
-					elapsedMs: execution.elapsedMs,
-					phase: "running",
-				},
-				width,
-			);
-		}
-		return renderToolStreamingExecution(
-			{
-				toolCallId: "local-bash",
-				toolName: "bash",
-				args,
-				elapsedMs: execution.elapsedMs,
-				phase: "running",
-			},
+		return renderToolPreview(
+			{ toolCallId: "local-bash", toolName: "bash", args, phase: "running", elapsedMs: execution.elapsedMs },
 			width,
-			result,
+			bodyOptions.detail ?? transcriptDetail(),
+			{ ...bodyOptions, operator: true, partialResult: result },
 		);
 	}
 	const message = execution.error?.trim();
@@ -1438,5 +1309,57 @@ export function renderBashTranscriptExecution(
 			...(execution.fullOutputPath !== undefined ? { offloadPath: execution.fullOutputPath } : {}),
 		},
 	};
-	return folded ? renderToolSubline(finished, width, expandKey) : renderToolExecution(finished, width, bodyOptions);
+	return bodyOptions.unbounded
+		? renderToolExecution(finished, width, bodyOptions)
+		: renderToolPreview(finished, width, bodyOptions.detail ?? transcriptDetail(), { ...bodyOptions, operator: true });
+}
+
+/** One action identity plus a bounded result; arguments and full output belong in /view. */
+export function renderToolPreview(
+	call: ToolExecutionStart | ToolExecutionFinished,
+	width: number,
+	detail: TranscriptDetailPolicy,
+	options: ToolBodyRenderOptions & { terminalRows?: number; partialResult?: unknown; operator?: boolean } = {},
+): string[] {
+	const finished = "result" in call ? call : undefined;
+	const failure = finished?.isError === true || finished?.outcome !== undefined;
+	const limit = previewBudget(
+		failure
+			? detail.errorRows
+			: options.operator
+				? detail.operatorBashRows
+				: call.toolName === "bash"
+					? detail.bashRows
+					: detail.resultRows,
+		options.terminalRows,
+	);
+	const rows = renderToolSubline(call, width);
+	const result = finished?.result ?? options.partialResult;
+	const diff = finished && !failure ? resultDiff(result) : null;
+	if (diff !== null && detail.diffRows > 0) {
+		rows.push(
+			...previewRows(
+				renderMutationDiffBlock(redactSecretString(diff), width, options.diffStyle !== "plain"),
+				previewBudget(detail.diffRows, options.terminalRows),
+				width,
+			),
+		);
+	} else if (limit > 0 && result !== undefined) {
+		const text = resultText(unwrapResultEnvelope(result), Number.POSITIVE_INFINITY);
+		const body = indentAndWrap(redactSecretString(text), width, failure);
+		rows.push(...previewRows(body, limit, width, call.toolName === "bash" || !finished));
+	}
+	return rows;
+}
+
+/** Only ordinary successful observations can lose their individual metadata rows. */
+export function canGroupObservation(call: ToolExecutionFinished): boolean {
+	return (
+		["read", "grep", "find", "ls"].includes(call.toolName) &&
+		!call.isError &&
+		!call.outcome &&
+		!call.evictedReason &&
+		!isTruncatedResult(call) &&
+		offloadPathOf(call) === null
+	);
 }

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

@@ -1,27 +1,11 @@
-/**
- * Renderer for a worker's transcript block: the attributed stream a `/run`,
- * `/delegate`, or model-driven dispatch produces.
- *
- * One shape serves every runtime. A local Clio worker, a Claude subprocess, and
- * a delegated ACP peer differ only in what the header can name about their
- * route, so the body, the tool line, and the receipt footer are identical and
- * an operator learns one grammar. The origin glyph is the only thing that says
- * who asked, which is the same rule the board and the footer chip follow.
- *
- *   ◇ coder · node-a/example-coder-model · run 2mkas6s
- *   │ Hello! I'm the coder worker.
- *   │ ⚙ read · artifact
- *   └ ✓ ok · 4.8k tok · 9.6s · contract pass
- *
- * Folded (the default for a run the model asked for) is one row shaped like a tool subline,
- * so a fan-out of five scouts costs five rows until the operator opens one:
- *
- *   ◆ scout · node-b/example-scout-model · run 3nc18jo ✓ · 41s (Ctrl+O)
- *
- * Pure: no I/O, no module-level mutable state beyond the shared theme handle.
- */
+import { redactSecretString } from "../../domains/safety/redaction.js";
+import type { TranscriptDetailPolicy } from "../transcript-detail.js";
+import { transcriptDetail } from "../transcript-detail.js";
+import { previewBudget, previewRows } from "./preview.js";
+/** Bounded worker summaries share the main transcript's output style. */
 
 import { parseJsonObjectPayload } from "../../core/json-payload.js";
+import { trustStateWord } from "../../domains/evidence/trust-projection.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";
@@ -45,10 +29,8 @@ const SEPARATOR = " · ";
 const BODY_LINE_LIMIT = 80;
 
 export interface WorkerEntryRenderOptions {
-	/** Collapsed to the header line plus outcome. Default for a run the model asked for. */
-	folded: boolean;
-	/** Key hint appended to a folded header, e.g. "Ctrl+O". Omitted when unknown. */
-	expandKey?: string | undefined;
+	detail?: TranscriptDetailPolicy;
+	terminalRows?: number;
 	/** Render the full body without the line cap; `/export` sets this. */
 	unbounded?: boolean;
 }
@@ -80,14 +62,14 @@ function headerLine(entry: WorkerEntryState, width: number): string {
 }
 
 /**
- * Outcome glyph, with the word on the footer. The folded row uses the glyph
- * alone, as a tool subline does, so a list of cards reads like a list of calls.
+ * Execution outcome, explicitly named on successful folded and expanded rows
+ * so the separate quality line cannot be mistaken for process status.
  * Abandoned names itself rather than falling through to its `stalled`
  * outcome code, so it reads as a ledger-side finding instead of the ordinary
  * heartbeat-timeout `stalled` a sealed receipt reports.
  */
 function outcomeUnit(receipt: WorkerReceiptSummary, word: boolean): string {
-	if (receipt.outcome === "succeeded") return theme.fg("success", word ? `${GLYPH.ok} ok` : GLYPH.ok);
+	if (receipt.outcome === "succeeded") return theme.fg("success", `${GLYPH.ok} execution ok`);
 	if (receipt.outcome === "canceled") return theme.fg("dim", `${GLYPH.cancelled} canceled`);
 	if (receipt.abandonedDetail !== undefined) return theme.fg("error", word ? `${GLYPH.error} abandoned` : GLYPH.error);
 	return theme.fg("error", `${GLYPH.error} ${receipt.outcomeCode ?? receipt.outcome}`);
@@ -389,16 +371,19 @@ function footerLine(entry: WorkerEntryState, width: number): string {
  * renders only when the caller resolved a key binding for it, so a rebound or
  * unbound key never advertises a wrong chord.
  */
-function foldedLine(entry: WorkerEntryState, width: number, expandKey: string | undefined): string {
+function actionLine(entry: WorkerEntryState, width: number): string {
 	const identity = `${originGlyph(entry)} ${identityUnits(entry).join(dim(SEPARATOR))}`;
 	const status =
 		isPending(entry) || entry.receipt === undefined ? pendingUnit(entry) : outcomeUnit(entry.receipt, false);
 	const elapsed =
 		entry.receipt?.durationMs === undefined ? "" : dim(`${SEPARATOR}${formatCompactMs(entry.receipt.durationMs)}`);
-	const hint = expandKey === undefined || expandKey.length === 0 ? "" : dim(` (${expandKey})`);
-	const full = ` ${status}${elapsed}${hint}`;
-	const tail = visibleWidth(identity) + visibleWidth(full) <= width ? full : ` ${status}${hint}`;
-	return `${truncateToWidth(identity, Math.max(1, width - visibleWidth(tail)), GLYPH.ellipsis, false)}${tail}`;
+	const full = ` ${status}${elapsed}`;
+	let tail = visibleWidth(identity) + visibleWidth(full) <= width ? full : ` ${status}`;
+	// Reserve one identity cell. The optional hint yields before execution
+	// status when the suffix alone would exhaust the header's width.
+	if (visibleWidth(tail) >= width) tail = ` ${status}`;
+	const header = `${truncateToWidth(identity, Math.max(1, width - visibleWidth(tail)), GLYPH.ellipsis, false)}${tail}`;
+	return truncateToWidth(header, width, GLYPH.ellipsis, false);
 }
 
 export function renderWorkerEntryLines(
@@ -407,14 +392,60 @@ export function renderWorkerEntryLines(
 	options: WorkerEntryRenderOptions,
 ): string[] {
 	const safeWidth = Math.max(1, Math.floor(width));
-	if (options.folded) return [foldedLine(entry, safeWidth, options.expandKey)];
-	const tools = toolLine(entry, safeWidth);
+	const quality = isPending(entry)
+		? []
+		: railLines(
+				`quality: ${trustStateWord("validationGrounding", entry.receipt?.trust?.validationGrounding.state ?? "unknown")}`,
+				"muted",
+				safeWidth,
+			);
+	const detail = options.detail ?? transcriptDetail();
+	if (options.unbounded) {
+		const tools = toolLine(entry, safeWidth);
+		return [
+			headerLine(entry, safeWidth),
+			...bodyLines(entry, safeWidth, true),
+			...attemptLines(entry, safeWidth),
+			...(tools ? [tools] : []),
+			...failureLines(entry, safeWidth),
+			footerLine(entry, safeWidth),
+			...quality,
+		].map(redactSecretString);
+	}
+	const budget = (limit: number) => previewBudget(limit, options.terminalRows);
+	const summary = bodySourceLines(entry).flatMap((line) => railLines(redactSecretString(line), "muted", safeWidth));
+	const actions = entry.progress
+		? [...entry.progress.recentActions]
+				.reverse()
+				.concat(entry.progress.currentAction ? [entry.progress.currentAction] : [])
+		: [];
+	const trail = actions.flatMap((action) =>
+		railLines(
+			`${GLYPH.phaseTool} ${action.descriptor ? `${action.descriptor.verb} ${action.descriptor.object}` : action.tool}`,
+			"muted",
+			safeWidth,
+		),
+	);
+	const tools = detail.workerActivity && trail.length === 0 ? toolLine(entry, safeWidth) : null;
+	const failure = previewRows(failureLines(entry, safeWidth), budget(detail.errorRows), safeWidth);
+	const presented = presentedContractAnswer(entry)?.footer;
 	return [
-		headerLine(entry, safeWidth),
-		...bodyLines(entry, safeWidth, options.unbounded === true),
-		...attemptLines(entry, safeWidth),
-		...(tools === null ? [] : [tools]),
-		...failureLines(entry, safeWidth),
-		footerLine(entry, safeWidth),
-	];
+		actionLine(entry, safeWidth),
+		...(detail.workerRows > 0 ? previewRows(summary, budget(detail.workerRows), safeWidth, entry.pending) : []),
+		...previewRows(attemptLines(entry, safeWidth), budget(detail.errorRows), safeWidth, true),
+		...(tools ? [tools] : []),
+		...(detail.workerActivity ? previewRows(trail, budget(4), safeWidth, true) : []),
+		...failure,
+		...(presented ? railLines(presented, "muted", safeWidth) : []),
+		...(entry.receipt?.abandonedDetail ? railLines(entry.receipt.abandonedDetail, "warning", safeWidth) : []),
+		...(entry.receipt?.receiptUnavailable ? railLines("receipt unavailable", "warning", safeWidth) : []),
+		...(entry.droppedLines
+			? railLines(
+					`… ${entry.droppedLines} earlier lines unavailable here · /view dispatch:${entry.runId}`,
+					"muted",
+					safeWidth,
+				)
+			: []),
+		...quality,
+	].map(redactSecretString);
 }

package/src/interactive/slash-autocomplete.ts

@@ -154,12 +154,7 @@ function completionGrammar(command: string, args: CommandArgsSpec): CommandArgsS
 			? {
 					positionals: spec.positionals.map((pos) => {
 						const completionSlot = COMPLETION_SLOT_MANIFEST[`${path}:pos:${pos.name}`];
-						const values =
-							command === "output" && pos.name === "verbosity"
-								? (["minimal", "default", "verbose"] as const)
-								: command === "settings" && pos.name === "area"
-									? SETTINGS_AREA_IDS
-									: undefined;
+						const values = command === "settings" && pos.name === "area" ? SETTINGS_AREA_IDS : undefined;
 						return { ...pos, ...(completionSlot ? { completionSlot } : {}), ...(values ? { values } : {}) };
 					}),
 				}

package/src/interactive/slash-commands.ts

@@ -30,8 +30,11 @@ import type {
 	ResourceList,
 } from "../domains/resources/index.js";
 import { parseSkillCommand, SKILL_SURFACE_CLEAR_ARG } from "../domains/resources/index.js";
+import { activeDecisionRefs } from "../domains/session/decision-board.js";
+import type { DecisionLedgerEntry } from "../domains/session/entries.js";
 import type { ShareImportPlan } from "../domains/share/index.js";
 import type { UserTaskAcceptance } from "../domains/user-tasks/acceptance.js";
+import { formatUserTaskHandoff } from "../domains/user-tasks/handoff.js";
 import type { UserTask } from "../domains/user-tasks/store.js";
 import type { ExtensionReloadOutcome } from "../entry/extension-reload.js";
 import { isToolProfileName, TOOL_PROFILE_NAMES, type ToolProfileName } from "../tools/profiles.js";
@@ -171,8 +174,6 @@ type SlashCommandVariant =
 	| { kind: "files-usage"; reason: string }
 	| { kind: "thinking-set"; level: string }
 	| { kind: "thinking-picker" }
-	| { kind: "output-set"; verbosity: string }
-	| { kind: "output-picker" }
 	| { kind: "model" }
 	| { kind: "model-set"; pattern: string }
 	| { kind: "settings"; area?: SettingsAreaId; group?: string }
@@ -204,11 +205,6 @@ export type SetThinkingLevelResult =
 	| { status: "unsupported"; level: string; supported: ReadonlyArray<string> }
 	| { status: "unavailable" };
 
-export type SetOutputVerbosityResult =
-	| { status: "applied"; verbosity: string }
-	| { status: "unsupported"; verbosity: string; supported: ReadonlyArray<string> }
-	| { status: "unavailable" };
-
 /**
  * What one admitted dispatch-tool call reports back to `/council`. The council
  * itself is watched on the board and in the transcript, so success is silent;
@@ -246,6 +242,8 @@ export interface RunCommandOptions {
 
 export interface HandleRunDeps {
 	dispatch: DispatchContract;
+	/** Live session board, snapshotted before operator run admission. */
+	getDecisionBoard?: () => ReadonlyArray<DecisionLedgerEntry>;
 	/** Strict recipe facts the run's execution role is derived from. */
 	getAgentRoleFacts?: AgentRoleFactsResolver;
 	io: RunIo;
@@ -341,6 +339,7 @@ export async function handleRun(
 	deps: HandleRunDeps,
 	options: RunCommandOptions = {},
 ): Promise<void> {
+	const decisionRefs = activeDecisionRefs(deps.getDecisionBoard?.() ?? []);
 	if (options.target && options.workerProfile) {
 		deps.notice(
 			"warn",
@@ -363,6 +362,7 @@ export async function handleRun(
 				...(deps.getAgentRoleFacts ? { resolveFacts: deps.getAgentRoleFacts } : {}),
 			}),
 			requestOrigin: "user",
+			...(decisionRefs.length > 0 ? { decisionRefs } : {}),
 			...(options.workerProfile ? { workerProfile: options.workerProfile } : {}),
 			...(options.workerRuntime ? { workerRuntime: options.workerRuntime } : {}),
 			...(options.target ? { target: options.target } : {}),
@@ -562,6 +562,7 @@ export interface SlashCommandContext {
 	io: RunIo;
 	notice: (level: NoticeLevel, text: string) => void;
 	dispatch: DispatchContract;
+	getDecisionBoard?: HandleRunDeps["getDecisionBoard"];
 	bus: SafeEventBus;
 	/** Strict recipe facts used to keep interactive /run role-equivalent with the CLI. */
 	getAgentRoleFacts?: AgentRoleFactsResolver;
@@ -720,8 +721,6 @@ export interface SlashCommandContext {
 	thinkingLevelChoices?: () => ReadonlyArray<{ value: string; label: string }>;
 	openThinkingPicker?: () => void;
 	/** Apply a transcript verbosity named on the command line; refused values are reported by the caller. */
-	setOutputVerbosity?: (verbosity: string) => SetOutputVerbosityResult;
-	openOutputPicker?: () => void;
 	openModel: () => void;
 	/** Live providers contract used by `/model <pattern>` to resolve directly. */
 	providers: ProvidersContract;
@@ -791,13 +790,6 @@ function formatReceiptVerificationBlock(runId: string, result: SlashReceiptVerif
 	return lines.join("\n");
 }
 
-/** The one operator-authored turn used by slash and overlay handoff paths. */
-export function formatUserTaskHandoff(task: Pick<UserTask, "id" | "title" | "note" | "acceptance">): string {
-	const note = task.note ? ` ${task.note}.` : "";
-	const acceptance = task.acceptance ? ` Acceptance: ${JSON.stringify(task.acceptance)}.` : "";
-	return `Operator task ${task.id}: ${task.title}.${note}${acceptance} Pick it up with tasks action="pick" id="${task.id}" and work it when appropriate.`;
-}
-
 /** The verb a command performs, in the order /help lists the groups. */
 export const SLASH_COMMAND_GROUPS = ["Work", "Inspect", "Configure", "Session"] as const;
 export type SlashCommandGroup = (typeof SLASH_COMMAND_GROUPS)[number];
@@ -1183,6 +1175,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 					task,
 					{
 						dispatch: ctx.dispatch,
+						...(ctx.getDecisionBoard ? { getDecisionBoard: ctx.getDecisionBoard } : {}),
 						...(ctx.getAgentRoleFacts ? { getAgentRoleFacts: ctx.getAgentRoleFacts } : {}),
 						io: ctx.io,
 						notice: ctx.notice,
@@ -1915,35 +1908,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			ctx.render();
 		},
 	},
-	{
-		name: "output",
-		description: "Set transcript detail to minimal, default, or verbose",
-		group: "Configure",
-		kinds: ["output-set", "output-picker"],
-		args: { positionals: [{ name: "verbosity", required: false }] },
-		fromArgs(parsed) {
-			if (parsed.error) return { kind: "usage-error", command: "output", reason: parsed.error };
-			const verbosity = parsed.positionals[0];
-			return verbosity ? { kind: "output-set", verbosity } : { kind: "output-picker" };
-		},
-		handle(command, ctx) {
-			if (command.kind === "output-picker") {
-				if (ctx.openOutputPicker) ctx.openOutputPicker();
-				else ctx.notice("error", "output picker is not wired in this session");
-				return;
-			}
-			if (command.kind !== "output-set") return;
-			const result = ctx.setOutputVerbosity?.(command.verbosity) ?? { status: "unavailable" as const };
-			if (result.status === "applied") {
-				ctx.notice("success", `output detail: ${result.verbosity}`);
-			} else if (result.status === "unsupported") {
-				ctx.notice("error", `output detail "${result.verbosity}" is not one of ${result.supported.join(", ")}`);
-			} else {
-				ctx.notice("error", "output detail cannot be set right now");
-			}
-			ctx.render();
-		},
-	},
 	{
 		name: "model",
 		description: "Open model selector or set a model",
@@ -2197,6 +2161,13 @@ function reloadExtensionsCommand(ctx: SlashCommandContext): void {
 export function parseSlashCommand(input: string): SlashCommand {
 	const trimmed = input.trim();
 	if (trimmed.length === 0) return { kind: "empty" };
+	if (/^\/output(?:\s|$)/u.test(trimmed)) {
+		return {
+			kind: "usage-error",
+			command: "output",
+			reason: "Use Alt+O to cycle Output style, or /settings interface to save a default. Use /view for full details",
+		};
+	}
 	if (trimmed.startsWith(COMMAND_ESCAPE)) return { kind: "unknown", text: trimmed.slice(1) };
 	for (const entry of BUILTIN_SLASH_COMMANDS) {
 		const match = entry.match ? entry.match(trimmed) : matchFromSpec(entry, trimmed);
@@ -2284,7 +2255,6 @@ const COMMAND_ORDER = [
 	"help",
 	"model",
 	"thinking",
-	"output",
 	"settings",
 	"new",
 	"resume",