@iowarp/clio-coder 0.4.5 → 0.4.6

package/src/interactive/status/types.ts

@@ -19,6 +19,8 @@ export interface RetryOverlay {
 }
 
 export interface ToolOverlay {
+	toolCallId?: string;
+	startedAt?: number;
 	toolName: string;
 	toolPreview: string;
 }
@@ -104,6 +106,7 @@ export interface AgentStatus {
 	 * phase leaves `tool_running`.
 	 */
 	toolStartedAt?: number | undefined;
+	activeTools?: readonly ToolOverlay[];
 	retry?: RetryOverlay | undefined;
 	dispatch?: DispatchOverlay | undefined;
 	/**

package/src/interactive/status/verbs.ts

@@ -44,30 +44,31 @@ function coreVerb(status: AgentStatus): { text: string; toneHint: VerbRender["to
 		case "idle":
 			return null;
 		case "preparing":
-			return { text: tier >= 2 ? "still preparing harness" : "preparing harness", toneHint: "normal" };
+			return { text: "Preparing", toneHint: "normal" };
 		case "waiting_model":
 			return {
-				text: tier >= 2 ? "still waiting on model" : status.localRuntime ? "waiting on local model" : "waiting on model",
+				text: tier >= 2 ? "Waiting for model" : status.localRuntime ? "Waiting for local model" : "Waiting for model",
 				toneHint: "normal",
 			};
 		case "thinking":
-			return { text: tier >= 2 ? "still receiving thinking" : "receiving thinking", toneHint: "normal" };
+			return { text: "Thinking", toneHint: "normal" };
 		case "writing":
-			return { text: "streaming response", toneHint: "normal" };
+			return { text: "Writing", toneHint: "normal" };
 		case "tool_running": {
 			const name = status.tool?.toolName ?? "tool";
-			if (name === ToolNames.AskUser) return { text: "waiting for user input", toneHint: "normal" };
-			return { text: tier >= 2 ? `still running tool: ${name}` : `running tool: ${name}`, toneHint: "normal" };
+			if (name === ToolNames.Dispatch) return { text: "Waiting for worker", toneHint: "normal" };
+			if (name === ToolNames.AskUser) return { text: "Needs input", toneHint: "normal" };
+			return { text: `Running ${name}`, toneHint: "normal" };
 		}
 		case "tool_blocked":
-			return { text: "awaiting confirmation", toneHint: "warn" };
+			return { text: "Needs approval", toneHint: "warn" };
 		case "retrying": {
 			const retry = status.retry;
 			const wait = retry && retry.waitMs > 0 ? ` · ${formatStatusElapsed(retry.waitMs)}` : "";
 			return { text: `retrying ${retry?.attempt ?? 0}/${retry?.maxAttempts ?? 0}${wait}`, toneHint: "warn" };
 		}
 		case "compacting":
-			return { text: "compacting context", toneHint: "normal" };
+			return { text: "Compacting context", toneHint: "normal" };
 		case "dispatching": {
 			const agent = status.dispatch?.agentName;
 			if (tier >= 2)
@@ -75,7 +76,7 @@ function coreVerb(status: AgentStatus): { text: string; toneHint: VerbRender["to
 			return { text: agent ? `dispatching agent: ${agent}` : "dispatching agent", toneHint: "normal" };
 		}
 		case "stuck":
-			return { text: "stuck", toneHint: "error" };
+			return { text: "No output", toneHint: "error" };
 		case "ended": {
 			const stop = status.summary?.stopReason ?? "stop";
 			const elapsed = status.summary ? ` · ${formatStatusElapsed(status.summary.elapsedMs)}` : "";
@@ -97,7 +98,7 @@ export function resolveFooterVerb(status: AgentStatus, now: number, terminalCols
 	if (status.phase === "stuck") {
 		const elapsed = elapsedSince(status, now);
 		return {
-			text: terminalCols < 60 ? "stuck" : `stuck · ${elapsed} · Esc to cancel`,
+			text: terminalCols < 60 ? "No output" : `No output · ${elapsed} · Esc to cancel`,
 			toneHint: "error",
 		};
 	}
@@ -117,12 +118,12 @@ function inlineParts(
 	terminalCols: number,
 ): { text: string; hint: string | null; toneHint: VerbRender["toneHint"] } | null {
 	if (status.phase === "stuck")
-		return { text: `Stuck for ${elapsedSince(status, now)}.`, hint: "Press Esc to cancel.", toneHint: "error" };
+		return { text: `No output for ${noProgressSince(status, now)}.`, hint: "Press Esc to cancel.", toneHint: "error" };
 	const core = coreVerb(status);
 	if (!core) return null;
 	const text = core.text.replace(/^[a-z]/, (c) => c.toUpperCase());
 	if (status.watchdogTier >= 3) {
-		const hint = terminalCols < 50 ? null : `(no progress for ${noProgressSince(status, now)}; press Esc to cancel)`;
+		const hint = terminalCols < 50 ? null : `(no output for ${noProgressSince(status, now)}; press Esc to cancel)`;
 		return { text, hint, toneHint: core.toneHint };
 	}
 	if (terminalCols < 50 || status.phase === "tool_blocked") return { text, hint: null, toneHint: core.toneHint };

package/src/interactive/transcript-detail.ts

@@ -1,120 +1,58 @@
-/**
- * Transcript detail policy: the one place `/output minimal|default|verbose`
- * becomes a decision about how much of each foldable transcript block is open
- * before the operator touches it.
- *
- * The chat panel used to consult the verbosity string in four places, each
- * spelling the rule a little differently, and nothing else (running rows, live
- * tool output, worker cards in replay) consulted it at all. The panel now reads
- * this policy once per frame and threads it down; the verbosity string never
- * reaches a renderer.
- *
- * Operator toggles (`Alt+O`, `Alt+R`, expand-all, collapse-all) are overrides
- * layered on top of this policy, not fights with it: the effective state of a
- * block is `override ?? policy`, and `resolveFold` is that one rule.
- *
- * Pure module: no I/O, no UI imports.
- */
-
-import type { OutputVerbosity } from "../core/defaults.js";
-import type { ToolFoldDefault, ToolPresentationPolicy } from "../tools/presentation.js";
-
-/** A block's fold state. The same vocabulary serves tools, workers, thinking, and local bash. */
-export type Fold = ToolFoldDefault;
-
-/** An operator's explicit choice for one block, or none. */
-export type FoldOverride = Fold | undefined;
+/** Presentation budgets for the same captured session. Detailed is still bounded. */
+import type { OutputStyle } from "../core/defaults.js";
 
 export interface TranscriptDetailPolicy {
-	/** Finished tool call body: folded subline, the tool's own default, or open. */
-	toolBody: "folded" | "per-tool" | "expanded";
-	/** In-flight tool call: one-line row with elapsed, or the header plus streaming body. */
-	runningTool: "row" | "body";
-	/** Reasoning stretch: bare marker, folded marker with live progress, or the open rail. */
-	thinking: "marker" | "folded" | "rail";
-	/** Worker block: folded card, the origin default, or open. */
-	worker: "folded" | "origin" | "expanded";
-	/** Settled turn receipt: none, `turn · in N · out M`, or the full receipt. */
+	style: OutputStyle;
+	reasoningRows: number;
+	resultRows: number;
+	bashRows: number;
+	operatorBashRows: number;
+	diffRows: number;
+	workerRows: number;
+	workerActivity: boolean;
+	errorRows: number;
 	receipt: "none" | "compact" | "full";
-	/** Failed tool under its folded row: the bounded excerpt, or the full body. */
-	errors: "excerpt" | "body";
 }
 
-const MINIMAL: TranscriptDetailPolicy = {
-	toolBody: "folded",
-	runningTool: "row",
-	thinking: "marker",
-	worker: "folded",
-	receipt: "none",
-	errors: "excerpt",
-};
-
-const DEFAULT: TranscriptDetailPolicy = {
-	toolBody: "per-tool",
-	runningTool: "row",
-	thinking: "folded",
-	worker: "origin",
-	receipt: "compact",
-	errors: "excerpt",
+const POLICIES: Record<OutputStyle, TranscriptDetailPolicy> = {
+	compact: {
+		style: "compact",
+		reasoningRows: 0,
+		resultRows: 0,
+		bashRows: 0,
+		operatorBashRows: 3,
+		diffRows: 0,
+		workerRows: 0,
+		workerActivity: false,
+		errorRows: 4,
+		receipt: "none",
+	},
+	standard: {
+		style: "standard",
+		reasoningRows: 3,
+		resultRows: 0,
+		bashRows: 0,
+		operatorBashRows: 6,
+		diffRows: 8,
+		workerRows: 3,
+		workerActivity: false,
+		errorRows: 4,
+		receipt: "compact",
+	},
+	detailed: {
+		style: "detailed",
+		reasoningRows: 12,
+		resultRows: 8,
+		bashRows: 12,
+		operatorBashRows: 12,
+		diffRows: 20,
+		workerRows: 8,
+		workerActivity: true,
+		errorRows: 12,
+		receipt: "full",
+	},
 };
 
-const VERBOSE: TranscriptDetailPolicy = {
-	toolBody: "expanded",
-	runningTool: "body",
-	thinking: "rail",
-	worker: "expanded",
-	receipt: "full",
-	errors: "body",
-};
-
-/**
- * Map a verbosity to the full policy table. An absent verbosity (a panel built
- * without settings) is the balanced default, so the literal never has to be
- * spelled by the caller.
- */
-export function transcriptDetail(verbosity: OutputVerbosity | undefined): TranscriptDetailPolicy {
-	switch (verbosity) {
-		case "minimal":
-			return MINIMAL;
-		case "verbose":
-			return VERBOSE;
-		default:
-			return DEFAULT;
-	}
-}
-
-/** Effective state of one block: the operator's override when set, else the policy's answer. */
-export function resolveFold(override: FoldOverride, policyFold: Fold): Fold {
-	return override ?? policyFold;
-}
-
-/** The fold the policy gives a finished tool call, through the tool's own presentation when asked to. */
-export function policyToolFold(detail: TranscriptDetailPolicy, presentation: ToolPresentationPolicy): Fold {
-	if (detail.toolBody === "per-tool") return presentation.foldDefault;
-	return detail.toolBody;
-}
-
-/** The fold the policy gives an in-flight tool call. */
-export function policyRunningToolFold(detail: TranscriptDetailPolicy): Fold {
-	return detail.runningTool === "body" ? "expanded" : "folded";
-}
-
-/** The fold the policy gives a reasoning stretch. */
-export function policyThinkingFold(detail: TranscriptDetailPolicy): Fold {
-	return detail.thinking === "rail" ? "expanded" : "folded";
-}
-
-/**
- * The fold the policy gives a worker block. `askedByModel` is the origin rule
- * the caller already knows: a run the model asked for folds, the operator's own
- * run opens.
- */
-export function policyWorkerFold(detail: TranscriptDetailPolicy, askedByModel: boolean): Fold {
-	if (detail.worker === "origin") return askedByModel ? "folded" : "expanded";
-	return detail.worker;
-}
-
-/** The override that flips a block away from its current effective state. */
-export function toggledFold(effective: Fold): Fold {
-	return effective === "expanded" ? "folded" : "expanded";
+export function transcriptDetail(style: OutputStyle = "standard"): TranscriptDetailPolicy {
+	return POLICIES[style];
 }

package/src/interactive/view/artifacts.ts

@@ -44,6 +44,7 @@ import { clockLocal } from "../format-time.js";
 import { abbreviateModelId } from "../theme/index.js";
 
 export type ViewArtifactCategory =
+	| "transcript"
 	| "accountability"
 	| "evidence"
 	| "receipt"
@@ -86,6 +87,7 @@ export interface ArtifactProvider {
 }
 
 export interface ArtifactProviderDeps {
+	readTranscript?: (() => ViewArtifact[]) | undefined;
 	stateDir: string;
 	dataDir?: string | undefined;
 	dispatch?: Pick<DispatchContract, "listRuns" | "getRun"> | undefined;
@@ -94,6 +96,7 @@ export interface ArtifactProviderDeps {
 }
 
 export const VIEW_ARTIFACT_CATEGORIES: readonly ViewArtifactCategory[] = [
+	"transcript",
 	"accountability",
 	"evidence",
 	"receipt",
@@ -1560,6 +1563,7 @@ export class SafetyAuditArtifactProvider implements ArtifactProvider {
 
 export function createDefaultArtifactProviders(deps: ArtifactProviderDeps): ArtifactProvider[] {
 	return [
+		{ category: "transcript", list: async () => deps.readTranscript?.() ?? [] },
 		new AccountabilityArtifactProvider(deps),
 		new EvidenceArtifactProvider(deps),
 		new ReceiptArtifactProvider(deps),

package/src/interactive/view/view-overlay.ts

@@ -102,6 +102,8 @@ function artifactKey(artifact: ViewArtifact): string {
 
 function categoryLabel(category: ViewArtifactCategory): string {
 	switch (category) {
+		case "transcript":
+			return "Transcript details";
 		case "accountability":
 			return "Accountability";
 		case "evidence":
@@ -129,6 +131,7 @@ function categoryLabel(category: ViewArtifactCategory): string {
 
 const VIEW_ARTIFACT_CATEGORY_SET = new Set<ViewArtifactCategory>(VIEW_ARTIFACT_CATEGORIES);
 const BARE_CATEGORY_FILTERS = new Set<ViewArtifactCategory>([
+	"transcript",
 	"task-ledger",
 	"workspace",
 	"protected-artifact",
@@ -275,11 +278,8 @@ function groupedViewRows(artifacts: ReadonlyArray<ViewArtifact>): RenderedViewRo
 	const rows: RenderedViewRow[] = [];
 	for (const category of VIEW_ARTIFACT_CATEGORIES) {
 		const items = artifacts.filter((artifact) => artifact.category === category);
+		if (items.length === 0) continue;
 		rows.push({ type: "group", category });
-		if (items.length === 0) {
-			rows.push({ type: "empty", category });
-			continue;
-		}
 		for (const item of items) {
 			rows.push({ type: "item", category, item, itemIndex: artifacts.indexOf(item) });
 		}
@@ -393,11 +393,11 @@ function viewFooterHint(focus: ViewPaneFocus, canVerify: boolean, innerWidth?: n
 		const tiers =
 			focus === "list"
 				? [
-						"[↑↓] select · [type] filter · [Tab] detail · [Esc] close",
-						"[↑↓] select · [Tab] detail · [Esc] close",
-						"[↑↓] select · [Tab] detail",
+						"[↑↓] select · [type] filter · [Enter] detail · [Esc] close",
+						"[↑↓] select · [Enter] detail · [Esc] close",
+						"[↑↓] select · [Enter] detail",
 					]
-				: ["[↑↓] scroll · [Tab] list · [Esc] close", "[↑↓] scroll · [Tab] list"];
+				: ["[↑↓] scroll · [Esc] back", "[↑↓] scroll · [Tab] list"];
 		return tiers.find((tier) => visibleWidth(tier) <= budget) ?? (tiers.at(-1) as string);
 	}
 	if (focus === "list") {
@@ -405,20 +405,21 @@ function viewFooterHint(focus: ViewPaneFocus, canVerify: boolean, innerWidth?: n
 			{ key: "↑↓", verb: "select" },
 			{ key: "←→", verb: "category" },
 			{ key: "type", verb: "filter" },
-			{ key: "Tab", verb: "content" },
-			...(canVerify ? [{ key: "v", verb: "verify" }] : []),
-			{ key: "o", verb: "path" },
+			{ key: "Enter", verb: "content" },
+			{ key: "Ctrl+U", verb: "clear filter" },
 		]);
 	}
-	return buildHint([
-		{ key: "↑↓", verb: "scroll" },
-		{ key: "←→", verb: "category" },
-		{ key: "PgUp/PgDn", verb: "page" },
-		{ key: "g/G", verb: "top/bottom" },
-		{ key: "Tab", verb: "list" },
-		...(canVerify ? [{ key: "v", verb: "verify" }] : []),
-		{ key: "o", verb: "path" },
-	]);
+	return buildHint(
+		[
+			{ key: "↑↓", verb: "scroll" },
+			{ key: "←→", verb: "category" },
+			{ key: "PgUp/PgDn", verb: "page" },
+			{ key: "g/G", verb: "top/bottom" },
+			...(canVerify ? [{ key: "v", verb: "verify" }] : []),
+			{ key: "o", verb: "path" },
+		],
+		"back",
+	);
 }
 
 export class ViewOverlayView implements Component {
@@ -528,10 +529,11 @@ export class ViewOverlayView implements Component {
 		const content = this.content;
 		if (!content) return [];
 		if (content.status === "error") return content.lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)));
-		if (content.format !== "markdown") return content.lines;
 		if (content.renderedLines && content.renderWidth === width) return content.renderedLines;
-		const md = new Markdown(content.lines.join("\n"), 0, 0, markdownTheme(clioTheme()));
-		const rendered = md.render(width);
+		const rendered =
+			content.format === "markdown"
+				? new Markdown(content.lines.join("\n"), 0, 0, markdownTheme(clioTheme())).render(width)
+				: content.lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)));
 		content.renderWidth = width;
 		content.renderedLines = rendered;
 		return rendered;
@@ -556,6 +558,7 @@ export class ViewOverlayView implements Component {
 		}
 
 		const filtered = this.filteredArtifacts();
+		if (filtered.length === 0) return this.fixedLines([...lines, theme.fg("dim", "No matching details.")], width, height);
 		const rows = groupedViewRows(filtered);
 		const selectedRow = rows.findIndex((row) => row.type === "item" && row.itemIndex === this.selectedIndex);
 		const rowHeight = Math.max(1, height - 1);
@@ -634,7 +637,11 @@ export class ViewOverlayView implements Component {
 	}
 
 	handleInput(data: string): void {
-		if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
+		if (
+			matchesKey(data, "tab") ||
+			matchesKey(data, "shift+tab") ||
+			(this.focus === "list" && matchesKey(data, "enter"))
+		) {
 			this.focus = this.focus === "list" ? "content" : "list";
 			this.options.requestRender?.();
 			return;
@@ -647,21 +654,19 @@ export class ViewOverlayView implements Component {
 			this.selectCategory(1);
 			return;
 		}
-		if (data === "v") {
+		if (this.focus === "content" && data === "v") {
 			this.verifySelected();
 			return;
 		}
-		if (data === "o") {
+		if (this.focus === "content" && data === "o") {
 			this.openPathNotice();
 			return;
 		}
 		if (matchesKey(data, "esc")) {
-			if (this.focus === "list" && this.filterText.length > 0) {
-				this.filterText = "";
-				this.selectInitialFilterMatch();
-				return;
-			}
-			this.options.onClose();
+			if (this.focus === "content") {
+				this.focus = "list";
+				this.options.requestRender?.();
+			} else this.options.onClose();
 			return;
 		}
 		if (this.focus === "content") {
@@ -675,14 +680,19 @@ export class ViewOverlayView implements Component {
 
 	private handleListInput(data: string): boolean {
 		const filtered = this.filteredArtifacts();
-		if (matchesKey(data, "up") || data === "k") {
+		if (matchesKey(data, "up")) {
 			if (filtered.length > 0) this.selectIndex(this.selectedIndex - 1);
 			return true;
 		}
-		if (matchesKey(data, "down") || data === "j") {
+		if (matchesKey(data, "down")) {
 			if (filtered.length > 0) this.selectIndex(this.selectedIndex + 1);
 			return true;
 		}
+		if (matchesKey(data, "ctrl+u")) {
+			this.filterText = "";
+			this.selectInitialFilterMatch();
+			return true;
+		}
 		if (matchesKey(data, "backspace")) {
 			if (this.filterText.length > 0) {
 				this.filterText = this.filterText.slice(0, -1);

package/src/tools/presentation.ts

@@ -1,6 +1,6 @@
 /**
  * Typed tool presentation policy. Answers, per tool, what the transcript's
- * balanced (`/output default`) view needs to know: does the block open folded
+ * Standard view needs to know: does the block open folded
  * or expanded, does the folded row keep a mutation diff visible, and does a
  * failed folded row carry an output excerpt.
  *

package/src/tools/registry.ts

@@ -107,7 +107,7 @@ export interface ToolMetadata {
 	 */
 	promptHint?: ToolPromptHintMetadata;
 	/**
-	 * How transcript surfaces present this tool's block under `/output default`.
+	 * How transcript surfaces present this tool's block under Standard output style.
 	 * Optional: tools that declare nothing fold like every other tool.
 	 */
 	presentation?: ToolPresentationPolicy;

package/src/tools/verify/numeric.ts

@@ -133,15 +133,15 @@ export function parseNumericPayload(text: string, label: string): NumericPayload
 	const keys = Object.keys(record);
 	if (keys.length > NUMERIC_PAYLOAD_CAPS.keys)
 		return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.keys}-key cap`);
-	const payload: NumericPayload = {};
+	const entries: Array<[string, number | number[]]> = [];
 	let elements = 0;
 	for (const key of keys) {
 		const value = record[key];
 		if (typeof value === "number") {
-			payload[key] = value;
+			entries.push([key, value]);
 			elements += 1;
 		} else if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
-			payload[key] = [...(value as number[])];
+			entries.push([key, [...(value as number[])]]);
 			elements += value.length;
 		} else {
 			return new Error(`${label}.${key} must be a number or an array of numbers`);
@@ -150,7 +150,7 @@ export function parseNumericPayload(text: string, label: string): NumericPayload
 			return new Error(`${label} exceeds the ${NUMERIC_PAYLOAD_CAPS.elements}-element cap`);
 		}
 	}
-	return payload;
+	return Object.fromEntries(entries);
 }
 
 function deviation(actual: number, expected: number, index?: number): NumericDeviation {