@iowarp/clio-coder 0.4.6 → 0.4.8

package/src/interactive/slash-spec.ts

@@ -50,7 +50,6 @@ export const COMPLETION_SLOT_NAMES = [
 	"pane-runs-agents",
 	"pane-presets",
 	"pane-targets",
-	"library-tabs",
 	"thinking-levels",
 	"settings-areas",
 	"settings-groups",

package/src/interactive/terminal-lease.ts

@@ -10,11 +10,21 @@
 
 import type { ClioSettings } from "../core/config.js";
 import { getTerminationCoordinator } from "../core/termination.js";
-import { type Component, Container, matchesKey, ScrollView, Text, type TUI, VStack } from "../engine/tui.js";
+import {
+	type Component,
+	Container,
+	isKeyRelease,
+	isKeyRepeat,
+	matchesKey,
+	ScrollView,
+	Text,
+	type TUI,
+	VStack,
+} from "../engine/tui.js";
 import { ClioEditor, type EditorChrome } from "./clio-editor.js";
 import { createProcessInteractiveShell } from "./interactive-shell.js";
 import { type ClioKeybindingManager, createKeybindingManager } from "./keybinding-manager.js";
-import { clioTheme, GLYPH } from "./theme/index.js";
+import { brandMark, clioTheme, GLYPH } from "./theme/index.js";
 
 export const INSTANT_SHELL_ENV = "CLIO_CODER_INSTANT_SHELL";
 const DOUBLE_TAP_MS = 500;
@@ -133,17 +143,25 @@ function stageZeroRoot(
 	shutdownArmed: () => boolean,
 ): Component {
 	const theme = clioTheme();
+	// The same wordmark the hydrated header paints, through the same helper, so
+	// the `>C_` does not change color at adoption. `brandMark` and the theme
+	// tokens are Stage-0-safe: pure string composition with no I/O and no import
+	// outside the theme leaf this module already depends on.
+	// Three lines, matching the hydrated header's footprint so adoption does not
+	// shift the editor down the screen. The third is deliberately blank: it costs
+	// nothing and asserts nothing, where any real fact here would need I/O the
+	// boot path must not do.
 	const heading = new Text(
-		`${theme.style("title", ">C_ Clio Coder", { bold: true })}\n${theme.fg("muted", "Hydrating session services…")}`,
+		`${brandMark(theme)} ${theme.style("title", "Clio Coder", { bold: true })}\n${theme.fg("muted", "Starting Clio · you can type now")}\n`,
 		0,
 		0,
 	);
+	// Only the armed-exit warning lives here. The reassurance that typing works
+	// is already the second heading line, and printing it twice on a two-line
+	// screen was the loudest thing on it.
 	const footer: Component = {
-		render: () => [
-			shutdownArmed()
-				? theme.fg("warning", "Ctrl+C again to exit · typed input will be recovered")
-				: theme.fg("dim", "Warming up · typing and submit are ready"),
-		],
+		render: () =>
+			shutdownArmed() ? [theme.fg("warning", "Ctrl+C again to exit · typed input will be recovered")] : [""],
 		invalidate: () => {},
 	};
 	if (mode === "fullscreen") {
@@ -182,7 +200,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 			[settings.chat.target, settings.chat.model].filter((part) => part && part.length > 0).join("·") || "starting",
 		getThinkingLabel: () => settings.chat.thinkingLevel ?? "off",
 		getSubmitKeyLabel: () => keybindings.getKeys("tui.input.submit")[0] ?? "Enter",
-		getNewlineKeyLabel: () => keybindings.getKeys("tui.input.newLine")[0] ?? "Shift+Enter",
+		getNewlineKeyLabel: () => keybindings.getKeys("tui.input.newLine")[0] ?? "Ctrl+J",
 	};
 	const editorChromeProxy: EditorChrome = {
 		getModelLabel: () => editorChrome.getModelLabel(),
@@ -193,7 +211,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 		getTurnPreparation: () => editorChrome.getTurnPreparation?.() ?? "idle",
 		willEnterSteer: (text) => editorChrome.willEnterSteer?.(text) ?? false,
 		getSubmitKeyLabel: () => editorChrome.getSubmitKeyLabel?.() ?? "Enter",
-		getNewlineKeyLabel: () => editorChrome.getNewlineKeyLabel?.() ?? "Shift+Enter",
+		getNewlineKeyLabel: () => editorChrome.getNewlineKeyLabel?.() ?? "Ctrl+J",
 	};
 	const shell =
 		options.testing?.shell ??
@@ -271,6 +289,12 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 			tui.requestRender();
 			return;
 		}
+		if (submissions.length > 0) {
+			shutdownArmed = false;
+			lastCtrlCAt = 0;
+			tui.requestRender();
+			return;
+		}
 		const pressedAt = now();
 		if (lastCtrlCAt > 0 && pressedAt - lastCtrlCAt <= DOUBLE_TAP_MS) {
 			lastCtrlCAt = 0;
@@ -283,11 +307,19 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	};
 
 	inputDelegate = (data) => {
+		if (isKeyRelease(data)) return { consume: true };
+		if (
+			isKeyRepeat(data) &&
+			(matchesKey(data, "ctrl+c") ||
+				keybindings.matches(data, "clio-coder.exit") ||
+				keybindings.matches(data, "tui.input.submit"))
+		)
+			return { consume: true };
 		if (matchesKey(data, "ctrl+c")) {
 			handleStage0CtrlC();
 			return { consume: true };
 		}
-		if (keybindings.matches(data, "clio-coder.exit") && editor.getText().length === 0) {
+		if (keybindings.matches(data, "clio-coder.exit") && editor.getText().length === 0 && submissions.length === 0) {
 			requestShutdown();
 			return { consume: true };
 		}
@@ -302,7 +334,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	};
 
 	const stableInput = (data: string) => inputDelegate(data);
-	const removeStableInput = tui.addInputListener(stableInput);
+	const removeStableInput = tui.setApplicationInputPolicy(stableInput);
 	const stableSignal = (): void => {
 		if (applicationSignal) applicationSignal();
 		else handleStage0CtrlC();

package/src/interactive/turn-context.ts

@@ -705,6 +705,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 				output: usage.output,
 				cacheRead: usage.cacheRead,
 				cacheWrite: usage.cacheWrite,
+				...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 				reasoningTokens: usage.reasoning,
 				totalTokens: usage.totalTokens,
 				apiCalls: Math.max(1, Math.round(usage.apiCalls)),

package/src/interactive/turn-persistence.ts

@@ -213,6 +213,9 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			outputTokens: total.outputTokens + summary.output,
 			cacheReadTokens: total.cacheReadTokens + summary.cacheRead,
 			cacheWriteTokens: total.cacheWriteTokens + summary.cacheWrite,
+			...(total.cacheWrite1hTokens === undefined && summary.cacheWrite1h === undefined
+				? {}
+				: { cacheWrite1hTokens: (total.cacheWrite1hTokens ?? 0) + (summary.cacheWrite1h ?? 0) }),
 			reasoningTokens: total.reasoningTokens + summary.reasoning,
 			totalTokens: total.totalTokens + summary.tokens,
 			costUsd: (total.costUsd ?? 0) + summary.costUsd,

package/src/interactive/turn-prewarm.ts

@@ -10,10 +10,16 @@
  * nobody watching.
  */
 
+import { createHash } from "node:crypto";
 import { BusChannels } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
-import type { ProvidersContract } from "../domains/providers/index.js";
+import { endpointCapacityUsage } from "../domains/dispatch/index.js";
+import {
+	type CacheDeploymentObservation,
+	observeCacheDeployment,
+	type ProvidersContract,
+} from "../domains/providers/index.js";
 import type { SessionContract } from "../domains/session/contract.js";
 import type { Usage } from "../engine/types.js";
 import { type PrewarmTrigger, prewarmPromptTokens, runPrewarmRound } from "./prewarm.js";
@@ -28,9 +34,14 @@ export type PrewarmSkipReason =
 	| "dispatch-active"
 	| "tier"
 	| "unresolved"
+	| "deployment"
+	| "cooldown"
+	| "expired"
 	| "superseded";
 
-export type PrewarmOutcome = { ran: true; trigger: PrewarmTrigger } | { ran: false; reason: PrewarmSkipReason };
+export type PrewarmOutcome =
+	| { ran: true; trigger: PrewarmTrigger }
+	| { ran: false; reason: PrewarmSkipReason; detail?: string };
 
 export interface TurnPrewarmDeps {
 	state: ChatTurnState;
@@ -78,6 +89,7 @@ export interface TurnPrewarmDeps {
 	registerEndpointSlot?: (runtime: AgentRuntime) => (() => void) | null;
 	/** Test seam. Production uses the real provider round. */
 	runPrewarm?: typeof runPrewarmRound;
+	observeDeployment?: typeof observeCacheDeployment;
 	/**
 	 * Whether a submit aborts the round's request. Defaults to the measured
 	 * backend behavior; see {@link ABORT_ROUND_ON_SUBMIT}.
@@ -127,6 +139,13 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 	let pendingTrigger: PrewarmTrigger | null = null;
 	let timer: ReturnType<typeof setTimeout> | null = null;
 	let active: AbortController | null = null;
+	// Ownership outlives detachment: one request and at most one newer trigger.
+	let running: AbortController | null = null;
+	let disposed = false;
+	let pendingSince = 0;
+	let lastFinished = 0;
+	let lastPrefix: string | null = null;
+	let lastSkip: string | null = null;
 	// Rounds a submit or a session switch let go of. Their result is still
 	// recorded, but it no longer describes the prefix the next turn will send, so
 	// it never reaches the `/context` line.
@@ -167,13 +186,33 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 		// notice from either.
 		const targetId = deps.getSettings().chat?.target?.trim();
 		const runtimeId = targetId ? deps.providers.getTarget(targetId)?.runtime : undefined;
-		if (runtimeId === undefined || deps.providers.getRuntime(runtimeId)?.tier !== "local-native") return "tier";
+		if (
+			runtimeId === undefined ||
+			(deps.providers.getRuntime(runtimeId)?.tier !== "local-native" &&
+				!(runtimeId === "litellm" && targetId && deps.providers.getTarget(targetId)?.cache?.deployment))
+		)
+			return "tier";
 		return null;
 	};
 
 	const runOnce = async (trigger: PrewarmTrigger, controller: AbortController): Promise<PrewarmOutcome> => {
 		const refusal = admissionRefusal();
 		if (refusal) return { ran: false, reason: refusal };
+		const targetId = deps.getSettings().chat.target;
+		const target = targetId ? deps.providers.getTarget(targetId) : null;
+		if (!target) return { ran: false, reason: "unresolved" };
+		const targetSettings = JSON.stringify(target);
+		const started = Date.now();
+		if (target.cache?.retention === "none") return { ran: false, reason: "disabled" };
+		if (target.pricing && Object.values(target.pricing).some((rate) => rate > 0))
+			return { ran: false, reason: "deployment", detail: "paid-warming-disabled" };
+		const cooldown = Math.max(1000, target.cache?.warm?.cooldownMs ?? 60000);
+		if (Date.now() - lastFinished < cooldown) return { ran: false, reason: "cooldown" };
+		const observe = deps.observeDeployment ?? observeCacheDeployment;
+		let deployment: CacheDeploymentObservation = await observe(target, deps.getSettings().chat.model ?? "", {
+			signal: controller.signal,
+		});
+		if (deployment.warm !== "bounded") return { ran: false, reason: "deployment", detail: deployment.reason };
 
 		const prepared = await deps.prepareRuntime(controller.signal);
 		if (!prepared.ok) return { ran: false, reason: "unresolved" };
@@ -194,15 +233,48 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 		const lateRefusal = admissionRefusal();
 		if (lateRefusal) return { ran: false, reason: lateRefusal };
 		if (detached.has(controller) || controller.signal.aborted) return { ran: false, reason: "superseded" };
+		// Binding/residency can change during preparation. Discovery itself never
+		// loads models and missing evidence leaves ordinary inference untouched.
+		deployment = await observe(target, runtime.wireModelId, { signal: controller.signal });
+		if (deployment.warm !== "bounded") return { ran: false, reason: "deployment", detail: deployment.reason };
+		const finalRefusal = admissionRefusal();
+		if (finalRefusal) return { ran: false, reason: finalRefusal };
+		if (
+			detached.has(controller) ||
+			controller.signal.aborted ||
+			JSON.stringify(deps.providers.getTarget(target.id)) !== targetSettings
+		)
+			return { ran: false, reason: "superseded" };
+		if (Date.now() - started > 30000) return { ran: false, reason: "expired" };
+		// This includes shared dispatch leases/reservations and this process's
+		// foreground streams. It is a fresh check, not an atomic global warm lease;
+		// server slot observations above also include unrelated active traffic.
+		if (deployment.endpoint && (endpointCapacityUsage()[deployment.endpoint] ?? 0) > 0)
+			return { ran: false, reason: "dispatch-active" };
+		const prefix = createHash("sha256")
+			.update(
+				JSON.stringify({
+					model: runtime.agent.state.model,
+					system: runtime.agent.state.systemPrompt,
+					messages: runtime.agent.state.messages,
+					tools: runtime.agent.state.tools,
+					thinking: runtime.agent.state.thinkingLevel,
+				}),
+			)
+			.digest("hex");
+		if (prefix === lastPrefix && Date.now() - lastFinished < Math.max(cooldown, 60000))
+			return { ran: false, reason: "cooldown" };
 
 		// The claim is taken before the request goes out and released in the
 		// finally, including on the detach path, because the request the server is
 		// still finishing is the one occupying the slot.
 		const releaseEndpointSlot = deps.registerEndpointSlot?.(runtime) ?? null;
 		let result: Awaited<ReturnType<typeof round>>;
+		const deadline = setTimeout(() => controller.abort(), Math.min(target.cache?.warm?.maxDurationMs ?? 30000, 120000));
 		try {
 			result = await round({
 				model: runtime.agent.state.model,
+				agent: runtime.agent,
 				state: {
 					systemPrompt: runtime.agent.state.systemPrompt,
 					messages: runtime.agent.state.messages,
@@ -211,10 +283,14 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 				},
 				...(prepared.apiKey !== undefined ? { apiKey: prepared.apiKey } : {}),
 				signal: controller.signal,
+				maxInputTokens: target.cache?.warm?.maxInputTokens ?? 8192,
 			});
 		} finally {
+			clearTimeout(deadline);
+			lastFinished = Date.now();
 			releaseEndpointSlot?.();
 		}
+		lastPrefix = result.aborted || result.errorMessage ? null : prefix;
 
 		// The prefill the server did is spend whatever the operator did next, so a
 		// let-go round is recorded exactly like a completed one. Only the
@@ -223,7 +299,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 		// prefix.
 		const wasDetached = detached.has(controller) || controller.signal.aborted;
 		const promptTokens = prewarmPromptTokens(result);
-		if (!wasDetached) {
+		if (!wasDetached && !result.errorMessage) {
 			deps.context.notePrewarm({
 				tokens: promptTokens,
 				ms: result.timing.apiMs,
@@ -242,6 +318,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 				parentTurnId: deps.state.lastTurnId,
 				data: {
 					trigger,
+					deployment,
 					target: runtime.targetId,
 					model: runtime.wireModelId,
 					promptTokens,
@@ -249,9 +326,10 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 					detached: wasDetached,
 					timing: result.timing,
 					promptCache: {
-						input: result.usage?.input ?? 0,
-						cacheRead: result.usage?.cacheRead ?? 0,
-						cacheWrite: result.usage?.cacheWrite ?? 0,
+						input: result.usage?.input ?? null,
+						cacheRead: result.usage?.cacheRead ?? null,
+						cacheWrite: result.usage?.cacheWrite ?? null,
+						...(result.usage?.cacheWrite1h === undefined ? {} : { cacheWrite1h: result.usage.cacheWrite1h }),
 						...(result.backend ? { backend: { ...result.backend } } : {}),
 					},
 					...(result.errorMessage ? { error: result.errorMessage } : {}),
@@ -279,28 +357,55 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 
 	const fire = (): void => {
 		timer = null;
+		if (disposed || running !== null) return;
 		const trigger = pendingTrigger;
 		pendingTrigger = null;
 		if (trigger === null) return;
 		const controller = new AbortController();
 		active = controller;
-		const previous = inFlight;
-		inFlight = previous
-			.catch(() => null)
-			.then(() => runOnce(trigger, controller))
+		running = controller;
+		inFlight = (
+			Date.now() - pendingSince > 30000
+				? Promise.resolve<PrewarmOutcome>({ ran: false, reason: "expired" })
+				: runOnce(trigger, controller)
+		)
+			.then((outcome) => {
+				if (!outcome.ran && deps.getSettings().chat.prewarm && outcome.reason !== "surface") {
+					const key = `${outcome.reason}:${outcome.detail ?? ""}`;
+					if (lastSkip !== key) {
+						lastSkip = key;
+						try {
+							deps.session?.appendEntry({
+								kind: "custom",
+								customType: "prewarmSkipped",
+								display: false,
+								parentTurnId: deps.state.lastTurnId,
+								data: { trigger, ...outcome },
+							});
+						} catch {
+							/* Optional diagnostics. */
+						}
+					}
+				} else if (outcome.ran) lastSkip = null;
+				return outcome;
+			})
 			.catch(() => null)
 			.finally(() => {
 				if (active === controller) active = null;
+				running = null;
+				if (!disposed && pendingTrigger !== null && timer === null) timer = setTimeout(fire, 0);
 			});
 	};
 
 	return {
 		schedule(trigger: PrewarmTrigger): void {
+			if (disposed) return;
 			// A newer trigger describes a newer prefix; the older round is no longer
 			// warming history this session has.
 			releaseActiveRound();
 			pendingTrigger = trigger;
-			if (timer !== null) return;
+			pendingSince = Date.now();
+			if (timer !== null || running !== null) return;
 			// Ref'd on purpose, same reasoning as `settled()` below: the timer is due
 			// in 0 ms, so it holds the event loop for one tick at most, and a Node 22
 			// loop that drains past a due unref'd timer would otherwise never start
@@ -317,7 +422,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 			releaseActiveRound();
 		},
 
-		settled(): Promise<PrewarmOutcome | null> {
+		async settled(): Promise<PrewarmOutcome | null> {
 			// One hop past the scheduling tick so a caller that just scheduled a
 			// round waits for that round rather than for the previous one. The timer
 			// is deliberately ref'd, unlike the scheduling timer above: the caller is
@@ -327,14 +432,16 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 			// pending forever and cancelled every later test in the lane; Node 24
 			// happens to fire the due timer first, which is why the hang never
 			// reproduced on a 24.x development machine.
-			return new Promise((resolve) => {
-				setTimeout(() => {
-					resolve(inFlight.catch(() => null));
-				}, 0);
-			});
+			let outcome: PrewarmOutcome | null;
+			do {
+				await new Promise<void>((resolve) => setTimeout(resolve, 0));
+				outcome = await inFlight;
+			} while (timer !== null || running !== null || pendingTrigger !== null);
+			return outcome;
 		},
 
 		dispose(): void {
+			disposed = true;
 			for (const unsubscribe of unsubscribeDispatch) unsubscribe?.();
 			pendingTrigger = null;
 			if (timer !== null) {
@@ -343,7 +450,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 			}
 			// Shutdown always aborts: the process is going away, and a socket held
 			// open for a round nobody will read is not a latency question.
-			active?.abort();
+			running?.abort();
 			active = null;
 		},
 	};

package/src/interactive/turn-queues.ts

@@ -25,6 +25,7 @@ export type SteeringMode = "interrupt" | "next-slot" | "end-of-turn";
 export const DEFAULT_STEERING_MODE: SteeringMode = "next-slot";
 
 export interface QueuedChatMessage {
+	display?: { text: string; note: string };
 	text: string;
 	kind: QueuedMessageKind;
 }
@@ -50,8 +51,8 @@ export interface TurnQueuesDeps {
 }
 
 export interface TurnQueues {
-	steer(text: string): boolean;
-	queueFollowUp(text: string): boolean;
+	steer(text: string, display?: QueuedChatMessage["display"]): boolean;
+	queueFollowUp(text: string, display?: QueuedChatMessage["display"]): boolean;
 	queuedMessages(): QueuedMessagesSnapshot;
 	/** Drain the mirror and both engine queues; returns the drained entries. */
 	clearQueuedMirror(): QueuedChatMessage[];
@@ -69,7 +70,7 @@ export function createTurnQueues(deps: TurnQueuesDeps): TurnQueues {
 	const { state } = deps;
 	// UI mirror of both engine queues, in enqueue order. Entries leave when
 	// the engine injects them into the transcript (message_end →
-	// appendQueuedUserTurn), when alt+up restores them to the editor, or when
+	// appendQueuedUserTurn), when Alt+Q restores them to the editor, or when
 	// a cancel clears the run.
 	const queuedMirror: QueuedChatMessage[] = [];
 	const persistedUserEchoes: string[] = [];
@@ -82,7 +83,7 @@ export function createTurnQueues(deps: TurnQueuesDeps): TurnQueues {
 	// that a message is pending, exactly as pi-coding-agent's pending container
 	// works. The former per-steer transcript notice duplicated the panel and
 	// left a permanent line for a transient state.
-	const enqueue = (text: string, kind: QueuedMessageKind): boolean => {
+	const enqueue = (text: string, kind: QueuedMessageKind, display?: QueuedChatMessage["display"]): boolean => {
 		// The payload crosses to the model exactly as it was submitted; only the
 		// emptiness test reads a trimmed copy. A queued turn that shortened its own
 		// text here would land in the ledger disagreeing with the expansion that
@@ -93,7 +94,7 @@ export function createTurnQueues(deps: TurnQueuesDeps): TurnQueues {
 			content: text,
 			timestamp: Date.now(),
 		} as AgentMessage;
-		queuedMirror.push({ text, kind });
+		queuedMirror.push({ text, kind, ...(display ? { display } : {}) });
 		if (kind === "steer") {
 			state.runtime.agent.steer(message);
 		} else {
@@ -104,8 +105,8 @@ export function createTurnQueues(deps: TurnQueuesDeps): TurnQueues {
 	};
 
 	return {
-		steer: (text) => enqueue(text, "steer"),
-		queueFollowUp: (text) => enqueue(text, "follow-up"),
+		steer: (text, display) => enqueue(text, "steer", display),
+		queueFollowUp: (text, display) => enqueue(text, "follow-up", display),
 		queuedMessages(): QueuedMessagesSnapshot {
 			return {
 				steer: queuedMirror.filter((entry) => entry.kind === "steer").map((entry) => entry.text),

package/src/interactive/turn-runtime.ts

@@ -25,6 +25,7 @@ import {
 import type { RetrySettings } from "../domains/session/retry.js";
 import type { createEngineAgent } from "../engine/agent.js";
 import { cleanupEngineSessionResources } from "../engine/ai.js";
+import { setGlobalDefaultMaxOutputTokens } from "../engine/apis/index.js";
 import { sanitizeLockedSynthesisMessage } from "../engine/loop-guard.js";
 import {
 	patchProviderThinkingPayload,
@@ -380,9 +381,17 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		);
 	};
 
+	// A target id/model names the selection, not its current URL, auth, pricing
+	// or cache policy. Keep the constructed descriptor identity across calls.
+	let runtimeTargetSettings: string | null = null;
 	const ensureRuntime = (): AgentRuntime | null => {
 		const target = readTarget();
 		if (!target) return null;
+		const targetSettings = JSON.stringify(target.target);
+		const sameTargetSettings = runtimeTargetSettings === targetSettings;
+		// Preflight and the wire budget share the session's effective settings,
+		// including overrides that never reach the saved providers snapshot.
+		setGlobalDefaultMaxOutputTokens(deps.getSettings().chat.maxOutputTokens);
 		context.emitContextWindowWarningTransition(target.runtimeResolution?.contextWindowDetails?.warning ?? null);
 		if (!deps.knownTargets().has(target.target.id)) {
 			throw new TurnAdmissionError(
@@ -394,11 +403,12 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			state.runtime &&
 			state.runtime.targetId === target.target.id &&
 			state.runtime.runtimeId === target.runtime.id &&
+			sameTargetSettings &&
 			state.runtime.wireModelId === target.wireModelId
 		) {
 			// Same target+runtime+model. Settings may still have moved
 			// thinkingLevel since the last call (the user invoked /thinking
-			// or Alt+T); reconcile the clamped level so the next prompt
+			// or Shift+Tab); reconcile the clamped level so the next prompt
 			// dispatches under the current intent without forcing a rebuild.
 			ensureReasoningProbe(target);
 			const runtimeResolution = refineRuntimeTargetWithModelHints(
@@ -427,6 +437,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			state.runtime &&
 			state.runtime.targetId === target.target.id &&
 			state.runtime.runtimeId === target.runtime.id &&
+			sameTargetSettings &&
 			state.runtime.wireModelId !== target.wireModelId
 		) {
 			const nextModel = synthesizeModel(target);
@@ -472,6 +483,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			maxRetryDelayMs: deps.retrySettings().maxDelayMs,
 			...(gatewaySessionId ? { sessionId: gatewaySessionId } : {}),
 			onStreamInvocation: () => {
+				setGlobalDefaultMaxOutputTokens(deps.getSettings().chat.maxOutputTokens);
 				apiCallStartedAt = performance.now();
 				apiCallFirstDeltaAt = null;
 			},
@@ -777,6 +789,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 							output: summary.output,
 							cacheRead: summary.cacheRead,
 							cacheWrite: summary.cacheWrite,
+							...(summary.cacheWrite1h === undefined ? {} : { cacheWrite1h: summary.cacheWrite1h }),
 							reasoningTokens: summary.reasoning,
 							totalTokens: summary.tokens,
 							apiCalls: summary.apiCalls,
@@ -911,6 +924,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		});
 
 		state.runtime = localRuntime;
+		runtimeTargetSettings = targetSettings;
 		// Append a modelChange marker only when this rebuild replaces a prior
 		// runtime, which is the cross-target swap case (mid-session change of
 		// target or runtime id). On the initial build, the session header's

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

@@ -1,6 +1,7 @@
 import {
 	type Component,
 	fuzzyFilter,
+	Input,
 	Markdown,
 	matchesKey,
 	type OverlayHandle,
@@ -10,6 +11,7 @@ import {
 	wrapTextWithAnsi,
 } from "../../engine/tui.js";
 import { clockLocal } from "../format-time.js";
+import { localKey } from "../keyboard-owner.js";
 import { buildHint, showClioOverlayFrame } from "../overlay-frame.js";
 import { clioTheme, GLYPH, markdownTheme, padAnsi } from "../theme/index.js";
 import {
@@ -425,6 +427,17 @@ function viewFooterHint(focus: ViewPaneFocus, canVerify: boolean, innerWidth?: n
 export class ViewOverlayView implements Component {
 	private artifacts: ViewArtifact[] = [];
 	private filterText = "";
+	private readonly filterInput = new Input();
+	get keyboardScope(): "edit" | "review" {
+		return this.focus === "list" ? "edit" : "review";
+	}
+	undoInput(): boolean {
+		if (this.focus !== "list") return false;
+		this.filterInput.applyEdit("undo");
+		this.filterText = this.filterInput.getValue();
+		this.selectInitialFilterMatch();
+		return true;
+	}
 	private selectedIndex = 0;
 	private listScrollOffset = 0;
 	private contentScrollOffset = 0;
@@ -439,6 +452,7 @@ export class ViewOverlayView implements Component {
 
 	constructor(private readonly options: ViewOverlayOptions) {
 		this.filterText = options.initialFilter ?? "";
+		this.filterInput.setValue(this.filterText);
 	}
 
 	refresh(): void {
@@ -637,6 +651,7 @@ export class ViewOverlayView implements Component {
 	}
 
 	handleInput(data: string): void {
+		data = localKey(data);
 		if (
 			matchesKey(data, "tab") ||
 			matchesKey(data, "shift+tab") ||
@@ -688,20 +703,10 @@ export class ViewOverlayView implements Component {
 			if (filtered.length > 0) this.selectIndex(this.selectedIndex + 1);
 			return true;
 		}
-		if (matchesKey(data, "ctrl+u")) {
-			this.filterText = "";
-			this.selectInitialFilterMatch();
-			return true;
-		}
-		if (matchesKey(data, "backspace")) {
-			if (this.filterText.length > 0) {
-				this.filterText = this.filterText.slice(0, -1);
-				this.selectInitialFilterMatch();
-			}
-			return true;
-		}
-		if (data.length === 1 && data >= " " && data !== "\x7f") {
-			this.filterText += data;
+		const previous = this.filterText;
+		this.filterInput.handleInput(data);
+		this.filterText = this.filterInput.getValue();
+		if (previous !== this.filterText) {
 			this.selectInitialFilterMatch();
 			return true;
 		}