@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/interactive/turn-recovery.ts

@@ -79,9 +79,10 @@ export interface TurnRecovery {
  * that landed in the same window wins: `activeInterruptReason` is set only by
  * `ChatLoop.cancel`, so the stall reason is dropped rather than retried.
  *
- * The failure's assistant message is rewritten in place because it is the same
- * object the ledger persists and the transcript renders; without it the turn
- * would read "[aborted] Request was aborted." instead of naming the stall.
+ * The runtime event seam calls `rewriteStallAbortMessage` before publishing or
+ * persisting `message_end`, so the provider's one terminal message becomes the
+ * corrected ledger row. This post-settlement pass covers engines that settle
+ * without emitting that event and consumes the watchdog reason in either case.
  */
 export function reclassifyStallAbort(
 	state: ChatTurnState,
@@ -90,14 +91,30 @@ export function reclassifyStallAbort(
 	const reason = state.streamStallReason;
 	state.streamStallReason = null;
 	if (reason === null || failure.stopReason !== "aborted" || state.activeInterruptReason !== null) return failure;
-	if (failure.message) {
-		const message = failure.message as { stopReason?: unknown; errorMessage?: unknown };
-		message.stopReason = "error";
-		message.errorMessage = reason;
-	}
+	if (failure.message) rewriteStallAbortMessage(state, failure.message, reason);
 	return { ...failure, stopReason: "error", errorMessage: reason };
 }
 
+/** Rewrite the provider's terminal abort object before its event is emitted and persisted. */
+export function rewriteStallAbortMessage(
+	state: ChatTurnState,
+	message: AgentMessage,
+	reason = state.streamStallReason,
+): boolean {
+	if (
+		reason === null ||
+		state.activeInterruptReason !== null ||
+		message.role !== "assistant" ||
+		(message as { stopReason?: unknown }).stopReason !== "aborted"
+	) {
+		return false;
+	}
+	const failure = message as { stopReason?: unknown; errorMessage?: unknown };
+	failure.stopReason = "error";
+	failure.errorMessage = reason;
+	return true;
+}
+
 export function createTurnRecovery(deps: TurnRecoveryDeps): TurnRecovery {
 	const { state, persistence, context } = deps;
 	let retryCountdown: RetryCountdownHandle | null = null;

package/src/interactive/turn-runtime.ts

@@ -11,7 +11,6 @@ import type { MiddlewareToolChoiceControl } from "../domains/middleware/index.js
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import {
 	applyModelCapabilityPatch,
-	firstRuntimeResolutionError,
 	modelResidencyForStatus,
 	type ProvidersContract,
 	refineRuntimeTargetWithModelHints,
@@ -35,6 +34,7 @@ import {
 	type AssistantCallTiming,
 	type BackendCacheVerdict,
 	backendCacheVerdict,
+	estimatedUsageForInterruptedTurn,
 	extractText,
 	extractThinking,
 	fallbackIdentityPrompt,
@@ -52,6 +52,22 @@ import type { AgentRuntime, ChatLoopTarget, ChatTurnState } from "./turn-state.j
 
 const LOCAL_API_KEY_FALLBACK = "clio-local-target";
 
+/**
+ * A turn that never started, with a machine-readable reason attached. The
+ * operator-facing message is unchanged prose; `reason` exists because the ACP
+ * server has to tell a client *why* Clio refused to admit the prompt, and
+ * parsing that out of the prose would bind a wire contract to a sentence.
+ */
+export class TurnAdmissionError extends Error {
+	constructor(
+		message: string,
+		readonly reason: string,
+	) {
+		super(message);
+		this.name = "TurnAdmissionError";
+	}
+}
+
 /**
  * Say that the first request will pay for a load, before it does.
  *
@@ -177,8 +193,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			requireOutputBudget: true,
 		});
 		if (!resolved.ok) {
-			const message = firstRuntimeResolutionError(resolved.diagnostics) ?? resolved.diagnostics[0]?.message;
-			throw new Error(`[Clio Coder] ${message ?? "orchestrator target resolution failed"}`);
+			const failure = resolved.diagnostics.find((entry) => entry.severity === "error") ?? resolved.diagnostics[0];
+			throw new TurnAdmissionError(
+				`[Clio Coder] ${failure?.message ?? "orchestrator target resolution failed"}`,
+				failure?.code ?? "admission-failed",
+			);
 		}
 		for (const message of runtimeResolutionWarnings(resolved.diagnostics)) {
 			const key = `${targetId}|${wireModelId}|${message}`;
@@ -331,8 +350,9 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		if (!target) return null;
 		context.emitContextWindowWarningTransition(target.runtimeResolution?.contextWindowDetails?.warning ?? null);
 		if (!deps.knownTargets().has(target.target.id)) {
-			throw new Error(
+			throw new TurnAdmissionError(
 				`[Clio Coder] orchestrator target=${target.target.id} unknown. Run \`clio-coder targets\` to see configured targets.`,
+				"target-unknown",
 			);
 		}
 		if (
@@ -400,6 +420,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			state.runtime.agent.abort();
 			cleanupSessionResources(state.runtime.agent.sessionId);
 		}
+		let getCurrentAgentSignal: () => AbortSignal | undefined = () => undefined;
 		const handle = deps.createAgent({
 			initialState: {
 				systemPrompt: fallbackIdentityPrompt(),
@@ -428,10 +449,16 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				if (!targetRequiresAuth(target.target, target.runtime)) {
 					return LOCAL_API_KEY_FALLBACK;
 				}
-				const resolved = await deps.providers.auth.resolveForTarget(target.target, target.runtime);
+				const signal = getCurrentAgentSignal();
+				const resolved = await deps.providers.auth.resolveForTarget(
+					target.target,
+					target.runtime,
+					signal ? { signal } : undefined,
+				);
 				return resolved.apiKey;
 			},
 		});
+		getCurrentAgentSignal = () => handle.agent.signal;
 
 		// Build the runtime object before subscribing so the callback closes
 		// over the same heap object the hot-swap path mutates. Reading
@@ -543,6 +570,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		// message of the run (prompts, assistant, tool results) via message_end,
 		// so the slice from here is the run's real message window.
 		let runStartMessageCount = 0;
+		// Estimated spend of each cancelled call, keyed by the engine's message
+		// object: message_end publishes it, agent_end re-reports it on the same
+		// object from agent state, and a suppressed hollow abort hands it to the
+		// closing turn. Weak so a settled run's messages are not retained.
+		const interruptedUsageByMessage = new WeakMap<object, Record<string, unknown>>();
 
 		handle.agent.subscribe(async (event) => {
 			// Wall anchor for the one field a human reads back (`recordedAt`);
@@ -608,7 +640,36 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 					enrichedEvent = { ...event, lockedSynthesisSanitized: true } as typeof event;
 				}
 			}
-			const publicEvent = enrichedEvent;
+			let publicEvent = enrichedEvent;
+			if (enrichedEvent.type === "message_end" && enrichedEvent.message?.role === "assistant") {
+				const interruptedUsage = estimatedUsageForInterruptedTurn(enrichedEvent.message, context.promptSideTokens());
+				if (interruptedUsage !== null) {
+					// Persistence records the same estimate, but it does so after the
+					// public event has already fed status. Copy it onto the public event
+					// only: the raw engine message and observability/cost path must remain
+					// provider-reported. Remember it by message identity so the public
+					// agent_end window below reports the same figure.
+					interruptedUsageByMessage.set(enrichedEvent.message as object, interruptedUsage);
+					publicEvent = {
+						...enrichedEvent,
+						message: { ...enrichedEvent.message, usage: interruptedUsage as unknown as Usage },
+					} as typeof enrichedEvent;
+				}
+			}
+			if (enrichedEvent.type === "agent_end") {
+				// The aborted message in the run window still carries the provider's
+				// untouched zeros. The footer's settled summary and the transcript's
+				// `turn · in/out` receipt both rebuild from this window, so give them
+				// the estimate the message_end published; the raw window feeds
+				// observability and the cache summary below unchanged.
+				const reported = enrichedEvent.messages.map((message) => {
+					const estimate = interruptedUsageByMessage.get(message as object);
+					return estimate === undefined ? message : ({ ...message, usage: estimate as unknown as Usage } as typeof message);
+				});
+				if (reported.some((message, index) => message !== enrichedEvent.messages[index])) {
+					publicEvent = { ...enrichedEvent, messages: reported } as typeof enrichedEvent;
+				}
+			}
 			if (publicEvent?.type === "agent_start") {
 				runStartMessageCount = localRuntime.agent.state.messages.length;
 				streamStartedAt = eventClock;
@@ -644,11 +705,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				if (hasDelta && firstAssistantDeltaAt === null) firstAssistantDeltaAt = eventClock;
 				if (hasDelta && apiCallFirstDeltaAt === null) apiCallFirstDeltaAt = eventClock;
 			}
-			if (publicEvent?.type === "agent_end") {
-				context.noteRunCacheSummary(publicEvent.messages, runFirstCallVerdict);
+			if (enrichedEvent.type === "agent_end") {
+				context.noteRunCacheSummary(enrichedEvent.messages, runFirstCallVerdict);
 			}
-			if (publicEvent?.type === "agent_end" && deps.observability) {
-				const summary = sumRunUsage(publicEvent.messages);
+			if (enrichedEvent.type === "agent_end" && deps.observability) {
+				const summary = sumRunUsage(enrichedEvent.messages);
 				if (summary.hadUsage && (summary.tokens > 0 || summary.costUsd > 0)) {
 					deps.observability.recordTokens(
 						localRuntime.targetId,
@@ -687,9 +748,15 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			// persistence does.
 			if (
 				state.activeInterruptReason !== null &&
-				publicEvent?.type === "message_end" &&
-				isEmptyAbortedAssistantMessage(publicEvent.message)
+				enrichedEvent.type === "message_end" &&
+				isEmptyAbortedAssistantMessage(enrichedEvent.message)
 			) {
+				// The ledger drops this message too, so the spend the cancelled call
+				// streamed as thinking would otherwise vanish from the durable record.
+				// Hand it to the closing turn the interrupt persists when the run
+				// settles; the public agent_end window above still feeds status.
+				const estimate = interruptedUsageByMessage.get(enrichedEvent.message as object);
+				if (estimate !== undefined) state.interruptedUsage = estimate;
 				return;
 			}
 			if (publicEvent) deps.emit(publicEvent);

package/src/interactive/turn-state.ts

@@ -39,6 +39,7 @@ export interface AgentRuntime {
 
 export interface ChatLoopRunSnapshot {
 	targetId: string;
+	targetUrl: string | null;
 	runtimeId: string;
 	runtimeKind: RuntimeDescriptor["kind"];
 	wireModelId: string;
@@ -74,6 +75,14 @@ export interface ChatTurnState {
 	 * start of each submit.
 	 */
 	activeInterruptReason: string | null;
+	/**
+	 * Estimated spend of the cancelled call whose hollow aborted message the
+	 * interrupt suppressed (thinking streamed, no text). The message never reaches
+	 * the ledger, so the closing turn persisted in submit's finally carries this
+	 * instead of an estimate derived from its own notice text. Cleared with
+	 * `activeInterruptReason`.
+	 */
+	interruptedUsage: Record<string, unknown> | null;
 	/**
 	 * Loop-guard synthesis lockout: once the guard locks a turn, the remaining
 	 * model rounds are forced text-only at the request level (tool_choice none
@@ -108,6 +117,7 @@ export function createTurnState(initialThinkingLevel: ThinkingLevel): ChatTurnSt
 		replayedContextMessages: [],
 		activeUserTurnId: null,
 		activeInterruptReason: null,
+		interruptedUsage: null,
 		synthesisToolLock: false,
 		toolProseAbortReason: null,
 		streamStallReason: null,

package/src/interactive/view/artifacts.ts

@@ -1,6 +1,6 @@
 import { createReadStream, readFileSync, statSync } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import type { DispatchContract } from "../../domains/dispatch/contract.js";
 import {
 	isReceiptIntegrity,
@@ -31,6 +31,8 @@ import {
 	readPromptCompileManifest,
 	type SessionPromptCompileRecord,
 } from "../../domains/session/prompt-manifest.js";
+import { foldSessionArtifacts, resolveSessionArtifactPath } from "../../domains/session/session-artifacts.js";
+import { filterEntriesToActivePath } from "../../domains/session/tree/active-path.js";
 import { formatUsd } from "../footer/widgets.js";
 import { formatFooterTokens } from "../footer-panel.js";
 import { clockLocal } from "../format-time.js";
@@ -42,6 +44,7 @@ export type ViewArtifactCategory =
 	| "receipt"
 	| "dispatch"
 	| "task-ledger"
+	| "workspace"
 	| "tool-output"
 	| "protected-artifact"
 	| "compaction"
@@ -91,6 +94,7 @@ export const VIEW_ARTIFACT_CATEGORIES: readonly ViewArtifactCategory[] = [
 	"receipt",
 	"dispatch",
 	"task-ledger",
+	"workspace",
 	"tool-output",
 	"protected-artifact",
 	"compaction",
@@ -815,6 +819,8 @@ function renderTaskLedgerGoals(lines: string[], heading: string, goals: Readonly
 	for (const goal of goals) {
 		const parent = goal.parentGoalId ? ` parent ${goal.parentGoalId}` : "";
 		lines.push(`- [${goal.status}] ${goal.id} ${goal.title}${parent}`);
+		if (goal.origin) lines.push(`  - origin: ${goal.origin}`);
+		if (goal.userTaskId) lines.push(`  - operator task: ${goal.userTaskId}`);
 		if (goal.description) lines.push(`  - description: ${goal.description}`);
 	}
 }
@@ -842,6 +848,7 @@ function renderTaskLedgerMarkdown(entry: TaskLedgerEntry): string[] {
 		`- timestamp: ${entry.timestamp}`,
 		`- status: ${taskLedgerStatusSummary(entry)}`,
 	];
+	if (entry.boardId) lines.push(`- board id: ${entry.boardId}`);
 	renderTaskLedgerGoals(lines, "## Board Goals", entry.goals);
 	renderTaskLedgerGoals(lines, "## Subgoals", entry.subgoals);
 	lines.push("", "## Active Runs");
@@ -873,9 +880,24 @@ export class TaskLedgerArtifactProvider implements ArtifactProvider {
 				...(path ? { path } : {}),
 				searchText: [
 					entry.turnId,
+					entry.boardId ?? "",
 					...entry.activeRunIds,
-					...entry.goals.flatMap((goal) => [goal.id, goal.title, goal.description ?? "", goal.parentGoalId ?? ""]),
-					...entry.subgoals.flatMap((goal) => [goal.id, goal.title, goal.description ?? "", goal.parentGoalId ?? ""]),
+					...entry.goals.flatMap((goal) => [
+						goal.id,
+						goal.title,
+						goal.description ?? "",
+						goal.parentGoalId ?? "",
+						goal.origin ?? "agent",
+						goal.userTaskId ?? "",
+					]),
+					...entry.subgoals.flatMap((goal) => [
+						goal.id,
+						goal.title,
+						goal.description ?? "",
+						goal.parentGoalId ?? "",
+						goal.origin ?? "agent",
+						goal.userTaskId ?? "",
+					]),
 					...entry.requiredValidationEvidence.flatMap((item) => [
 						item.id,
 						item.description,
@@ -892,6 +914,93 @@ export class TaskLedgerArtifactProvider implements ArtifactProvider {
 	}
 }
 
+function workspaceArtifactFormat(path: string): ViewArtifactFormat {
+	const lower = path.toLowerCase();
+	return lower.endsWith(".md") || lower.endsWith(".markdown") ? "markdown" : "text";
+}
+
+class WorkspaceArtifactContainmentError extends Error {}
+
+async function canonicalWorkspaceArtifactPath(path: string, workspace: string): Promise<string> {
+	// Resolve both sides from the live filesystem for every load. The artifact
+	// row is durable, but neither an earlier lexical check nor an earlier realpath
+	// result is authority after a symlink has changed.
+	const canonicalWorkspace = await realpath(workspace);
+	const canonicalTarget = await realpath(path);
+	const rel = relative(canonicalWorkspace, canonicalTarget);
+	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+		throw new WorkspaceArtifactContainmentError("canonical target is outside the recorded workspace");
+	}
+	return canonicalTarget;
+}
+
+async function loadWorkspaceArtifact(
+	path: string,
+	workspace: string,
+	recordedAt: string,
+): Promise<ViewArtifactLoadResult> {
+	try {
+		const canonicalPath = await canonicalWorkspaceArtifactPath(path, workspace);
+		const { lines } = await readTextFileLinesCapped(canonicalPath);
+		return { lines, format: workspaceArtifactFormat(path) };
+	} catch (error) {
+		const err = error as NodeJS.ErrnoException;
+		if (err.code === "ENOENT") {
+			return { lines: [`file no longer on disk (recorded at ${recordedAt})`], format: "text" };
+		}
+		if (error instanceof WorkspaceArtifactContainmentError) {
+			return { lines: [`refusing to read ${path}: ${error.message}`], format: "text" };
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		return { lines: [`unable to read ${path}: ${message}`], format: "text" };
+	}
+}
+
+/** Files successfully produced by artifact/write/edit on the active session branch. */
+export class WorkspaceArtifactProvider implements ArtifactProvider {
+	readonly category = "workspace" as const;
+	private readonly entries: ReadonlyArray<SessionEntry>;
+
+	constructor(private readonly deps: ArtifactProviderDeps) {
+		const entries = [...sessionEntries(deps)];
+		this.entries = filterEntriesToActivePath(entries, deps.sessionMeta?.pinnedLeafTurnId ?? undefined);
+	}
+
+	async list(): Promise<ViewArtifact[]> {
+		const workspace = this.deps.sessionMeta?.cwd;
+		if (!workspace) return [];
+		return foldSessionArtifacts(this.entries, { workspace }).flatMap((artifact) => {
+			const path = resolveSessionArtifactPath(artifact.path, workspace);
+			if (path === null) return [];
+			const kind = artifact.artifactKind ? ` · ${artifact.artifactKind}` : "";
+			const overwriteLabel = `${artifact.overwrites} overwrite${artifact.overwrites === 1 ? "" : "s"}`;
+			return [
+				{
+					id: `workspace:${path}`,
+					category: this.category,
+					title: safeTitle(`${artifact.path} · ${artifact.tool}${kind}`, artifact.path),
+					timestamp: parseTime(artifact.timestamp),
+					sizeBytes: maybeSizeBytes(path),
+					path,
+					description: `${artifact.tool}${kind} · ${overwriteLabel}`,
+					toolName: artifact.tool,
+					searchText: [
+						artifact.path,
+						path,
+						basename(path),
+						artifact.tool,
+						artifact.artifactKind ?? "",
+						overwriteLabel,
+						String(artifact.overwrites),
+						artifact.turnId,
+					].filter(isNonEmptyString),
+					load: () => loadWorkspaceArtifact(path, workspace, artifact.timestamp),
+				},
+			];
+		});
+	}
+}
+
 export class ToolOutputArtifactProvider implements ArtifactProvider {
 	readonly category = "tool-output" as const;
 
@@ -1310,6 +1419,7 @@ export function createDefaultArtifactProviders(deps: ArtifactProviderDeps): Arti
 		new ReceiptArtifactProvider(deps),
 		new DispatchArtifactProvider(deps),
 		new TaskLedgerArtifactProvider(deps),
+		new WorkspaceArtifactProvider(deps),
 		new ToolOutputArtifactProvider(deps),
 		new ProtectedArtifactProvider(deps),
 		new CompactionArtifactProvider(deps),

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

@@ -109,6 +109,8 @@ function categoryLabel(category: ViewArtifactCategory): string {
 			return "Dispatch outputs";
 		case "task-ledger":
 			return "Task ledgers";
+		case "workspace":
+			return "Workspace outputs";
 		case "tool-output":
 			return "Tool outputs";
 		case "protected-artifact":
@@ -125,6 +127,7 @@ function categoryLabel(category: ViewArtifactCategory): string {
 const VIEW_ARTIFACT_CATEGORY_SET = new Set<ViewArtifactCategory>(VIEW_ARTIFACT_CATEGORIES);
 const BARE_CATEGORY_FILTERS = new Set<ViewArtifactCategory>([
 	"task-ledger",
+	"workspace",
 	"protected-artifact",
 	"compaction",
 	"prompt-manifest",

package/src/interactive/welcome-dashboard.ts

@@ -2,17 +2,16 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { ClioSettings } from "../core/config.js";
 import { readClioVersion } from "../core/package-root.js";
-import { EXPERIMENTAL_RELEASE_WARNING } from "../core/release.js";
+import { loadProjectClioMd } from "../domains/context/clio-md.js";
+import { readCodewiki, readCodewikiAsync } from "../domains/context/codewiki/artifact.js";
+import { renderCodewikiDigest } from "../domains/context/codewiki/digest.js";
+import { listWikiPages } from "../domains/context/wiki/layout.js";
 import {
-	listWikiPages,
-	readCodewiki,
-	readCodewikiAsync,
-	renderCodewikiDigest,
 	type WikiStaleness,
 	wikiCompleteness,
 	wikiStaleness,
 	wikiStalenessAsync,
-} from "../domains/context/index.js";
+} from "../domains/context/wiki/staleness.js";
 import type { TaskMemoryOperatorStatus } from "../domains/memory/index.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import {
@@ -172,7 +171,9 @@ function entryPointExcerpt(codewikiDigest: string): string[] {
 const NO_WIKI_STATUS = "no wiki; run clio-coder context wiki";
 
 function clioMdStatusFor(cwd: string): string {
-	return existsSync(join(cwd, "CLIO-CODER.md")) ? "ok" : "none";
+	const loaded = loadProjectClioMd(cwd);
+	if (loaded.errors.length > 0) return "malformed";
+	return loaded.files.length > 0 ? "ok" : "none";
 }
 
 /** Shape the wiki rows from a staleness verdict the caller already paid for. */
@@ -370,7 +371,10 @@ function nextValue(stats: WelcomeDashboardStats): string {
 /**
  * The launchpad has one fixed row per decision the operator needs to make.
  * Repository facts may replace text inside NEXT, never rows. After submission,
- * the session header is exactly one line for every width and fact state.
+ * the session header is exactly one line for every width and fact state, and
+ * it carries the same three facts in order: where Clio is working, which
+ * route answers, and what the context is ready for. Maturity caveats belong
+ * in the README, not in a line the operator reads on every turn.
  */
 export function buildWelcomeDashboardLines(
 	stats: WelcomeDashboardStats,
@@ -380,21 +384,18 @@ export function buildWelcomeDashboardLines(
 	const theme = clioTheme();
 	const safeWidth = Math.max(1, width);
 	const title = `${brandMark(theme)} ${theme.style("title", "Clio Coder", { bold: true })} ${theme.fg("dim", `v${readClioVersion()}`)}`;
-	const experimental = theme.style("warning", EXPERIMENTAL_RELEASE_WARNING, { bold: true });
 	const tag = (label: string): string => sectionTag(theme, "accentDeep", label, 9);
 	const row = (label: string, value: string): string => `  ${tag(label)}  ${value}`;
+	const workspace = theme.fg("muted", workspaceValue(stats));
+	const route = theme.fg(stats.currentAvailable ? "success" : "warning", routeValue(stats));
+	const next = theme.fg(stats.clioMdStatus === "ok" && !stats.factsPending ? "success" : "warning", nextValue(stats));
 
 	if (mode === "session") {
-		const header = `${title} · ${experimental} · ${theme.fg("muted", nextValue(stats))}`;
+		const header = [title, workspace, route, theme.fg("muted", nextValue(stats))].join(" · ");
 		return [truncateToWidth(header, safeWidth, GLYPH.ellipsis, true)];
 	}
 
-	const body = [
-		`  ${experimental}`,
-		row("WORKSPACE", theme.fg("muted", workspaceValue(stats))),
-		row("ROUTE", theme.fg(stats.currentAvailable ? "success" : "warning", routeValue(stats))),
-		row("NEXT", theme.fg(stats.clioMdStatus === "ok" && !stats.factsPending ? "success" : "warning", nextValue(stats))),
-	];
+	const body = [row("WORKSPACE", workspace), row("ROUTE", route), row("NEXT", next)];
 	if (safeWidth >= MID_MIN) return frame(theme, title, body, safeWidth);
 	return [title, ...body].map((line) => truncateToWidth(line, safeWidth, GLYPH.ellipsis, true));
 }

package/src/interactive/worker-receipts.ts

@@ -13,7 +13,8 @@
  * to take down a render.
  */
 
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { clioStateDir } from "../core/xdg.js";
 import { receiptFilePath } from "./view/artifacts.js";
 import type { WorkerReceiptFacts, WorkerResultContract } from "./worker-stream.js";
@@ -83,8 +84,8 @@ export function workerReceiptFacts(receipt: Record<string, unknown>): WorkerRece
 	};
 }
 
-/** Read and project `<state>/receipts/<runId>.json`; null when it is absent or unreadable. */
-export function readWorkerReceiptFacts(runId: string, stateDir = clioStateDir()): WorkerReceiptFacts | null {
+/** Read and project `<state>/receipts/<runId>.json` alone; null when it is absent or unreadable. */
+function readReceiptFileFacts(runId: string, stateDir: string): WorkerReceiptFacts | null {
 	try {
 		const parsed: unknown = JSON.parse(readFileSync(receiptFilePath(stateDir, runId), "utf8"));
 		return isRecord(parsed) ? workerReceiptFacts(parsed) : null;
@@ -92,3 +93,51 @@ export function readWorkerReceiptFacts(runId: string, stateDir = clioStateDir())
 		return null;
 	}
 }
+
+/** Read and project `<state>/receipts/<runId>.json`; null when it is absent or unreadable. */
+export function readWorkerReceiptFacts(runId: string, stateDir = clioStateDir()): WorkerReceiptFacts | null {
+	return readReceiptFileFacts(runId, stateDir);
+}
+
+/**
+ * The subset of a `runs.json` row replay needs once a receipt has failed to
+ * read: whether the run is still open, and, if the ledger closed it early
+ * (`closeAbandonedRows`), the closing row's own explanation.
+ */
+function findRunRow(runId: string, stateDir: string): Record<string, unknown> | null {
+	const path = join(stateDir, "runs.json");
+	if (!existsSync(path)) return null;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!Array.isArray(parsed)) return null;
+		for (const entry of parsed) {
+			if (isRecord(entry) && entry.id === runId) return entry;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Replay-only receipt reader: falls back to the run's own `runs.json` row
+ * when no receipt was sealed for it, so a resumed transcript can tell a run
+ * still going in another process, one the ledger closed as dead/stalled
+ * before it could seal a receipt, and one whose evidence is genuinely gone
+ * apart from each other. Never used by the live subscription: there, a
+ * missing receipt at settle time is a flush race the terminal event's own
+ * payload already covers (`worker-stream.ts`'s `settle`), not an open run.
+ */
+export function readWorkerReceiptFactsForReplay(runId: string, stateDir = clioStateDir()): WorkerReceiptFacts | null {
+	const sealed = readReceiptFileFacts(runId, stateDir);
+	if (sealed !== null) return sealed;
+	const row = findRunRow(runId, stateDir);
+	if (row === null) return null;
+	if (row.endedAt === null || row.endedAt === undefined) return { outcome: "running", stillRunning: true };
+	const outcome = optionalString(row.outcome) ?? optionalString(row.status) ?? "unknown";
+	const abandonedDetail = optionalString(row.outcomeDetail);
+	return {
+		outcome,
+		...(abandonedDetail !== undefined ? { abandonedDetail } : {}),
+	};
+}

package/src/interactive/worker-stream.ts

@@ -64,8 +64,12 @@ export interface WorkerReceiptSummary {
 	contract?: WorkerResultContract;
 	/** From an abort marker rather than a sealed terminal event; a later DispatchCompleted/DispatchFailed replaces it. */
 	provisional?: boolean;
-	/** The run is over, but no receipt could be read for it. */
+	/** The run is over, but no receipt could be read for it, and the ledger row could not explain why either. */
 	receiptUnavailable?: boolean;
+	/** Replay only: the ledger row for this run has no `endedAt` yet, so the run is still going in another process. */
+	stillRunning?: boolean;
+	/** Replay only: no receipt exists because the ledger closed this row early (`closeAbandonedRows`); the row's own explanation, verbatim. */
+	abandonedDetail?: string;
 }
 
 /** A receipt's projection: the summary plus the answer it sealed. */

package/src/tools/agent-tools.ts

@@ -25,9 +25,9 @@ import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
 import type { SafetyDecision } from "../domains/safety/contract.js";
 import { formatModelRejection } from "../domains/safety/rejection-feedback.js";
 import { validateEngineToolArguments } from "../engine/ai.js";
-import type { AgentTool, AgentToolResult } from "../engine/types.js";
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "../engine/types.js";
 import { applyToolProfile, type ToolProfileName } from "./profiles.js";
-import type { ToolInvokeOptions, ToolRegistry, ToolSpec } from "./registry.js";
+import type { ToolInvokeOptions, ToolRegistry, ToolResult, ToolSpec } from "./registry.js";
 
 /**
  * Lightweight per-call observability hook. Default no-op so unused
@@ -96,6 +96,18 @@ export interface InvokeWorkerToolOptions {
 type WorkerAgentToolResult = AgentToolResult<{ kind: "ok" } | { kind: "error" }>;
 type WorkerToolOkDetails = { kind: "ok" } & Record<string, unknown>;
 
+function projectToolResult(result: ToolResult): WorkerAgentToolResult {
+	const details = { ...(result.details ?? {}), kind: result.kind } as { kind: "ok" } | { kind: "error" };
+	if (result.kind === "error") {
+		return { content: [{ type: "text", text: result.message }], details };
+	}
+	return {
+		content: [{ type: "text", text: result.output }],
+		details,
+		...(result.terminate === true ? { terminate: true } : {}),
+	};
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -264,9 +276,17 @@ function toAgentTool(
 		description: spec.description,
 		parameters: spec.parameters,
 		label: spec.metadata?.uiLabel ?? spec.name,
-		async execute(toolCallId: string, params: unknown, signal?: AbortSignal): Promise<WorkerAgentToolResult> {
+		async execute(
+			toolCallId: string,
+			params: unknown,
+			signal?: AbortSignal,
+			onUpdate?: AgentToolUpdateCallback,
+		): Promise<WorkerAgentToolResult> {
 			const options = invokeOptions?.() ?? {};
 			if (toolCallId.length > 0) options.toolCallId = toolCallId;
+			if (onUpdate !== undefined) {
+				options.onUpdate = (partialResult) => onUpdate(projectToolResult(partialResult));
+			}
 			const callInput: RunValidatedToolCallInput = {
 				spec,
 				args: params as Record<string, unknown>,