@iowarp/clio-coder 0.4.8 → 0.4.9

package/src/engine/session.ts

@@ -1,5 +1,5 @@
 /**
- * Clio session JSONL writer + reader (Phase 3 slice 1).
+ * Clio session JSONL writer + reader.
  *
  * On-disk layout under `clioStateDir()`:
  *   sessions/<cwdHash>/<sessionId>/
@@ -9,7 +9,7 @@
  *
  * Atomicity:
  *   - Appends go to an O_APPEND fd held for the writer's lifetime; each line
- *     is one write(2). fsync is debounced after appends and forced on
+ *     uses complete byte writes. fsync is debounced after appends and forced on
  *     checkpoint (`persistTree`) and `close`. A torn last line from a crash
  *     is tolerated by the reader (skipped with a warning).
  *   - `replaceEntries` rewrites current.jsonl via `writeJsonlFileAtomic`
@@ -28,6 +28,7 @@ import {
 	constants as fsConstants,
 	fstatSync,
 	fsyncSync,
+	ftruncateSync,
 	mkdirSync,
 	openSync,
 	readdirSync,
@@ -35,6 +36,7 @@ import {
 	readSync,
 	renameSync,
 	statSync,
+	unlinkSync,
 	writeSync,
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -197,6 +199,31 @@ function serializeJsonl(entries: ReadonlyArray<unknown>): string {
 	return `${lines.join("\n")}\n`;
 }
 
+/** Complete UTF-8 bytes even when write(2) makes only partial progress. */
+function writeAll(fd: number, bytes: Buffer): void {
+	let offset = 0;
+	while (offset < bytes.length) {
+		const written = writeSync(fd, bytes, offset, bytes.length - offset);
+		if (written <= 0) throw new Error(`session JSONL write made no progress after ${offset} of ${bytes.length} bytes`);
+		offset += written;
+	}
+}
+
+/** Roll back a failed append so a retry cannot fuse onto its partial record. */
+function appendAll(fd: number, bytes: Buffer): void {
+	const size = fstatSync(fd).size;
+	try {
+		writeAll(fd, bytes);
+	} catch (error) {
+		try {
+			ftruncateSync(fd, size);
+		} catch (rollbackError) {
+			throw new AggregateError([error, rollbackError], "session JSONL append and rollback failed; reopen to recover");
+		}
+		throw error;
+	}
+}
+
 /**
  * Rewrite a JSONL file through `<target>.tmp` and rename over the target.
  * A crash or interruption before the rename leaves the original target
@@ -213,10 +240,21 @@ function writeJsonlFileAtomic(
 	const tmp = `${targetPath}.tmp`;
 	const fd = openSync(tmp, "w");
 	try {
-		writeSync(fd, body);
-		fsyncSync(fd);
-	} finally {
-		closeSync(fd);
+		try {
+			writeAll(fd, Buffer.from(body, "utf8"));
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+	} catch (error) {
+		// A missing target can recover from .tmp, so an incomplete write
+		// must not leave a candidate that recovery could promote.
+		try {
+			unlinkSync(tmp);
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "session JSONL write and temporary cleanup failed");
+		}
+		throw error;
 	}
 	options.beforeRename?.(tmp, targetPath);
 	renameSync(tmp, targetPath);
@@ -633,10 +671,7 @@ export function appendSessionFileEntry(targetPath: string, entry: unknown): void
 	const line = Buffer.from(`${endsWithNewline(appendPath) ? "" : "\n"}${serialized}\n`, "utf8");
 	const fd = openSync(appendPath, fsConstants.O_WRONLY | fsConstants.O_APPEND);
 	try {
-		const written = writeSync(fd, line);
-		if (written !== line.length) {
-			throw new Error(`short session JSONL append: wrote ${written} of ${line.length} bytes`);
-		}
+		appendAll(fd, line);
 		fsyncSync(fd);
 	} finally {
 		closeSync(fd);
@@ -655,6 +690,9 @@ function createWriter(
 	let closed = false;
 	let appendFd: number | null = null;
 	let fsyncTimer: NodeJS.Timeout | null = null;
+	// Descriptor cleanup must not discard accepted bytes or rollback changes
+	// still owed to the next debounce, checkpoint, flush, or close.
+	let pendingFsync = false;
 
 	// One-time normalization for resumes of pre-header files: rewrite once so
 	// fd-appended lines land after a header. Disk and memory match from here on.
@@ -668,7 +706,10 @@ function createWriter(
 		appendFd = openSync(paths.current, "a");
 		// Terminating the fragment keeps the reader's torn-tail behavior:
 		// it skips exactly one invalid line with a warning.
-		if (tornTail) writeSync(appendFd, "\n");
+		if (tornTail) {
+			pendingFsync = true;
+			appendAll(appendFd, Buffer.from("\n"));
+		}
 		return appendFd;
 	}
 
@@ -676,28 +717,52 @@ function createWriter(
 		if (fsyncTimer !== null) return;
 		fsyncTimer = setTimeout(() => {
 			fsyncTimer = null;
-			if (appendFd === null) return;
 			try {
-				fsyncSync(appendFd);
+				flushPendingAppends();
 			} catch {
-				// A concurrent close already flushed and released the fd.
+				// Keep the obligation pending. Explicit flush/checkpoint/close
+				// retries and reports an error if storage is still unavailable.
 			}
 		}, APPEND_FSYNC_DEBOUNCE_MS);
 		fsyncTimer.unref?.();
 	}
 
+	function flushPendingAppends(): void {
+		if (appendFd !== null) {
+			fsyncSync(appendFd);
+			pendingFsync = false;
+			return;
+		}
+		if (!pendingFsync || stateRootRemoved()) return;
+		// Reopen without O_CREAT or tail normalization: flushing after a failed
+		// append must neither recreate removed state nor alter retained bytes.
+		const fd = openSync(paths.current, fsConstants.O_WRONLY | fsConstants.O_APPEND);
+		try {
+			fsyncSync(fd);
+		} catch (error) {
+			try {
+				closeSync(fd);
+			} catch (closeError) {
+				throw new AggregateError([error, closeError], "session JSONL flush and close failed");
+			}
+			throw error;
+		}
+		closeSync(fd);
+		pendingFsync = false;
+	}
+
 	function closeAppendFd(opts: { flush: boolean }): void {
+		if (opts.flush) flushPendingAppends();
 		if (fsyncTimer !== null) {
 			clearTimeout(fsyncTimer);
 			fsyncTimer = null;
 		}
 		if (appendFd === null) return;
-		try {
-			if (opts.flush) fsyncSync(appendFd);
-		} finally {
-			closeSync(appendFd);
-			appendFd = null;
-		}
+		const fd = appendFd;
+		// A failed close can already have released the OS descriptor. Never
+		// retain that ambiguous number for a later append or duplicate close.
+		appendFd = null;
+		closeSync(fd);
 	}
 
 	function appendLine(entry: unknown): void {
@@ -705,7 +770,21 @@ function createWriter(
 		if (serialized === undefined) {
 			throw new Error("session JSONL entry is not serializable");
 		}
-		writeSync(openAppendFd(), `${serialized}\n`);
+		try {
+			const fd = openAppendFd();
+			pendingFsync = true;
+			appendAll(fd, Buffer.from(`${serialized}\n`, "utf8"));
+		} catch (error) {
+			// Reopening rechecks the tail even if rollback itself failed.
+			try {
+				closeAppendFd({ flush: false });
+			} catch (closeError) {
+				throw new AggregateError([error, closeError], "session JSONL append and close failed");
+			} finally {
+				scheduleFsync();
+			}
+			throw error;
+		}
 		scheduleFsync();
 	}
 
@@ -747,7 +826,7 @@ function createWriter(
 		},
 		async persistTree(): Promise<void> {
 			// Checkpoint: make appended lines durable alongside the tree.
-			if (appendFd !== null) fsyncSync(appendFd);
+			flushPendingAppends();
 			// `paths` was resolved at construction, but atomicWrite mkdirs the
 			// session directory again, so an uninstall that has already removed the
 			// state root would be undone here. Fsyncing the held fd first is safe
@@ -756,7 +835,7 @@ function createWriter(
 			atomicWrite(paths.tree, JSON.stringify(tree, null, 2));
 		},
 		flushAppends(): void {
-			if (appendFd !== null) fsyncSync(appendFd);
+			flushPendingAppends();
 		},
 		async close(): Promise<void> {
 			if (closed) return;
@@ -827,7 +906,10 @@ export function openSession(id: string): ClioSessionReader {
 	};
 }
 
-export function resumeSession(id: string): {
+export function resumeSession(
+	id: string,
+	options: { sessionFormatVersion?: number } = {},
+): {
 	meta: ClioSessionMeta;
 	writer: ClioSessionWriter;
 	tree: ReadonlyArray<SessionTreeNode>;
@@ -835,13 +917,20 @@ export function resumeSession(id: string): {
 	const dir = findSessionDir(id);
 	const metaPath = join(dir, "meta.json");
 	const meta = readMetaFile(metaPath);
-	// resume reopens an active session; clear endedAt if it was set by a prior close
-	if (meta.endedAt !== null) {
-		meta.endedAt = null;
-		atomicWrite(metaPath, JSON.stringify(meta, null, 2));
-	}
 	const existingFileEntries = readSessionFileEntries(join(dir, "current.jsonl"));
 	const existingTree = recoverTreeFromJsonl(readTreeFile(join(dir, "tree.json")), existingFileEntries);
 	const writer = createWriter(meta, existingTree, existingFileEntries);
+	// Prepare headerless ledgers before publishing that a closed session has
+	// reopened. A failed normalization must preserve its prior ended state.
+	// Reopening and a migration restamp are one atomic publication: a refused
+	// resume can never leave the session marked open under its old version.
+	const restamp = options.sessionFormatVersion;
+	const restamped = restamp !== undefined && meta.sessionFormatVersion !== restamp;
+	if (meta.endedAt !== null || restamped) {
+		const reopened = { ...meta, endedAt: null, ...(restamped ? { sessionFormatVersion: restamp } : {}) };
+		atomicWrite(metaPath, JSON.stringify(reopened, null, 2));
+		meta.endedAt = null;
+		if (restamped) meta.sessionFormatVersion = restamp;
+	}
 	return { meta, writer, tree: existingTree };
 }

package/src/engine/worker-runtime.ts

@@ -621,6 +621,9 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			correlationId: `worker-model-round-${workerModelRound}`,
 			toolResultMaxBytes: workerSettings.context.toolResultMaxBytes,
 			supportsImages: model.input.includes("image"),
+			// The admitted capability list, so the gateway calls only what the
+			// recipe declared: the same bound the attached schemas already honor.
+			allowedTools: input.allowedTools,
 			...(agentSkillPolicy ? { pendingSkillPolicy: agentSkillPolicy } : {}),
 		}),
 	});

package/src/entry/boot-options.ts

@@ -28,6 +28,8 @@ export interface BootOptions {
 	startupSettings?: Readonly<ClioSettings>;
 	/** `--with-panes` / `--no-panes`. The flag beats `panes.enabled` in both directions. */
 	panes?: "with" | "without";
+	/** Global `--autonomy <level>`: a one-session override for the interactive app; settings.yaml is untouched. */
+	autonomy?: AutonomyLevel;
 	headless?: {
 		prompt: string;
 		images?: ReadonlyArray<ImageContent>;

package/src/entry/orchestrator.ts

@@ -120,6 +120,7 @@ import {
 	isOrchestratorEligibleRuntime,
 	normalizeCostProvenance,
 	ProvidersDomainModule,
+	probeCapabilitiesForModel,
 	refineRuntimeTargetWithModelHints,
 	registerForegroundStream,
 	resolveEndpointCapacities,
@@ -603,6 +604,17 @@ function agentRoleToolWarnings(providers: ProvidersContract, settings: Readonly<
 			if (!status) continue;
 			const capabilities = resolveModelCapabilities(status, wireModelId, providers.knowledgeBase);
 			if (supportsAgentRoleTools(capabilities)) continue;
+			// A target that was never probed has reported nothing about this model:
+			// the flag is only the runtime's conservative floor. Dispatch admission
+			// probes the route itself before it refuses a worker.
+			const declared =
+				status.target.capabilities?.tools ?? providers.knowledgeBase?.lookup(wireModelId)?.entry.capabilities?.tools;
+			if (
+				declared === undefined &&
+				status.health.lastCheckAt === null &&
+				probeCapabilitiesForModel(status, wireModelId) === null
+			)
+				continue;
 			warnings.push(
 				`${role.label} model '${wireModelId}' on target '${targetId}' ${AGENT_ROLE_TOOLS_REQUIRED_REASON}. ` +
 					`Pick another model, or state the correction in a model-catalog.d entry if the provider's flag is wrong.`,
@@ -1184,7 +1196,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			createDispatchDomainModule({
 				getSettings: () => effectiveSettingsForDispatch?.(),
 				getProtectedArtifactState: () => protectedArtifactStateForDispatch?.() ?? { artifacts: [] },
-				autonomyOverride: options.headless?.autonomy !== undefined,
+				autonomyOverride: (options.headless?.autonomy ?? options.autonomy) !== undefined,
 				// The domain owns the durable journal here, not the dispatch
 				// tool's event registry: `/run`, a watchdog run, and a model
 				// dispatch all have to leave the same transcript behind, and only
@@ -1568,6 +1580,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	const resolveBaselineAutonomy = (): AutonomyLevel =>
 		effectiveSettingsForDispatch?.().safety.autonomy ??
 		options.headless?.autonomy ??
+		options.autonomy ??
 		(config?.get() ?? readSettings()).safety.autonomy ??
 		"auto-edit";
 	const resolveEffectiveAutonomy = (): AutonomyLevel => activeAcpSessionAutonomy ?? resolveBaselineAutonomy();
@@ -1726,6 +1739,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				})
 			: null;
 	registerAllTools(toolRegistry, {
+		termination,
 		captureWorkerContext: () => chat.captureWorkerContext?.() ?? null,
 		...(session
 			? {
@@ -1788,8 +1802,10 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// flag was keyed by the bare word, which wrote a top-level `autonomy` key
 	// nothing reads, so `run --autonomy full-auto` compiled and admitted at
 	// whatever settings.yaml said.
+	// The interactive `clio-coder --autonomy <level>` seeds the same override.
+	const startupAutonomy = options.headless?.autonomy ?? options.autonomy;
 	const sessionOverrides: SessionOverrides = new Map(
-		options.headless?.autonomy === undefined ? [] : [["safety.autonomy", options.headless.autonomy]],
+		startupAutonomy === undefined ? [] : [["safety.autonomy", startupAutonomy]],
 	);
 	// The effective view is derived by deep-cloning the saved snapshot, and it
 	// is read on the tool-admission hot path (every call resolves autonomy

package/src/interactive/chat-loop-policy.ts

@@ -14,5 +14,6 @@ export function normalizeRetrySettings(raw: RawRetrySettings): RetrySettings {
 		baseDelayMs: normalizeNonNegativeInteger(raw?.baseDelayMs, DEFAULT_RETRY_SETTINGS.baseDelayMs),
 		maxDelayMs: normalizeNonNegativeInteger(raw?.maxDelayMs, DEFAULT_RETRY_SETTINGS.maxDelayMs),
 		streamStallMs: normalizeNonNegativeInteger(raw?.streamStallMs, DEFAULT_RETRY_SETTINGS.streamStallMs),
+		firstTokenStallMs: normalizeNonNegativeInteger(raw?.firstTokenStallMs, DEFAULT_RETRY_SETTINGS.firstTokenStallMs),
 	};
 }

package/src/interactive/chat-loop.ts

@@ -345,8 +345,8 @@ export interface ChatLoop {
 	 * in-memory `state.messages` for a single bridge message carrying the
 	 * summary, and emit the standard summary notice. Used by `/context compact`
 	 * slash command so the next user turn ships only the bridge plus the new
-	 * text to the provider (slice 12.5b bug 4). Silent no-op when no session
-	 * or no compaction deps are wired; in both cases emits a user-visible
+	 * text to the provider. When no session or compaction dependencies are
+	 * wired, it skips compaction and emits a user-visible
 	 * notice so the `/context compact` handler does not have to mirror the logic.
 	 */
 	compact(instructions?: string): Promise<void>;
@@ -686,10 +686,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				(policy?.requests.length ?? 0) > 0)
 		) {
 			const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? undefined);
+			// A loaded skill that declares no tool narrowing arms no surface, yet its
+			// instructions are in context. Record it from the loading policy: an
+			// unknown selection would block every later compaction of this session.
 			const selection = next
 				? mainSkillContextState(entries, next)
-				: (policy?.loadedSkillNames.size ?? 0) > 0
-					? null
+				: policy !== undefined && policy.loadedSkillNames.size > 0
+					? mainSkillContextState(entries, policy)
 					: { version: 1 as const, activationRefs: [] };
 			const data = selection ?? { version: 1 as const, activationRefs: [], unknown: true as const };
 			if (JSON.stringify(data) !== JSON.stringify(latestSkillContextState(entries))) {
@@ -1289,6 +1292,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				images,
 				options.requestContinuation === true,
 				text,
+				options.display?.text,
 			);
 			// An interrupt was submitted while a run was active, so no caller drew
 			// it in the transcript; render it here, after the cancel notice and the

package/src/interactive/chat-panel.ts

@@ -12,7 +12,8 @@ import { codeInk } from "./renderers/code-ink.js";
 import { createMermaidMarkdownTransform } from "./renderers/mermaid.js";
 import { styleTaggedNotice } from "./renderers/notice.js";
 import { previewBudget, previewRows } from "./renderers/preview.js";
-import { formatRetryStatus } from "./renderers/retry-status.js";
+import { presentProviderError, providerErrorEvidence } from "./renderers/provider-error.js";
+import { renderRetryStatus } from "./renderers/retry-status.js";
 import {
 	canGroupObservation,
 	renderToolAwaitingApproval,
@@ -223,7 +224,12 @@ type AssistantSegment = TextSegment | ToolSegment | ErrorSegment | ThinkingSegme
  * A caller-rendered block receives the frame's transcript detail policy so a
  * block such as the operator's `!` bash row follows the same preset as the panel. Blocks that ignore it are unaffected.
  */
-type ReplayBlockRenderer = (width: number, detail: TranscriptDetailPolicy, unbounded?: boolean) => string[];
+type ReplayBlockRenderer = (
+	width: number,
+	detail: TranscriptDetailPolicy,
+	unbounded?: boolean,
+	terminalRows?: number,
+) => string[];
 
 type TranscriptEntry =
 	| { role: "user"; text: string; status?: () => UserTurnStatus }
@@ -460,7 +466,7 @@ function scopeTerminalErrorAfterSuccessfulTool(
 	const reason = terminalError.slice("[error] ".length);
 	const timedOut = /\b(?:timed?\s*out|timeout)\b/i.test(reason);
 	const modelFailure = timedOut
-		? "main model response timed out after successful tool result"
+		? `main model response timed out after successful tool result: ${reason}`
 		: `main model response failed after successful tool result: ${reason}`;
 	const detachedDispatchSucceeded = successfulTools.some(
 		(segment) =>
@@ -604,9 +610,9 @@ function renderTextSegmentLines(seg: TextSegment, width: number): string[] {
  * message text rather than plain markdown, so a failed turn is visibly a
  * failure. Each source line wraps to width and carries the error color.
  */
-function renderErrorSegmentLines(seg: ErrorSegment, width: number): string[] {
+function renderErrorSegmentLines(seg: ErrorSegment, width: number, unbounded: boolean): string[] {
 	const out: string[] = [];
-	for (const line of seg.text.split("\n")) {
+	for (const line of (unbounded ? providerErrorEvidence(seg.text) : presentProviderError(seg.text)).split("\n")) {
 		for (const wrapped of wrapTextWithAnsi(line, width)) {
 			out.push(`${RED_CRIT}${wrapped}${RESET}`);
 		}
@@ -813,7 +819,7 @@ function renderEntryLines(
 	terminalRows: number,
 ): string[] {
 	if (entry.role === "replayBlock") {
-		return entry.renderBlock(width, detail);
+		return entry.renderBlock(width, detail, unboundedToolBodies, terminalRows);
 	}
 	if (entry.role === "user") {
 		const contentWidth = Math.max(1, width - PROSE_GUTTER_WIDTH);
@@ -827,7 +833,7 @@ function renderEntryLines(
 		return rendered;
 	}
 	if (entry.role === "retryStatus") {
-		return wrapTextWithAnsi(formatRetryStatus(entry.status), width);
+		return renderRetryStatus(entry.status, width, detail, unboundedToolBodies, terminalRows);
 	}
 	if (entry.role === "worker") {
 		return renderWorkerEntryLines(entry.state, width, { detail, terminalRows, unbounded: unboundedToolBodies });
@@ -888,8 +894,13 @@ function renderEntryLines(
 			labeled = true;
 			continue;
 		}
-		const rendered =
-			seg.kind === "text" ? renderTextSegmentLines(seg, proseWidth) : renderErrorSegmentLines(seg, proseWidth);
+		let rendered =
+			seg.kind === "text"
+				? renderTextSegmentLines(seg, proseWidth)
+				: renderErrorSegmentLines(seg, proseWidth, unboundedToolBodies);
+		if (seg.kind === "error" && !unboundedToolBodies) {
+			rendered = previewRows(rendered, previewBudget(detail.errorRows, terminalRows), proseWidth);
+		}
 		if (rendered.length === 0) continue;
 		const isSkillSuggestion = seg.kind === "text" && findSkillSuggestionLine(seg) !== null;
 		if (!labeled && !isSkillSuggestion) {
@@ -1331,6 +1342,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 			for (const entry of transcript) {
 				if (entry.role === "assistant") {
 					for (const seg of entry.segments) {
+						if (seg.kind === "error") add("Provider or terminal error", () => providerErrorEvidence(seg.text).split("\n"));
 						if (seg.kind === "thinking" && seg.text) add("Thinking · supplied reasoning", () => seg.text.split("\n"));
 						if (seg.kind === "tool")
 							add(`${seg.name} · ${seg.id}`, () =>
@@ -1350,6 +1362,8 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 								),
 							);
 					}
+				} else if (entry.role === "retryStatus" && entry.status.errorMessage) {
+					add("Provider retry diagnostic", () => providerErrorEvidence(entry.status.errorMessage ?? "").split("\n"));
 				} else if (entry.role === "worker") {
 					add(`${entry.state.agentId} · worker ${entry.state.runId}`, () =>
 						renderWorkerEntryLines(entry.state, 120, { unbounded: true }),

package/src/interactive/chat-renderer.ts

@@ -1,5 +1,5 @@
 /**
- * Coalescing wrapper around chat events (slice 12.5d).
+ * Coalescing wrapper around chat events.
  *
  * Streaming responses fire text, thinking, and cumulative tool-result updates
  * at very high frequency. The TUI's per-event `requestRender()` call rebuilt the
@@ -53,12 +53,12 @@ import { wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
 import { toolResultPresentationText } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
-import { isSelfExplainingAbort, toolResultSummary } from "./chat-loop-messages.js";
+import { hasStructuredToolCall, isSelfExplainingAbort, toolResultSummary } from "./chat-loop-messages.js";
 import type { ChatPanel } from "./chat-panel.js";
 import { renderBranchSummaryEntry } from "./renderers/branch-summary.js";
 import { renderCompactionSummaryEntry } from "./renderers/compaction-summary.js";
 import { styleTaggedNotice } from "./renderers/notice.js";
-import { formatRetryStatus } from "./renderers/retry-status.js";
+import { renderRetryStatus } from "./renderers/retry-status.js";
 import { renderBashTranscriptExecution, renderToolResultOnly } from "./renderers/tool-execution.js";
 import {
 	classifyStreamEvent,
@@ -644,6 +644,7 @@ const LEADING_SYSTEM_REMINDER = /^\s*<system-reminder>[\s\S]*?<\/system-reminder
  */
 function replayedUserText(entry: MessageEntry): string {
 	const obj = payloadObject(entry.payload);
+	if (typeof obj?.displayText === "string" && obj.displayText.length > 0) return obj.displayText;
 	if (typeof obj?.operatorText === "string") return obj.operatorText;
 	let text = extractTurnText(entry.payload);
 	for (;;) {
@@ -823,7 +824,13 @@ function renderBashExecutionEntry(
 	);
 }
 
-function renderRetryStatusEntry(entry: CustomEntry, width: number): string[] {
+function renderRetryStatusEntry(
+	entry: CustomEntry,
+	width: number,
+	detail: TranscriptDetailPolicy,
+	unbounded: boolean,
+	terminalRows: number,
+): string[] {
 	const data = payloadObject(entry.data);
 	if (!data) return wrapTextWithAnsi(styleTaggedNotice("[retry] status"), width);
 	const rawPhase = data.phase;
@@ -848,7 +855,7 @@ function renderRetryStatusEntry(entry: CustomEntry, width: number): string[] {
 		...(typeof data.delayMs === "number" ? { delayMs: data.delayMs } : {}),
 		...(typeof data.seconds === "number" ? { seconds: data.seconds } : {}),
 	};
-	return wrapTextWithAnsi(formatRetryStatus(status), width);
+	return renderRetryStatus(status, width, detail, unbounded, terminalRows);
 }
 
 /**
@@ -868,8 +875,14 @@ function rendersCustomEntry(entry: CustomEntry): boolean {
 	return entry.display === true;
 }
 
-function renderCustomEntry(entry: CustomEntry, width: number): string[] {
-	if (entry.customType === "retryStatus") return renderRetryStatusEntry(entry, width);
+function renderCustomEntry(
+	entry: CustomEntry,
+	width: number,
+	detail: TranscriptDetailPolicy,
+	unbounded: boolean,
+	terminalRows: number,
+): string[] {
+	if (entry.customType === "retryStatus") return renderRetryStatusEntry(entry, width, detail, unbounded, terminalRows);
 	if (entry.customType === HANDOFF_SEED_CUSTOM_TYPE && isHandoffSeedData(entry.data)) {
 		return wrapTextWithAnsi(styleTaggedNotice(`[handoff] carried from session ${entry.data.fromSessionId}`), width);
 	}
@@ -1211,8 +1224,7 @@ export function buildReplayAgentMessagesFromTurns(
  * Rehydrate a chat panel from a persisted session's turn list. The
  * interactive layer calls this after /resume or /fork so the user sees the
  * prior transcript instead of a blank pane; without it, swapping the
- * session contract updated meta but left the visible chat untouched
- * (Row 51 and Row 52 on the Phase 12 ledger).
+ * session contract updated meta but left the visible chat untouched.
  *
  * Replays a structured SessionEntry stream. Compaction summaries, branch
  * summaries, bash executions, custom entries, and metadata entries are
@@ -1270,9 +1282,16 @@ export function rehydrateChatPanelFromTurns(
 							(message as { stopReason?: string; errorMessage?: string }).stopReason = failure.stopReason;
 							(message as { stopReason?: string; errorMessage?: string }).errorMessage = failure.errorMessage;
 						}
+						const stopReason = (message as { stopReason?: string }).stopReason;
+						const terminalFailure = stopReason === "error" || stopReason === "aborted" || stopReason === "length";
+						const continues = !terminalFailure && (stopReason === "toolUse" || hasStructuredToolCall(message));
+						// Tool-use messages continue this run. Settling before their tool rows
+						// exist can attach a Done receipt to an earlier visible failure.
+						// Keep incomplete replay pending until a terminal assistant arrives.
+						if (continues) chatPanel.applyEvent({ type: "message_start", message });
 						chatPanel.applyEvent({ type: "message_end", message });
 						runAssistantMessages.push(message);
-						chatPanel.applyEvent({ type: "agent_end", messages: runAssistantMessages });
+						if (!continues) chatPanel.applyEvent({ type: "agent_end", messages: runAssistantMessages });
 					}
 					break;
 				}
@@ -1348,7 +1367,10 @@ export function rehydrateChatPanelFromTurns(
 				break;
 			}
 			case "custom":
-				if (rendersCustomEntry(entry)) chatPanel.appendReplayBlock((width) => renderCustomEntry(entry, width));
+				if (rendersCustomEntry(entry))
+					chatPanel.appendReplayBlock((width, detail, unbounded, terminalRows = 40) =>
+						renderCustomEntry(entry, width, detail, unbounded === true || options.unboundedToolBodies === true, terminalRows),
+					);
 				break;
 			case "modelChange":
 				chatPanel.appendReplayBlock((width) => renderModelChangeEntry(entry, width));

package/src/interactive/clio-editor.ts

@@ -11,6 +11,7 @@ import { fitHintEntries } from "./overlay-frame.js";
 import { type PermissionInspectionHint, permissionHintEntries } from "./permission-hint.js";
 import type { ClioTheme } from "./theme/index.js";
 import { clioTheme, editorTheme, GLYPH, rule } from "./theme/index.js";
+import { fitIdentityLabel, formatTargetLabel, type TargetIdentity } from "./theme/labels.js";
 import type { TurnPreparationPhase } from "./turn-state.js";
 
 const REVERSE_VIDEO_BLANK = `${String.fromCharCode(27)}[7m ${String.fromCharCode(27)}[0m`;
@@ -26,8 +27,8 @@ function hasScrollIndicator(line: string): boolean {
 }
 
 export interface EditorChrome {
-	/** Target+model identity, e.g. `node-a·example-coder-model`. */
-	getModelLabel: () => string;
+	/** Raw route fields from presentation; startup/legacy labels remain opaque strings. */
+	getModelLabel: () => TargetIdentity | string;
 	/** Effective thinking level, e.g. `high` / `off`. */
 	getThinkingLabel: () => string;
 	/** Whether Enter currently targets the active Clio response. */
@@ -90,8 +91,15 @@ function styledThinkingHint(theme: ClioTheme, value: string): string {
 	}
 }
 
-function styledRailLabel(theme: ClioTheme, chrome: EditorChrome): string {
-	return `${theme.fg("dim", chrome.getModelLabel())} ${theme.fg("dim", "·")} ${styledThinkingHint(theme, chrome.getThinkingLabel())}`;
+function styledRailLabel(theme: ClioTheme, chrome: EditorChrome, width: number): string {
+	const thinking = styledThinkingHint(theme, chrome.getThinkingLabel());
+	const identity = chrome.getModelLabel();
+	const room = Math.max(1, width - visibleWidth(thinking) - 3);
+	const model =
+		typeof identity === "string"
+			? fitIdentityLabel(identity, room)
+			: formatTargetLabel(identity.targetId, identity.modelId, { width: room });
+	return `${theme.fg("dim", model)} ${theme.fg("dim", "·")} ${thinking}`;
 }
 
 function composerMode(chrome: EditorChrome, text: string): ComposerMode {
@@ -250,7 +258,7 @@ export class ClioEditor extends Editor {
 			lines[0] = rule(theme, safeWidth, {
 				left: mode,
 				leftToken: modeToken(mode),
-				right: styledRailLabel(theme, this.chrome),
+				right: styledRailLabel(theme, this.chrome, Math.max(1, safeWidth - visibleWidth(mode) - 5)),
 				fillToken: "frameStrong",
 				rightRaw: true,
 				rightTail: theme.style("frameStrong", "─", { bold: true }),