@iowarp/clio-coder 0.3.3 → 0.3.6

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

@@ -7,6 +7,13 @@
 
 import { randomUUID } from "node:crypto";
 import { settingsPath } from "../core/config.js";
+import {
+	addResponseModelIdObservationCount,
+	emptyResponseModelIdObservationCounts,
+	type ResponseModelIdObservation,
+	type ResponseModelIdObservationCounts,
+	responseModelIdObservationFromRecord,
+} from "../core/response-model-id.js";
 import type { PendingSkillRequest, PendingSkillToolPolicy, SkillDeclaredToolPolicy } from "../core/skill-activation.js";
 import { ToolNames } from "../core/tool-names.js";
 import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
@@ -334,6 +341,7 @@ export function createAskUserToolPolicy(activeTools: ReadonlyArray<{ name: strin
 		status: "idle",
 		startedAt: now,
 		updatedAt: now,
+		exposure: "local",
 		rounds: [],
 		decisions: [],
 		inFlight: false,
@@ -356,6 +364,9 @@ export interface RunUsageSummary {
 	apiCalls: number;
 	hadReasoning: boolean;
 	hadUsage: boolean;
+	responseModelIdObservationCounts: ResponseModelIdObservationCounts;
+	lastResponseModelIdObservation: ResponseModelIdObservation;
+	lastDifferingResponseModelId: string | null;
 }
 
 /**
@@ -380,6 +391,9 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 		apiCalls: 0,
 		hadReasoning: false,
 		hadUsage: false,
+		responseModelIdObservationCounts: emptyResponseModelIdObservationCounts(),
+		lastResponseModelIdObservation: { state: "not-observed" },
+		lastDifferingResponseModelId: null,
 	};
 	for (const raw of messages) {
 		const message = raw as
@@ -397,8 +411,15 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 			  };
 		if (!message || typeof message !== "object") continue;
 		if (message.role !== "assistant") continue;
+		const record = message as unknown as Record<string, unknown>;
 		const usage = message.usage;
 		if (!usage || typeof usage !== "object") continue;
+		summary.lastResponseModelIdObservation = responseModelIdObservationFromRecord(record, "not-observed");
+		addResponseModelIdObservationCount(summary.responseModelIdObservationCounts, summary.lastResponseModelIdObservation);
+		summary.lastDifferingResponseModelId =
+			typeof record.responseModel === "string" && record.responseModel.trim().length > 0
+				? record.responseModel.trim()
+				: null;
 		summary.hadUsage = true;
 		summary.apiCalls += 1;
 		const input = typeof usage.input === "number" ? usage.input : 0;
@@ -459,6 +480,7 @@ export function assistantSessionPayload(
 	const raw = message as unknown as Record<string, unknown>;
 	if (Array.isArray(raw.content)) payload.content = raw.content;
 	if (thinking.length > 0) payload.thinking = thinking;
+	payload.responseModelIdObservation = responseModelIdObservationFromRecord(raw, "not-observed");
 	for (const key of ["usage", "api", "provider", "model", "responseModel", "responseId", "diagnostics"]) {
 		if (raw[key] !== undefined) payload[key] = raw[key];
 	}
@@ -555,21 +577,33 @@ export function toolResultSummary(result: unknown): Record<string, unknown> {
 	const bytes = Buffer.byteLength(text, "utf8");
 	const details = recordValue(obj?.details);
 	const size = recordValue(details?.resultSize);
+	const disposition = recordValue(details?.resultDisposition);
 	const truncation = recordValue(details?.truncation);
 	const observation = recordValue(details?.observation);
 	const offloadPath =
-		typeof observation?.offloadPath === "string"
-			? observation.offloadPath
-			: typeof size?.offloadPath === "string"
-				? size.offloadPath
-				: null;
+		typeof disposition?.offloadPath === "string"
+			? disposition.offloadPath
+			: typeof observation?.offloadPath === "string"
+				? observation.offloadPath
+				: typeof size?.offloadPath === "string"
+					? size.offloadPath
+					: null;
+	const displayedBytes =
+		typeof disposition?.displayedBytes === "number" && Number.isFinite(disposition.displayedBytes)
+			? disposition.displayedBytes
+			: bytes;
 	return {
-		bytes,
+		bytes: displayedBytes,
 		truncated:
+			disposition?.presentationTruncated === true ||
 			size?.truncated === true ||
 			truncation?.truncated === true ||
 			observation?.truncated === true ||
 			text.includes("[tool result truncated]"),
+		...(typeof disposition?.capturedBytes === "number" ? { capturedBytes: disposition.capturedBytes } : {}),
+		...(typeof disposition?.displayedBytes === "number" ? { displayedBytes: disposition.displayedBytes } : {}),
+		...(typeof disposition?.contextBytes === "number" ? { contextBytes: disposition.contextBytes } : {}),
+		...(disposition?.contextTruncated === true ? { contextTruncated: true } : {}),
 		...(typeof size?.policy === "string" ? { policy: size.policy } : {}),
 		...(typeof size?.followUpHint === "string" ? { followUpHint: size.followUpHint } : {}),
 		...(offloadPath !== null ? { offloadPath } : {}),

package/src/interactive/chat-loop.ts

@@ -549,6 +549,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emitNotice,
 		toolStartTimes,
 	});
+	// A fresh ledger and footer render before the first submit. Start the same
+	// live capability probe that submit and resume use so those boot surfaces
+	// refresh to the probed model window as soon as provider discovery lands.
+	// The turn runtime coalesces the first submit onto this request, then its
+	// target and model TTL keeps later submits from repeating it.
+	void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
 
 	// --- bus subscriptions --------------------------------------------------
 
@@ -664,6 +670,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// 1. Accept the prompt: reset per-turn accounting, freeze the tool
 			// surface, fire turn_start, and assemble the submitted text.
 			state.turnToolCalls = 0;
+			state.turnToolNames = [];
 			state.turnSharedWorkerNote = isWorkerShareNote(text);
 			middlewareToolChoice.reset();
 			if (options.requestContinuation !== true) state.stalledTurnNudgeSpent = false;
@@ -988,6 +995,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			middlewareToolChoice.reset();
 			state.lastTurnId = leafTurnId;
 			context.resetForSession();
+			// The resumed ledger renders before the first new turn (issue #189),
+			// and the window it renders against should be the probed one rather
+			// than the catalog's, so the live capability probe the first submit
+			// would run runs now, under the same TTL; the footer refreshes on the
+			// provider-health event the probe publishes.
+			void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
 			state.replayedContextMessages = replayMessages ? [...replayMessages] : [];
 			if (state.runtime) {
 				state.runtime.agent.state.messages = [...state.replayedContextMessages];

package/src/interactive/chat-panel.ts

@@ -5,6 +5,7 @@ import { rawDurationMs } from "../core/timers.js";
 import { type Component, Markdown, truncateToWidth, wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
 import { toolPresentationPolicy } from "../tools/presentation.js";
+import { toolResultPresentationPolicy } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
 import { extractText, isSelfExplainingAbort } from "./chat-loop-messages.js";
 import type { ApprovalRequestView } from "./permission-overlay.js";
@@ -202,6 +203,12 @@ type ToolSegment = {
 	 * was refused and leaves the operator no way to learn why.
 	 */
 	blockReason?: string | undefined;
+	/**
+	 * Working-set eviction reason for a replayed result whose body the
+	 * projection has replaced. Set only on rehydrate, from the folded ledger;
+	 * a live call is never evicted while it is still being rendered.
+	 */
+	evictedReason?: string | undefined;
 	/** View-only marker: historical calls render mutation diffs without live color. */
 	replayed?: true;
 };
@@ -835,7 +842,7 @@ function styleStatusVerb(text: string, toneHint: VerbRender["toneHint"]): string
 function policySegmentFold(seg: ToolSegment, detail: TranscriptDetailPolicy): Fold {
 	if (!seg.finished) return policyRunningToolFold(detail);
 	if (seg.isError && detail.errors === "body") return "expanded";
-	return policyToolFold(detail, toolPresentationPolicy(seg.name, seg.args));
+	return policyToolFold(detail, toolResultPresentationPolicy(seg.result) ?? toolPresentationPolicy(seg.name, seg.args));
 }
 
 /** Effective state of a tool segment: the operator's override, else the policy. */
@@ -884,6 +891,7 @@ function renderToolSegmentLines(
 						resultSummary: seg.resultSummary,
 						outcome: seg.settlement,
 						blockReason: seg.blockReason,
+						evictedReason: seg.evictedReason,
 					}
 				: { toolCallId: seg.id, toolName: seg.name, args: seg.args, elapsedMs, phase },
 			width,
@@ -916,6 +924,7 @@ function renderToolSegmentLines(
 			resultSummary: seg.resultSummary,
 			outcome: seg.settlement,
 			blockReason: seg.blockReason,
+			evictedReason: seg.evictedReason,
 		},
 		width,
 		{ unbounded: unboundedToolBodies, diffStyle: seg.replayed === true ? "plain" : "color" },
@@ -1936,7 +1945,14 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 						resultSummary?: unknown;
 						outcome?: unknown;
 						blockReason?: unknown;
+						evictedReason?: unknown;
 					};
+					// Replay-only: the rehydrator reads the working-set fold and tags
+					// the rows whose bodies the projection has replaced for the model.
+					tool.evictedReason =
+						typeof enriched.evictedReason === "string" && enriched.evictedReason.length > 0
+							? enriched.evictedReason
+							: undefined;
 					// Settlement is that verdict, never an inference from result text.
 					// The text of a tool result is the tool's own output: `node --test`
 					// prints `cancelled 0` on every run and a linter can print

package/src/interactive/chat-renderer.ts

@@ -13,7 +13,10 @@
  * `isTransparentAssistantWrapper`.
  */
 
+import { existsSync } from "node:fs";
 import { ToolNames } from "../core/tool-names.js";
+import { foldWorkingSet } from "../domains/context/working-set/fold.js";
+import { compactionCut } from "../domains/context/working-set/visible.js";
 import type {
 	BashExecutionEntry,
 	BranchSummaryEntry,
@@ -40,8 +43,9 @@ import {
 import { wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
 import { toolPresentationPolicy } from "../tools/presentation.js";
+import { toolResultPresentationText } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
-import { isSelfExplainingAbort } from "./chat-loop-messages.js";
+import { 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";
@@ -437,6 +441,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"api",
 			"provider",
 			"model",
+			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
 			"diagnostics",
@@ -482,7 +487,11 @@ function toolResultContent(result: unknown, unbounded = false): unknown[] {
 }
 
 function displayReplayToolResult(result: unknown, unbounded = false): unknown {
-	const content = toolResultContent(result, unbounded);
+	const presentationText = toolResultPresentationText(result);
+	const content =
+		presentationText === null
+			? toolResultContent(result, unbounded)
+			: [{ type: "text", text: unbounded ? presentationText : truncateReplayText(presentationText) }];
 	// Preserve the details record (observation envelope, exec records) so the
 	// replayed ledger line carries the same outcome facts as the live one.
 	const details = payloadObject(result)?.details;
@@ -664,6 +673,19 @@ interface ReplayToolResult {
 	blockReason?: string;
 }
 
+/**
+ * Resolve a replayed offload pointer once, when the ledger row becomes a
+ * display event. Terminal repaints consume the recorded fact and never touch
+ * the filesystem.
+ */
+function replayResultSummary(result: ReplayToolResult): Record<string, unknown> | undefined {
+	const summary = result.resultSummary ?? toolResultSummary(result.result);
+	const offloadPath =
+		typeof summary.offloadPath === "string" && summary.offloadPath.length > 0 ? summary.offloadPath : null;
+	if (offloadPath === null) return result.resultSummary;
+	return { ...summary, offloadFileMissing: !existsSync(offloadPath) };
+}
+
 function extractToolResult(entry: MessageEntry): ReplayToolResult {
 	const payload = entry.payload;
 	const obj = payloadObject(payload);
@@ -835,13 +857,6 @@ function truncateAtTurn(entries: ReadonlyArray<SessionEntry>, uptoTurnId?: strin
 	return entries.slice(0, index + 1);
 }
 
-function latestCompactionIndex(entries: ReadonlyArray<SessionEntry>): number {
-	for (let i = entries.length - 1; i >= 0; i--) {
-		if (entries[i]?.kind === "compactionSummary") return i;
-	}
-	return -1;
-}
-
 function toolCallIdsInEntry(entry: SessionEntry): string[] {
 	if (entry.kind !== "message") return [];
 	if (entry.role === "tool_call") return [extractToolCall(entry).id];
@@ -919,19 +934,13 @@ export function selectReplayEntries(
 ): SessionEntry[] {
 	const active = filterEntriesToActivePath(turns, options.activeLeafTurnId ?? options.uptoTurnId);
 	const entries = truncateAtTurn(active, options.uptoTurnId);
-	const compactionIndex = latestCompactionIndex(entries);
-	if (compactionIndex < 0) return dropLegacyToolResultAssistantDuplicates(entries);
-
-	const compaction = entries[compactionIndex] as CompactionSummaryEntry;
-	const selected: SessionEntry[] = [compaction];
-	const firstKeptIndex = compaction.firstKeptTurnId
-		? entries.findIndex((entry) => entry.turnId === compaction.firstKeptTurnId)
-		: -1;
-	if (firstKeptIndex >= 0 && firstKeptIndex < compactionIndex) {
-		selected.push(...entries.slice(firstKeptIndex, compactionIndex));
-	}
-	selected.push(...entries.slice(compactionIndex + 1));
-	return dropLegacyToolResultAssistantDuplicates(repairToolResultOrphans(entries, selected, compactionIndex));
+	// The cut itself is the working-set layer's definition of "what the model
+	// can see", shared with the eviction policy input so the two cannot drift.
+	const cut = compactionCut(entries);
+	if (cut.compactionIndex < 0) return dropLegacyToolResultAssistantDuplicates(entries);
+	const compaction = entries[cut.compactionIndex] as CompactionSummaryEntry;
+	const selected: SessionEntry[] = [compaction, ...cut.visible];
+	return dropLegacyToolResultAssistantDuplicates(repairToolResultOrphans(entries, selected, cut.compactionIndex));
 }
 
 function dropLegacyToolResultAssistantDuplicates(entries: ReadonlyArray<SessionEntry>): SessionEntry[] {
@@ -1043,6 +1052,11 @@ export function buildReplayAgentMessagesFromTurns(
 			// It reaches the model only when an operator shares it, and a share
 			// is already a user message by the time it lands in the ledger.
 			case "workerRun":
+			// Working-set entries are folded into a view by the context domain
+			// and applied as a projection before this builder runs; the
+			// entries themselves never become messages.
+			case "contextEviction":
+			case "contextRecall":
 				break;
 		}
 	}
@@ -1080,6 +1094,11 @@ export function rehydrateChatPanelFromTurns(
 	const pendingToolIds: string[] = [];
 	let runAssistantMessages: AgentMessage[] = [];
 	const selected = selectReplayEntries(turns, options);
+	// The transcript shows the ledger, never the projection: an evicted result
+	// still renders its full body here, tagged with the reason it left the
+	// model's working set. Folded once over the same active path the replay
+	// uses, so a /tree switch cannot tag a row from an abandoned branch.
+	const workingSet = foldWorkingSet(turns, options.activeLeafTurnId ?? options.uptoTurnId);
 	// One block per assignment, drawn where its first attempt started. Later
 	// attempts of the same assignment fold into that block as `↻` rail lines, so
 	// a failover replays as the one run it was rather than as two.
@@ -1127,6 +1146,8 @@ export function rehydrateChatPanelFromTurns(
 				}
 				if (entry.role === "tool_result") {
 					const result = extractToolResult(entry);
+					const resultSummary = replayResultSummary(result);
+					const evictedReason = workingSet.evicted.get(entry.turnId)?.reason;
 					const fallbackId = result.id ?? pendingToolIds.pop() ?? null;
 					if (fallbackId) {
 						const pendingIndex = pendingToolIds.indexOf(fallbackId);
@@ -1138,9 +1159,10 @@ export function rehydrateChatPanelFromTurns(
 							result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 							isError: result.isError,
 							...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
-							...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
+							...(resultSummary !== undefined ? { resultSummary } : {}),
 							...(result.outcome !== undefined ? { outcome: result.outcome } : {}),
 							...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
+							...(evictedReason !== undefined ? { evictedReason } : {}),
 						} as ChatLoopEvent);
 					} else {
 						chatPanel.appendReplayBlock((width) =>
@@ -1151,9 +1173,10 @@ export function rehydrateChatPanelFromTurns(
 									result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 									isError: result.isError,
 									...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
-									...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
+									...(resultSummary !== undefined ? { resultSummary } : {}),
 									...(result.outcome === "blocked" ? { outcome: "blocked" as const } : {}),
 									...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
+									...(evictedReason !== undefined ? { evictedReason } : {}),
 								},
 								width,
 								{ unbounded: options.unboundedToolBodies === true },
@@ -1239,6 +1262,8 @@ export function rehydrateChatPanelFromTurns(
 			case "label":
 			case "taskLedger":
 			case "decisionLedger":
+			case "contextEviction":
+			case "contextRecall":
 				break;
 		}
 	}

package/src/interactive/clio-editor.ts

@@ -1,9 +1,12 @@
 import { Editor, stripTerminalSequences, type TUI, truncateToWidth, visibleWidth } from "../engine/tui.js";
+import { fitHintEntries } from "./overlay-frame.js";
+import { permissionHintEntries } from "./permission-hint.js";
 import type { ClioTheme } from "./theme/index.js";
 import { clioTheme, editorTheme, GLYPH, rule } from "./theme/index.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 MIN_HINT_WIDTH = 60;
 
 function hasScrollIndicator(line: string): boolean {
@@ -18,6 +21,13 @@ export interface EditorChrome {
 	getThinkingLabel: () => string;
 	/** Whether Enter currently targets the active Clio response. */
 	isStreaming?: () => boolean;
+	/**
+	 * Whether a permission prompt owns the keyboard. The dialog once sat at the
+	 * vertical center of a tall viewport, far from the composer. It now anchors
+	 * above that composer, while the rail still says CONFIRM and carries the
+	 * dialog's keys whenever the prompt owns input (issues #186 and #194).
+	 */
+	isAwaitingApproval?: () => boolean;
 	/** Whether the current draft will actually steer Clio or live dispatch work on Enter. */
 	willEnterSteer?: (text: string) => boolean;
 	/** Resolved submit binding, formatted for display. */
@@ -26,7 +36,7 @@ export interface EditorChrome {
 	getNewlineKeyLabel?: () => string;
 }
 
-type ComposerMode = "MESSAGE" | "FOLLOW-UP" | "STEER";
+type ComposerMode = "MESSAGE" | "FOLLOW-UP" | "STEER" | "CONFIRM";
 
 function normalizeThinkingHint(value: string): string {
 	return value
@@ -61,6 +71,7 @@ function styledRailLabel(theme: ClioTheme, chrome: EditorChrome): string {
 }
 
 function composerMode(chrome: EditorChrome, text: string): ComposerMode {
+	if (chrome.isAwaitingApproval?.() ?? false) return "CONFIRM";
 	if (!(chrome.isStreaming?.() ?? false)) return "MESSAGE";
 	const willSteer = chrome.willEnterSteer?.(text) ?? text.trim().length > 0;
 	return willSteer ? "STEER" : "FOLLOW-UP";
@@ -73,12 +84,27 @@ function lowerRailHint(theme: ClioTheme, chrome: EditorChrome): string {
 	);
 }
 
-function renderEmptyPrompt(line: string, width: number, theme: ClioTheme): string {
+/**
+ * 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.
+ * The rule spends three columns around a right label, hence the subtraction.
+ */
+function confirmRailHint(theme: ClioTheme, width: number, hasDraft: boolean): string {
+	return theme.fg("warning", fitHintEntries(permissionHintEntries(hasDraft), Math.max(1, width - 3)));
+}
+
+function modeToken(mode: ComposerMode): "action" | "accentDeep" | "warning" {
+	if (mode === "STEER") return "action";
+	if (mode === "CONFIRM") return "warning";
+	return "accentDeep";
+}
+
+function renderEmptyPrompt(line: string, width: number, theme: ClioTheme, text = EMPTY_PROMPT): string {
 	const cursorAt = line.indexOf(REVERSE_VIDEO_BLANK);
 	if (cursorAt < 0) return line;
 	const afterCursorAt = cursorAt + REVERSE_VIDEO_BLANK.length;
 	const available = Math.max(0, width - 1);
-	const prompt = truncateToWidth(theme.fg("dim", EMPTY_PROMPT), available, "…", false);
+	const prompt = truncateToWidth(theme.fg("dim", text), available, "…", false);
 	const consumed = visibleWidth(prompt);
 	return `${line.slice(0, afterCursorAt)}${prompt}${line.slice(afterCursorAt + consumed)}`;
 }
@@ -111,12 +137,12 @@ export class ClioEditor extends Editor {
 			// 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(mode === "STEER" ? "action" : "accentDeep", mode, { bold: true });
+			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: mode === "STEER" ? "action" : "accentDeep",
+				leftToken: modeToken(mode),
 				right: styledRailLabel(theme, this.chrome),
 				fillToken: "frameStrong",
 				rightRaw: true,
@@ -124,10 +150,21 @@ export class ClioEditor extends Editor {
 			});
 		}
 
-		if (text.length === 0 && lines[1]) lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme);
+		if (text.length === 0 && lines[1]) {
+			lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme, mode === "CONFIRM" ? CONFIRM_PROMPT : EMPTY_PROMPT);
+		}
 
 		const bottomRail = findBottomRail(lines, safeWidth);
-		if (bottomRail >= 0 && safeWidth >= MIN_HINT_WIDTH) {
+		// 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),
+				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",

package/src/interactive/context-meter.ts

@@ -156,6 +156,16 @@ export function renderContextMeterGrid(
 	return lines;
 }
 
+/**
+ * Evicted tokens live outside the window: the working-set projection removed
+ * them from what the model sees, so they are not a meter category and must
+ * not claim cells or a legend row. One line after the legend names them.
+ */
+export function renderEvictedTokensLine(evictedTokens: number, theme: ClioTheme = clioTheme()): string {
+	const tokens = Math.round(Math.max(0, evictedTokens)).toLocaleString("en-US");
+	return `${theme.fg("dim", GLYPH.contextReserve)} ${theme.fg("muted", "evicted (outside window)")} ${theme.fg("dim", `${tokens} tokens`)}`;
+}
+
 /** A small colored swatch for a category, for inline legends. */
 export function contextCategorySwatch(category: ContextLedgerCategory, theme: ClioTheme = clioTheme()): string {
 	return theme.fg(CONTEXT_CATEGORY_TOKEN[category], contextCategoryGlyph(category));