@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/interactive/chat-loop.ts

@@ -1,5 +1,7 @@
 import type { WorkerContextSnapshot } from "../domains/context/worker/contract.js";
 import { captureWorkerContext } from "../domains/context/worker/snapshot.js";
+import { replaceEngineMessages } from "../engine/agent.js";
+import { isLockedSynthesisFallbackOnly, lockedSynthesisRepromptMessages } from "../engine/loop-guard.js";
 /**
  * The chat loop: one turn's state machine.
  *
@@ -27,6 +29,7 @@ import {
 	skillSurfaceNames,
 	withModelSkillActivation,
 } from "../core/skill-activation.js";
+import { snapshotTurnConstraints, type TurnConstraints } from "../core/turn-constraints.js";
 import { clioStateDir } from "../core/xdg.js";
 import {
 	createMiddlewareToolChoiceControl,
@@ -201,6 +204,8 @@ export type ChatLoopEvent =
 	| ToolApprovalStateEvent;
 
 export interface ChatSubmitOptions {
+	/** Explicit host-owned task scope; never parsed from the prompt text. */
+	constraints?: TurnConstraints;
 	/** Presentation only; never part of the model message or persisted text. */
 	display?: { text: string; note: string };
 	/** Host-owned run identity, scoped to this submit and its internal continuations. */
@@ -298,6 +303,7 @@ export type SideQuestionOutcome =
 
 export interface ChatLoop {
 	submit(text: string, options?: ChatSubmitOptions): Promise<void>;
+	currentTurnConstraints?(): TurnConstraints | undefined;
 	steer(text: string): boolean;
 	queueFollowUp(text: string): boolean;
 	/**
@@ -398,6 +404,7 @@ export interface ChatLoop {
 }
 
 export interface CreateChatLoopDeps {
+	interactiveGuidance?: boolean;
 	getSettings: () => Readonly<ClioSettings>;
 	/**
 	 * The same effective autonomy level registry admission resolves, so the
@@ -416,7 +423,7 @@ export interface CreateChatLoopDeps {
 	session?: SessionContract;
 	/**
 	 * Prompt compiler. When wired, the session system prompt is compiled once
-	 * per session and written into `state.systemPrompt`; recompiles happen
+	 * per session and applied to Pi’s system transcript baseline; recompiles happen
 	 * only on explicit events (model/target change, safety-level change,
 	 * config hot-reload, session switch).
 	 *
@@ -513,6 +520,7 @@ export interface CreateChatLoopDeps {
 	 * tests omit it when memory is irrelevant.
 	 */
 	getMemorySection?: () => string;
+	getReadySkillCount?: () => number;
 	/** Structured, redacted task-bank export supplied only to an explicit context-handoff skill request. */
 	getTaskMemoryHandoffSource?: () => string;
 	/**
@@ -551,6 +559,8 @@ export interface CreateChatLoopDeps {
 	 * that an unattended run never spends. Defaults to true.
 	 */
 	isLatencySurface?: () => boolean;
+	/** An editor draft already owns the next foreground request. */
+	isPrewarmBusy?: () => boolean;
 	/** The session pre-warm round. Injectable for the same reason `runSideQuestion` is. */
 	runPrewarm?: typeof runPrewarmRound;
 	/**
@@ -751,6 +761,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
 		if (turnId) options.turnId = turnId;
 		if (state.currentPendingSkillPolicy) options.pendingSkillPolicy = state.currentPendingSkillPolicy;
+		if (state.currentTurnConstraints) options.turnConstraints = state.currentTurnConstraints;
 		if (state.currentAskUserPolicy) options.askUserPolicy = state.currentAskUserPolicy;
 		return options;
 	};
@@ -786,6 +797,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	}
 
 	const context = createTurnContext({
+		interactiveGuidance: deps.interactiveGuidance === true,
 		state,
 		getSettings: deps.getSettings,
 		providers: deps.providers,
@@ -797,6 +809,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		readSessionEntries: deps.readSessionEntries,
 		autoCompact: deps.autoCompact,
 		getMemorySection: deps.getMemorySection,
+		getReadySkillCount: deps.getReadySkillCount,
 		middleware,
 		emitNotice,
 	});
@@ -907,11 +920,15 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		| { ok: true; runtime: AgentRuntime; apiKey: string | undefined }
 		| { ok: false; reason: string };
 
-	const prepareOutOfTurnRound = async (inFlightRefusal: string, signal?: AbortSignal): Promise<OutOfTurnPreparation> => {
+	const prepareOutOfTurnRound = async (
+		inFlightRefusal: string,
+		signal?: AbortSignal,
+		silent = false,
+	): Promise<OutOfTurnPreparation> => {
 		if (state.streaming) return { ok: false, reason: inFlightRefusal };
 		let agentRuntime: AgentRuntime | null;
 		try {
-			agentRuntime = turnRuntime.ensureRuntime();
+			agentRuntime = turnRuntime.ensureRuntime({ silent });
 		} catch (err) {
 			return { ok: false, reason: err instanceof Error ? err.message : String(err) };
 		}
@@ -1025,13 +1042,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		bus: deps.bus,
 		...(deps.session ? { session: deps.session } : {}),
 		isLatencySurface: () => deps.isLatencySurface?.() !== false,
-		isTurnActive: () => turnActive,
+		isTurnActive: () => turnActive || deps.isPrewarmBusy?.() === true,
 		hasActiveDispatch: () => (deps.hasActiveDispatch ?? deps.hasAttachedDispatch)?.() === true,
 		prepareRuntime: async (signal) => {
 			// The same probe a submit awaits, so the pre-warm resolves the model the
 			// next turn will resolve rather than a stale catalog entry.
-			await turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
-			return prepareOutOfTurnRound("a turn is in flight", signal);
+			await turnRuntime.ensureLiveCapabilitiesForSelectedModel({ silent: true }).catch(() => {});
+			return prepareOutOfTurnRound("a turn is in flight", signal, true);
 		},
 		applySessionTools: (runtime) => {
 			runtime.agent.state.tools = resolveSessionTools(
@@ -1101,6 +1118,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 					}
 				}
 				if (!interrupted) {
+					if (options.constraints !== undefined) {
+						emitAdmissionNotice(
+							"A submission with explicit task constraints must start a fresh turn; wait for settlement or interrupt the active run.",
+							"constrained-turn-in-flight",
+						);
+						return;
+					}
 					const hasImages = options.images !== undefined && options.images.length > 0;
 					if (!hasImages && trimmed.length > 0 && state.runtime) {
 						// Enter while streaming means "correct it now": the engine
@@ -1120,6 +1144,8 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				}
 			}
 
+			state.currentTurnConstraints =
+				options.requestContinuation === true ? state.currentTurnConstraints : snapshotTurnConstraints(options.constraints);
 			const previousRunSnapshot = state.lastRunSnapshot;
 			let agentRuntime: AgentRuntime | null;
 			try {
@@ -1145,7 +1171,8 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			middlewareToolChoice.reset();
 			if (options.requestContinuation !== true) state.stalledTurnNudgeSpent = false;
 			const images = options.images && options.images.length > 0 ? [...options.images] : undefined;
-			const pendingSkillRequests = options.pendingSkillRequests ?? [];
+			const pendingSkillRequests =
+				state.currentTurnConstraints?.skills === "disabled" ? [] : (options.pendingSkillRequests ?? []);
 			context.addWorkingContextPaths(options.workingContextPaths ?? []);
 			// A skill the operator activated narrows the tools for the workflow
 			// it started, and that workflow outlives the turn it began in. A
@@ -1153,7 +1180,8 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// armed surface is what this turn runs under.
 			const pendingSkillPolicy = withModelSkillActivation(
 				createPendingSkillToolPolicy(pendingSkillRequests) ?? state.activeSkillSurface,
-				modelMayActivateSkills(deps.getAutonomy?.() ?? deps.getSettings().safety.autonomy),
+				state.currentTurnConstraints?.skills !== "disabled" &&
+					modelMayActivateSkills(deps.getAutonomy?.() ?? deps.getSettings().safety.autonomy),
 			);
 			// What was already loaded when this turn started, so the settle-time
 			// notice names the skills this turn activated and not the ones a
@@ -1362,6 +1390,24 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			state.currentAskUserPolicy = askUserPolicy;
 			try {
 				await queues.markPersistedUserEcho(runtimePromptText, () => agentRuntime.agent.prompt(runtimePromptText, images));
+				if (
+					state.synthesisToolLock &&
+					state.activeInterruptReason === null &&
+					isLockedSynthesisFallbackOnly(agentRuntime.agent.state.messages.at(-1))
+				) {
+					// Deliver the pair atomically. The normal follow-up queue drains one
+					// message at a time; queuing these separately creates an extra round
+					// with an unanswered synthetic tool call.
+					emitNotice("[Clio Coder] Recovering a final answer once; tools remain disabled.");
+					const model = agentRuntime.agent.state.model;
+					await agentRuntime.agent.prompt([
+						...lockedSynthesisRepromptMessages(1, {
+							provider: model.provider,
+							api: model.api,
+							model: model.id,
+						}),
+					]);
+				}
 				// pi-agent-core does NOT throw on provider failures:
 				// it pushes an assistant message with stopReason="error" and
 				// errorMessage="<provider text>" onto state.messages, sets
@@ -1533,11 +1579,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		},
 
 		contextUsage: () => context.contextUsage(),
+		currentTurnConstraints: () => state.currentTurnConstraints,
 		contextLedger: () => context.contextLedger(),
 		whenSettled: () => activeSubmit,
 		whenPrewarmSettled: () => prewarm.settled(),
 
 		resetForSession(leafTurnId: string | null, replayMessages?: ReadonlyArray<AgentMessage>): void {
+			state.currentTurnConstraints = undefined;
 			if (state.runtime) {
 				state.runtime.agent.abort();
 				(state.runtime.agent as { clearAllQueues?: () => void } | undefined)?.clearAllQueues?.();
@@ -1558,7 +1606,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
 			state.replayedContextMessages = replayMessages ? [...replayMessages] : [];
 			if (state.runtime) {
-				state.runtime.agent.state.messages = [...state.replayedContextMessages];
+				replaceEngineMessages(state.runtime.agent, [...state.replayedContextMessages]);
 			}
 			if (deps.protectedArtifacts) {
 				reloadProtectedArtifactsForSession(deps.protectedArtifacts, deps.readSessionEntries);
@@ -1721,6 +1769,8 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	// released at admission, not settlement, so steering stays immediate.
 	let admissionTail: Promise<void> | null = null;
 	api.submit = (text, options = {}) => {
+		const constraints = snapshotTurnConstraints(options.constraints);
+		options = { ...options, ...(constraints === undefined ? {} : { constraints }) };
 		// Capture before admission can await. Internal resubmits inherit the
 		// async scope; every independent public submit explicitly starts its own.
 		const hostRun = options.hostRun === undefined ? undefined : structuredClone(options.hostRun);

package/src/interactive/chat-panel.ts

@@ -16,6 +16,7 @@ import { presentProviderError, providerErrorEvidence } from "./renderers/provide
 import { renderRetryStatus } from "./renderers/retry-status.js";
 import {
 	canGroupObservation,
+	renderToolArguments,
 	renderToolAwaitingApproval,
 	renderToolExecution,
 	renderToolPreview,
@@ -836,7 +837,7 @@ function renderEntryLines(
 		return renderRetryStatus(entry.status, width, detail, unboundedToolBodies, terminalRows);
 	}
 	if (entry.role === "worker") {
-		return renderWorkerEntryLines(entry.state, width, { detail, terminalRows, unbounded: unboundedToolBodies });
+		return renderWorkerEntryLines(entry.state, width, { detail, terminalRows, unbounded: unboundedToolBodies, nowMs });
 	}
 	// A settled assistant entry that rendered nothing at all contributes nothing.
 	// A mid-turn notice splits the transcript, so the events after it open a
@@ -874,6 +875,13 @@ function renderEntryLines(
 			}
 			if (count > 1) {
 				lines.push(dimLine(`✓ ${kind === "read" ? `Read ${count} files` : `${count} ${kind} actions`} · /view`, width));
+				for (let offset = 0; offset < count; offset++) {
+					const grouped = entry.segments[segIndex + offset];
+					if (grouped?.kind === "tool")
+						lines.push(
+							...renderToolArguments(grouped.args, width, false, previewBudget(detail.invocationRows, terminalRows)),
+						);
+				}
 				segIndex += count - 1;
 			} else lines.push(...renderToolSegmentLines(seg, width, nowMs, unboundedToolBodies, detail, terminalRows));
 			continue;
@@ -1186,6 +1194,7 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				// only thinking still needs the time-keyed render key.
 			) ||
 				(entry.pending && openThinkingSegment(entry)?.startedAtMs !== undefined))) ||
+		(entry.role === "worker" && entry.state.pending && entry.state.startedAtMs !== undefined) ||
 		(entry.role === "replayBlock" && entry.isLive?.() === true) ||
 		(entry.role === "user" && (entry.status?.() ?? "committed") !== "committed");
 

package/src/interactive/clio-editor.ts

@@ -7,19 +7,19 @@ import {
 	visibleWidth,
 } from "../engine/tui.js";
 import { guardPastedEditorOperator } from "./editor-bash.js";
+import { type EditorRailState, renderEditorRail } from "./editor-rails.js";
 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 { clioTheme, editorTheme, GLYPH } from "./theme/index.js";
+import 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`;
 const EMPTY_PROMPT = "Ask Clio…  / for commands";
 const CONFIRM_PROMPT = "A parked call is waiting for your decision";
 const PREPARING_PROMPT = "Clio has your prompt and is preparing the turn";
-const COMPACTING_PROMPT = "Clio has your prompt and is compacting the context first";
-const MIN_HINT_WIDTH = 60;
+const COMPACTING_PROMPT = "Clio is compacting the session context";
 
 function hasScrollIndicator(line: string): boolean {
 	const stripped = stripTerminalSequences(line);
@@ -31,6 +31,10 @@ export interface EditorChrome {
 	getModelLabel: () => TargetIdentity | string;
 	/** Effective thinking level, e.g. `high` / `off`. */
 	getThinkingLabel: () => string;
+	/** Effective session autonomy, including live overrides. */
+	getAutonomy?: () => string;
+	/** Monotonic animation clock, injectable for deterministic rendering tests. */
+	getAnimationTime?: () => number;
 	/** Whether Enter currently targets the active Clio response. */
 	isStreaming?: () => boolean;
 	/**
@@ -63,45 +67,6 @@ export interface EditorChrome {
 
 type ComposerMode = "MESSAGE" | "FOLLOW-UP" | "STEER" | "CONFIRM" | "PREPARING" | "COMPACTING";
 
-function normalizeThinkingHint(value: string): string {
-	return value
-		.replace(/^think\s+/i, "")
-		.trim()
-		.toLowerCase();
-}
-
-// The thinking-level hint reads on a two-step color scale that survives
-// squinting: `off` is dim, the low band (`minimal`/`low`) is muted, and
-// everything from `medium` up carries the reason token, going bold for the
-// top band (`xhigh`/`max`, and the generic `on`).
-function styledThinkingHint(theme: ClioTheme, value: string): string {
-	const hint = normalizeThinkingHint(value);
-	switch (hint) {
-		case "off":
-			return theme.fg("dim", hint);
-		case "minimal":
-		case "low":
-			return theme.fg("muted", hint);
-		case "xhigh":
-		case "max":
-		case "on":
-			return theme.style("reason", hint, { bold: true });
-		default:
-			return theme.fg("reason", hint);
-	}
-}
-
-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 {
 	if (chrome.isAwaitingApproval?.() ?? false) return "CONFIRM";
 	if (!(chrome.isStreaming?.() ?? false)) {
@@ -117,13 +82,6 @@ function composerMode(chrome: EditorChrome, text: string): ComposerMode {
 	return willSteer ? "STEER" : "FOLLOW-UP";
 }
 
-function lowerRailHint(theme: ClioTheme, chrome: EditorChrome): string {
-	return theme.fg(
-		"dim",
-		`${chrome.getSubmitKeyLabel?.() ?? "Enter"} send · ${chrome.getNewlineKeyLabel?.() ?? "Ctrl+J"} newline`,
-	);
-}
-
 /**
  * The permission keys on the composer rail, fitted like the dialog footer so
  * both surfaces narrow in the same order and never drop allow or stop first.
@@ -247,22 +205,37 @@ export class ClioEditor extends Editor {
 		const safeWidth = Math.max(0, width);
 		const text = this.getText();
 		const mode = composerMode(this.chrome, text);
-
-		if (hasScrollIndicator(lines[0] ?? "")) {
-			// The base editor has already fitted the scroll indicator to this width.
-			// Prefix the mode and trim only the indicator rail's trailing fill, keeping
-			// its direction/count text and its own narrow-width fallback intact.
-			const modeLabel = theme.style(modeToken(mode), mode, { bold: true });
-			lines[0] = truncateToWidth(`${modeLabel} ${lines[0] ?? ""}`, safeWidth, "", true);
-		} else {
-			lines[0] = rule(theme, safeWidth, {
-				left: mode,
-				leftToken: modeToken(mode),
-				right: styledRailLabel(theme, this.chrome, Math.max(1, safeWidth - visibleWidth(mode) - 5)),
-				fillToken: "frameStrong",
-				rightRaw: true,
-				rightTail: theme.style("frameStrong", "─", { bold: true }),
-			});
+		const rail: EditorRailState = {
+			phase: mode === "CONFIRM" ? "attention" : mode === "MESSAGE" ? "idle" : "working",
+			fullAuto: this.chrome.getAutonomy?.() === "full-auto",
+			animate:
+				text.length === 0 &&
+				process.env.CLIO_CODER_REDUCE_MOTION !== "1" &&
+				process.env.CLIO_CODER_SCREEN_READER !== "1" &&
+				process.env.TERM !== "dumb" &&
+				process.env.NO_COLOR === undefined,
+			now: this.chrome.getAnimationTime?.() ?? performance.now(),
+		};
+
+		// Normal composition needs no mode or model label on the input rail.
+		// Keep exceptional admission/permission states and native scroll counts.
+		if (!hasScrollIndicator(lines[0] ?? "")) {
+			const exceptional = mode === "CONFIRM" || mode === "PREPARING" || mode === "COMPACTING";
+			lines[0] = renderEditorRail(
+				theme,
+				safeWidth,
+				{
+					...(exceptional
+						? {
+								left: rail.fullAuto ? `${mode} · FULL-AUTO` : mode,
+								leftToken: rail.fullAuto ? ("editorDanger" as const) : modeToken(mode),
+							}
+						: rail.fullAuto
+							? { left: "FULL-AUTO", leftToken: "editorDanger" as const }
+							: {}),
+				},
+				rail,
+			);
 		}
 
 		if (text.length === 0 && lines[1]) {
@@ -273,21 +246,20 @@ export class ClioEditor extends Editor {
 		// The confirm keys render at every width: the send hint is a convenience
 		// that a narrow composer can drop, the allow and deny keys are not.
 		if (bottomRail >= 0 && mode === "CONFIRM") {
-			lines[bottomRail] = rule(theme, safeWidth, {
-				right: confirmRailHint(theme, safeWidth, text.length > 0, this.chrome.getPermissionInspection?.() ?? "none"),
-				fillToken: "frameStrong",
-				rightRaw: true,
-				rightTail: theme.style("frameStrong", "─", { bold: true }),
-			});
-		} else if (bottomRail >= 0 && safeWidth >= MIN_HINT_WIDTH) {
-			lines[bottomRail] = rule(theme, safeWidth, {
-				right: lowerRailHint(theme, this.chrome),
-				fillToken: "frameStrong",
-				rightRaw: true,
-				rightTail: theme.style("frameStrong", "─", { bold: true }),
-			});
+			lines[bottomRail] = renderEditorRail(
+				theme,
+				safeWidth,
+				{
+					right: confirmRailHint(theme, safeWidth, text.length > 0, this.chrome.getPermissionInspection?.() ?? "none"),
+					fillToken: "editor",
+					rightRaw: true,
+					rightTail: theme.style("editor", "─", { bold: true }),
+				},
+				rail,
+			);
 		}
 
+		if (bottomRail >= 0 && mode !== "CONFIRM") lines[bottomRail] = renderEditorRail(theme, safeWidth, {}, rail);
 		return lines;
 	}
 

package/src/interactive/context-meter.ts

@@ -12,6 +12,7 @@ import { type ClioTheme, type ClioToken, clioTheme, GLYPH } from "./theme/index.
 export const CONTEXT_CATEGORY_TOKEN: Readonly<Record<ContextLedgerCategory, ClioToken>> = {
 	system: "info",
 	tools: "warning",
+	toolResults: "tool",
 	agents: "reason",
 	skills: "success",
 	memory: "error",

package/src/interactive/context-overlay.ts

@@ -5,7 +5,7 @@ import type { SafeEventBus } from "../core/event-bus.js";
 import type { WorkingSetView } from "../domains/context/working-set/contract.js";
 import { formatContextWindowSlots } from "../domains/providers/index.js";
 import type { ContextLedger, ContextLedgerGroup } from "../domains/session/context-ledger.js";
-import { type OverlayHandle, Text, type TUI, visibleWidth } from "../engine/tui.js";
+import { type OverlayHandle, Text, type TUI, truncateToWidth, visibleWidth } from "../engine/tui.js";
 import { contextCategorySwatch, renderContextMeterGrid, renderEvictedTokensLine } from "./context-meter.js";
 import { buildHint, showClioOverlayFrame } from "./overlay-frame.js";
 import { abbreviateModelId, type ClioToken, clioTheme, formatContextPercent } from "./theme/index.js";
@@ -78,8 +78,8 @@ function legendRow(group: ContextLedgerGroup, contentWidth: number): string {
 	const percent = formatContextPercent(group.percent);
 	const right = `${tokens.padStart(9)}  ${percent.padStart(6)}`;
 	const labelToken: ClioToken = group.category === "reserve" ? "frame" : group.category === "free" ? "dim" : "muted";
-	const leftWidth = Math.max(0, contentWidth - visibleWidth(right) - 2);
-	const labelText = group.label.length > leftWidth ? group.label.slice(0, leftWidth) : group.label.padEnd(leftWidth);
+	const leftWidth = Math.max(0, contentWidth - visibleWidth(right) - visibleWidth(swatch) - 2);
+	const labelText = truncateToWidth(group.label, leftWidth, "", true);
 	return `${swatch} ${theme.fg(labelToken, labelText)} ${theme.fg("muted", right)}`;
 }
 
@@ -187,7 +187,7 @@ function renderContextLedgerLines(
 	lines.push("");
 
 	if (ledger.contextWindow > 0) {
-		const source = ledger.measured ? "measured" : "≈ estimated";
+		const source = ledger.measured ? "provider-anchored total · estimated splits" : "≈ estimated";
 		// `196,608 (786,432 / 4 slots)`: a llama.cpp window that is one slot's
 		// share of the server's KV budget names the split, because the bare
 		// number reads as the whole server and the meter is measured against
@@ -231,7 +231,7 @@ function renderContextLedgerLines(
 	if (ledger.promptCache) {
 		const cache = ledger.promptCache;
 		const shell = cache.shellReused ? "shell reused" : "shell recompiled";
-		const backendCacheReadsUnknown = cache.backend?.cachedTokens === null;
+		const backendCacheReadsUnknown = cache.backendVerdict === "unknown" || cache.backend?.cachedTokens === null;
 		const backend = backendCacheReadsUnknown
 			? "server does not report cache reads"
 			: cache.backendVerdict === "hot" || cache.backendVerdict === "partial"
@@ -268,7 +268,7 @@ function renderContextLedgerLines(
 		}
 		if (coldReasons.length > 0) {
 			const reasons = coldReasons.map(coldReasonLabel).join(", ");
-			lines.push(theme.fg("dim", `last cold turn: ${reasons} (expected)`));
+			lines.push(theme.fg("dim", `last cache-affecting events: ${reasons} (reuse measured separately)`));
 		}
 	}
 
@@ -319,15 +319,28 @@ export function openContextOverlay(
 	getLedger: () => ContextLedger,
 	options?: OpenContextOverlayOptions,
 ): OverlayHandle {
+	let contentWidth = DEFAULT_CONTENT_WIDTH;
 	const render = (): string =>
 		renderContextLedgerLines(
 			getLedger(),
-			DEFAULT_CONTENT_WIDTH,
+			contentWidth,
 			options?.getWorkingSet?.() ?? null,
 			options?.getWorkingSetConfig?.() ?? null,
 		).join("\n");
 	const text = new Text(render(), 0, 0);
-	const handle = showClioOverlayFrame(tui, text, {
+	const body = {
+		render(width: number): string[] {
+			if (width !== contentWidth) {
+				contentWidth = width;
+				text.setText(render());
+			}
+			return text.render(width);
+		},
+		invalidate(): void {
+			text.invalidate();
+		},
+	};
+	const handle = showClioOverlayFrame(tui, body, {
 		anchor: "center",
 		width: CONTEXT_OVERLAY_WIDTH,
 		markerId: "context-view",

package/src/interactive/cost-overlay.ts

@@ -227,7 +227,7 @@ function summaryBlock(
 					] as const,
 					[
 						"cache verdicts",
-						`hot ${promptCache.verdictCounts.hot} · partial ${promptCache.verdictCounts.partial} · cold ${promptCache.verdictCounts.cold} · small ${promptCache.verdictCounts.small}`,
+						`hot ${promptCache.verdictCounts.hot} · partial ${promptCache.verdictCounts.partial} · cold ${promptCache.verdictCounts.cold} · small ${promptCache.verdictCounts.small} · unknown ${promptCache.verdictCounts.unknown}`,
 					] as const,
 				]
 			: [];

package/src/interactive/dispatch-board.ts

@@ -45,6 +45,7 @@ import {
 	spinnerFrame,
 } from "./theme/index.js";
 import { fitIdentityLabel } from "./theme/labels.js";
+import { isHelperRun } from "./worker-stream.js";
 
 export type DispatchBoardStatus = ObservabilityRunSummary["status"];
 
@@ -110,7 +111,7 @@ export interface DispatchBoardRow {
 	failoverHops?: number;
 	/** Model context window for the per-worker context meter. */
 	contextWindow?: number;
-	/** Last assistant message's input+cacheRead+output: current context occupancy. */
+	/** Last assistant message's input+cacheRead+cacheWrite+output: current context occupancy. */
 	lastContextTokens?: number;
 	/** Tool currently executing in the worker; null between calls. Projected from `progress`. */
 	currentTool?: string | null;
@@ -484,6 +485,34 @@ function progressActionLine(theme: ClioTheme, progress: WorkerProgressSnapshot,
 	return cardUnitsLine(theme, "doing", units, contentWidth);
 }
 
+/** Live dashboard detail shares the board's redacted actions and contract-aware answer rendering. */
+export function renderDispatchActivity(row: DispatchBoardRow, width: number): string[] {
+	const theme = clioTheme();
+	const progress = row.progress;
+	if (!progress) return [];
+	const lines: string[] = [];
+	const phase = {
+		starting: "Starting worker",
+		thinking: "Thinking",
+		writing: "Streaming response",
+		tool: "Executing tool",
+		waiting: "Between tool calls · awaiting next worker event",
+		settled: "Worker output finished",
+	}[progress.phase];
+	lines.push(...wrapTextWithAnsi(`${theme.style("agent", "Now", { bold: true })}  ${phase}`, width));
+	if (progress.currentAction)
+		lines.push(...wrapTextWithAnsi(`  → ${sanitizeCallTargetText(actionPhrase(progress.currentAction))}`, width));
+	for (const action of progress.recentActions.slice(0, 3))
+		lines.push(
+			...wrapTextWithAnsi(`${theme.fg("dim", "Recent")}  ${sanitizeCallTargetText(actionPhrase(action))}`, width),
+		);
+	if (progress.tailText.trim()) {
+		lines.push(theme.fg("dim", progress.settled ? "Worker output" : "Live response · provisional"));
+		lines.push(...progressAnswerLines(theme, progress, row.runId, width, row.resultContract, 3));
+	}
+	return lines;
+}
+
 /**
  * The `answer` block: the newest rows of the worker's bounded prose on a rail,
  * then what is not shown and where to read it. Wrapping happens before the row
@@ -497,6 +526,7 @@ function progressAnswerLines(
 	runId: string,
 	contentWidth: number,
 	contract: ObservabilityRunSummary["resultContract"],
+	maxRows = WORKER_PROGRESS_CARD_ROWS,
 ): string[] {
 	if (progress.tailText.length === 0) return [];
 	const gutter = CARD_KV_KEY_WIDTH + 1;
@@ -514,9 +544,7 @@ function progressAnswerLines(
 	for (const line of source) {
 		for (const row of wrapTextWithAnsi(sanitizeCallTargetText(line), railWidth)) wrapped.push(row);
 	}
-	const shown = progress.settled
-		? wrapped.slice(0, WORKER_PROGRESS_CARD_ROWS)
-		: wrapped.slice(Math.max(0, wrapped.length - WORKER_PROGRESS_CARD_ROWS));
+	const shown = progress.settled ? wrapped.slice(0, maxRows) : wrapped.slice(Math.max(0, wrapped.length - maxRows));
 	const hiddenRows = wrapped.length - shown.length;
 	const rail = theme.fg("dim", `${GLYPH.rail} `);
 	const body = shown.map((row) => `${rail}${theme.fg("muted", row)}`);
@@ -810,8 +838,10 @@ function renderTaskIslandRow(row: DispatchBoardRow, width: number): string[] {
 		? `  ${theme.fg("warning", `attempt ${row.retry.attempt}`)}${dot}${theme.fg("muted", retryCountdown(row.retry))}`
 		: `  ${up}${dot}${down}${dot}${theme.fg("muted", cost)}`;
 	const task = row.taskSummary
-		? `  ${theme.fg("muted", truncateToWidth(row.taskSummary, Math.max(1, width - 2), "…", false))}`
-		: null;
+		? wrapTextWithAnsi(row.taskSummary, Math.max(1, width - 2))
+				.slice(0, 3)
+				.map((line) => `  ${theme.fg("muted", line)}`)
+		: [];
 
 	const quality = isTerminalStatus(row.status)
 		? wrapTextWithAnsi(
@@ -822,8 +852,9 @@ function renderTaskIslandRow(row: DispatchBoardRow, width: number): string[] {
 	return [
 		padAnsi(line1, width),
 		...quality.map((line) => padAnsi(theme.fg("muted", line), width)),
-		...(task ? [padAnsi(task, width)] : []),
+		...task.map((line) => padAnsi(line, width)),
 		padAnsi(telemetry, width),
+		...wrapTextWithAnsi(theme.fg("dim", `  /view dispatch:${row.runId}`), width),
 	];
 }
 
@@ -1082,7 +1113,7 @@ export function createDispatchBoardView(
 export function formatTaskIslandLines(rows: ReadonlyArray<DispatchBoardRow>, maxRows = 4): string[] {
 	// Councils are folded before the row cap, so a five-member council costs the
 	// island one card and never crowds out the runs beside it.
-	const items = dispatchBoardItems(rows);
+	const items = dispatchBoardItems(rows.filter((row) => !isHelperRun(row)));
 	const visibleItems = items.slice(0, Math.max(1, maxRows));
 	const body: string[] = [];