@iowarp/clio-coder 0.4.4 → 0.4.6

package/src/interactive/status/controller.ts

@@ -206,9 +206,6 @@ export function createStatusController(deps: StatusControllerDeps): StatusContro
 			deps.bus.on(BusChannels.PermissionResolved, () => apply({ type: "overlay_pop", overlay: "tool_blocked" }, true)),
 			deps.bus.on(BusChannels.CompactionBegin, () => apply({ type: "overlay_push", overlay: "compacting" }, true)),
 			deps.bus.on(BusChannels.CompactionEnd, () => apply({ type: "overlay_pop", overlay: "compacting" }, true)),
-			deps.bus.on(BusChannels.DispatchStarted, (payload) =>
-				apply({ type: "overlay_push", overlay: "dispatching", data: payload }, true),
-			),
 			deps.bus.on(BusChannels.DispatchProgress, (payload) => {
 				if (!isWorkerStreamEvidence(payload)) return;
 				const at = now();
@@ -216,8 +213,6 @@ export function createStatusController(deps: StatusControllerDeps): StatusContro
 				lastDispatchProgressAt = at;
 				apply({ type: "dispatch_progress" });
 			}),
-			deps.bus.on(BusChannels.DispatchCompleted, () => apply({ type: "overlay_pop", overlay: "dispatching" }, true)),
-			deps.bus.on(BusChannels.DispatchFailed, () => apply({ type: "overlay_pop", overlay: "dispatching" }, true)),
 			deps.bus.on(BusChannels.RunAborted, (payload) => {
 				scheduleAbortCeiling();
 				// Carry abort provenance into the summary; a dispatch drain and a

package/src/interactive/status/state-machine.ts

@@ -245,6 +245,7 @@ function activePhaseAfterStuck(prev: AgentStatus): StatusPhase {
 }
 
 function isAwaitingDispatch(prev: AgentStatus): boolean {
+	if (activePhaseAfterStuck(prev) === "tool_running" && prev.tool?.toolName === ToolNames.Dispatch) return true;
 	if (prev.phase === "dispatching") return true;
 	if (prev.activePhases?.has("dispatching")) return true;
 	return (prev.overlayStack ?? []).some((frame) => frame.phase === "dispatching");
@@ -360,26 +361,9 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			if (base === "preparing") return { ...next, phase: "waiting_model", resumePhase: undefined };
 			return next;
 		}
-		case "message_start": {
-			const next = refreshMeaningful(prev, ctx);
-			const role = (event.message as { role?: unknown }).role;
-			if (role === "assistant" && prev.phase === "tool_running") return { ...next, phase: "writing" };
-			if (
-				role === "assistant" &&
-				(prev.phase === "preparing" || prev.phase === "waiting_model" || prev.phase === "thinking")
-			)
-				return { ...next, phase: "writing", resumePhase: undefined };
-			return next;
-		}
-		case "message_update": {
-			const base = activePhaseAfterStuck(prev);
-			const next = refreshMeaningful({ ...prev, phase: base }, ctx);
-			if (base === "preparing" || base === "waiting_model" || base === "thinking") {
-				return { ...next, phase: "writing", resumePhase: undefined };
-			}
-			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
-			return next;
-		}
+		case "message_start":
+		case "message_update":
+			return refreshMeaningful(prev, ctx);
 		case "tool_execution_update":
 			return refreshMeaningful(prev, ctx);
 		case "message_end":
@@ -390,10 +374,22 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 				runTally: foldMessageIntoRunTally(prev.runTally ?? emptyRunTally(), event.message),
 			};
 		case "tool_execution_end": {
-			const next = refreshMeaningful(prev, ctx);
-			if (prev.phase === "tool_running") return { ...next, phase: "preparing", tool: undefined, toolStartedAt: undefined };
+			const activeTools = (prev.activeTools ?? []).filter((tool) => tool.toolCallId !== event.toolCallId);
+			const next = { ...refreshMeaningful(prev, ctx), activeTools };
+			const remaining = activeTools.at(-1);
+			if (remaining && prev.phase === "tool_running")
+				return { ...next, tool: remaining, toolStartedAt: remaining.startedAt };
+			if (prev.phase === "tool_running")
+				return { ...next, phase: "preparing", tool: undefined, toolStartedAt: undefined, activeTools: [] };
 			if (prev.phase === "stuck" && prev.resumePhase === "tool_running") {
-				return { ...next, phase: "preparing", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "preparing",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			// A blocked call's end can land while an overlay is still visible
 			// (permission prompt not yet resolved, retry or dispatch in front).
@@ -422,7 +418,14 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			// tool is done (its end never landed or was an admission block): the
 			// model is generating, nothing is executing, so drop the tool display.
 			if (base === "preparing" || base === "waiting_model" || base === "writing" || base === "tool_running") {
-				return { ...next, phase: "thinking", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "thinking",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
 			return next;
@@ -433,19 +436,34 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			// Streamed answer text while a tool still shows as running: same as
 			// above, the model is writing, so the running-tool spinner must clear.
 			if (base === "preparing" || base === "waiting_model" || base === "thinking" || base === "tool_running") {
-				return { ...next, phase: "writing", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "writing",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
 			return next;
 		}
 		case "tool_execution_start": {
 			const tool: ToolOverlay = {
+				toolCallId: event.toolCallId,
+				startedAt: ctx.now,
 				toolName: event.toolName,
 				toolPreview: compactPreview(event.args),
 			};
 			// Stamp this call's own start so the footer's running-tool timer counts
 			// from here, not from turn start.
-			return { ...refreshMeaningful(prev, ctx), phase: "tool_running", tool, toolStartedAt: ctx.now };
+			return {
+				...refreshMeaningful(prev, ctx),
+				phase: "tool_running",
+				tool,
+				toolStartedAt: ctx.now,
+				activeTools: [...(prev.activeTools ?? []).filter((active) => active.toolCallId !== event.toolCallId), tool],
+			};
 		}
 		case "retry_status": {
 			const phase = event.status.phase;

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];
 }