@iowarp/clio-coder 0.4.7 → 0.4.9

package/src/interactive/slash-commands.ts

@@ -1,3 +1,4 @@
+import { mcpCommandOutput } from "../cli/mcp.js";
 import { acceptanceFromTaskFlags } from "../cli/tasks.js";
 import { BusChannels } from "../core/bus-events.js";
 import { THINKING_LEVELS } from "../core/defaults.js";
@@ -135,6 +136,7 @@ export interface LibraryBrowseRequest {
 }
 
 type SlashCommandVariant =
+	| { kind: "mcp"; argv: string[] }
 	| { kind: "quit" }
 	| { kind: "help"; query?: string }
 	| { kind: "init"; options: InitCommandOptions }
@@ -872,7 +874,7 @@ export interface BuiltinSlashCommand {
 	match?(trimmed: string): SlashCommand | null;
 	fromArgs?(parsed: ParsedArgs, trimmed: string): SlashCommand;
 	/** Execute `command` against `ctx`. Called only for kinds declared in `kinds`. */
-	handle(command: SlashCommand, ctx: SlashCommandContext): void | "rejected";
+	handle(command: SlashCommand, ctx: SlashCommandContext): undefined | "rejected";
 }
 
 const RUN_THINKING_LEVELS: ReadonlyArray<JobThinkingLevel> = THINKING_LEVELS;
@@ -1227,6 +1229,29 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			ctx.openSkillsHub?.({ tab: "prompt" });
 		},
 	},
+	{
+		name: "mcp",
+		description: "List MCP servers or manage explicit trust with trust <id> [class] and untrust <id>",
+		group: "Inspect",
+		kinds: ["mcp"],
+		args: {
+			positionals: [
+				{ name: "action", required: false, values: ["list", "trust", "untrust"] },
+				{ name: "id", required: false },
+				{ name: "class", required: false },
+			],
+		},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "mcp", reason: parsed.error };
+			const [action = "list", id, actionClass] = parsed.positionals;
+			return { kind: "mcp", argv: [action, ...(id ? [id] : []), ...(actionClass ? ["--action-class", actionClass] : [])] };
+		},
+		handle(command, ctx) {
+			if (command.kind !== "mcp") return;
+			const result = mcpCommandOutput(command.argv);
+			ctx.notice(result.code ? "error" : "info", result.text);
+		},
+	},
 	{
 		name: "extensions",
 		description: "Inspect harness extensions or reload their commands, hooks and operator UI",

package/src/interactive/slash-spec.ts

@@ -27,8 +27,8 @@ export interface CommandPositionalSpec {
 }
 
 /**
- * Stable grammar/provider seam. Slice 10 names every dynamic noun; slice 11
- * supplies read-only implementations for these slots.
+ * Stable names for dynamic completion sources. The presentation layer supplies
+ * read-only catalogs for available slots; unsupplied slots return no values.
  */
 export const COMPLETION_SLOT_NAMES = [
 	"agents",

package/src/interactive/theme/labels.ts

@@ -1,29 +1,50 @@
-/**
- * Abbreviate a wire model id for chips and dashboards without amputating a
- * meaningful placement prefix or version suffix. `dynamo/qwen3.8-27b` remains
- * visible as selected; only the leaf is shortened when the complete route is
- * wider than 24 characters.
- */
-export function abbreviateModelId(modelId: string | null | undefined): string {
-	const segments = (modelId ?? "").trim().split("/").filter(Boolean);
-	const base = segments.pop() ?? "";
-	if (base.length === 0) return "model";
-	const prefix = segments[0];
-	const maxLeaf = prefix ? Math.max(8, 24 - prefix.length - 1) : 18;
-	const parts = base.split("-").filter((part) => part.length > 0);
-	let leaf: string;
-	if (parts.length <= 1) leaf = base.length > maxLeaf ? base.slice(0, maxLeaf) : base;
-	else {
-		const kept: string[] = [];
-		for (const part of parts) {
-			const next = [...kept, part].join("-");
-			if (kept.length > 0 && next.length > maxLeaf) break;
-			kept.push(part);
-		}
-		const joined = kept.join("-");
-		leaf = joined.length > maxLeaf ? joined.slice(0, maxLeaf) : joined;
+import { sanitizeCallTargetText } from "../../domains/safety/call-target.js";
+import { stripTerminalSequences, truncateToWidth, visibleWidth } from "../../engine/tui.js";
+
+const identitySegments = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** Keep both placement and the distinguishing suffix when an identity must fit. */
+export function fitIdentityLabel(value: string, width: number): string {
+	value = sanitizeCallTargetText(value);
+	const room = Math.max(0, Math.floor(width));
+	if (visibleWidth(value) <= room) return value;
+	if (room <= 1) return room === 1 ? "…" : "";
+	const tailBudget = Math.ceil((room - 1) / 2);
+	let tail = "";
+	for (const { segment } of [...identitySegments.segment(value)].reverse()) {
+		if (visibleWidth(segment + tail) > tailBudget) break;
+		tail = segment + tail;
+	}
+	const headBudget = room - 1 - visibleWidth(tail);
+	let head = "";
+	for (const { segment } of identitySegments.segment(value)) {
+		if (visibleWidth(head + segment) > headBudget) break;
+		head += segment;
 	}
-	return prefix ? `${prefix}/${leaf}` : leaf;
+	return `${head}…${tail}`;
+}
+
+/** Compact wire identity with explicit omission and its version/quantization suffix. */
+export function abbreviateModelId(modelId: string | null | undefined): string {
+	const value = sanitizeCallTargetText(modelId ?? "");
+	if (value.length === 0) return "model";
+	if (visibleWidth(value) <= 24) return value;
+	const slash = value.lastIndexOf("/");
+	if (slash < 0) return fitIdentityLabel(value, 24);
+	const placement = value.slice(0, slash);
+	const model = value.slice(slash + 1);
+	const modelBudget = Math.min(18, visibleWidth(model));
+	return `${fitIdentityPrefix(placement, 23 - modelBudget)}/${fitIdentityLabel(model, modelBudget)}`;
+}
+
+/** Raw route fields stay separate until the surface knows its terminal-cell budget. */
+export interface TargetIdentity {
+	targetId: string | null | undefined;
+	modelId: string | null | undefined;
+}
+
+function fitIdentityPrefix(value: string, width: number): string {
+	return stripTerminalSequences(truncateToWidth(value, Math.max(0, width), "…", false));
 }
 
 export interface TargetLabelOptions {
@@ -31,6 +52,8 @@ export interface TargetLabelOptions {
 	separator?: string;
 	/** Off for surfaces with room for the whole wire id. */
 	abbreviate?: boolean;
+	/** Fit raw target/model fields once, preserving family and suffix before placement. */
+	width?: number;
 }
 
 /**
@@ -53,12 +76,25 @@ export function formatTargetLabel(
 	modelId: string | null | undefined,
 	options: TargetLabelOptions = {},
 ): string {
-	const target = (targetId ?? "").trim();
-	const model = (modelId ?? "").trim();
-	if (target.length === 0 && model.length === 0) return "not configured";
+	const target = sanitizeCallTargetText(targetId ?? "");
+	const model = sanitizeCallTargetText(modelId ?? "");
+	const fit = (label: string): string => (options.width === undefined ? label : fitIdentityLabel(label, options.width));
+	if (target.length === 0 && model.length === 0) return fit("not configured");
+	if (options.width !== undefined && target.length > 0 && model.length > 0) {
+		const width = Math.max(0, Math.floor(options.width));
+		const separator = options.separator ?? " · ";
+		const full = `${target}${separator}${model}`;
+		if (visibleWidth(full) <= width) return full;
+		const leaf = model.slice(model.lastIndexOf("/") + 1);
+		const available = width - visibleWidth(separator);
+		if (available < 9) return fitIdentityLabel(leaf, width);
+		const modelBudget = Math.min(visibleWidth(leaf), Math.max(8, Math.ceil(available * 0.7)));
+		const targetBudget = Math.min(visibleWidth(target), available - modelBudget);
+		return `${fitIdentityPrefix(target, targetBudget)}${separator}${fitIdentityLabel(leaf, available - targetBudget)}`;
+	}
 	const shown = options.abbreviate === false ? model : abbreviateModelId(model);
-	if (target.length === 0) return `no target · ${shown}`;
-	if (model.length === 0) return `${target} · no model`;
+	if (target.length === 0) return fit(`no target · ${shown}`);
+	if (model.length === 0) return fit(`${target} · no model`);
 	return `${target}${options.separator ?? " · "}${shown}`;
 }
 

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

@@ -78,6 +78,9 @@ export interface TurnPersistence {
 	 * (reminder block, skill preamble, handoff, then the operator's words);
 	 * `operatorText`, when it differs, is what the operator actually typed and
 	 * is what a transcript replay renders under the operator marker.
+	 * `displayText` is the literal editor input when an expansion (a prompt
+	 * template or command) replaced it; the session picker and replay show it,
+	 * while compaction keeps reasserting the expanded `operatorText`.
 	 */
 	appendSubmittedUserTurn(
 		agentRuntime: AgentRuntime,
@@ -85,6 +88,7 @@ export interface TurnPersistence {
 		images: ReadonlyArray<unknown> | undefined,
 		synthetic: boolean,
 		operatorText?: string,
+		displayText?: string,
 	): string | null;
 	appendRetryStatus(status: RetryStatusPayload): void;
 	appendModelChangeEntry(target: ChatLoopTarget): void;
@@ -213,6 +217,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,
@@ -401,7 +408,7 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			finishTracedTurn("success", null);
 		},
 
-		appendSubmittedUserTurn(agentRuntime, text, images, synthetic, operatorText): string | null {
+		appendSubmittedUserTurn(agentRuntime, text, images, synthetic, operatorText, displayText): string | null {
 			if (!deps.session) return null;
 			if (!deps.session.current()) {
 				deps.session.create({
@@ -412,6 +419,7 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			}
 			const payload: Record<string, unknown> = images ? { content: [{ type: "text", text }, ...images] } : { text };
 			if (operatorText !== undefined && operatorText !== text) payload.operatorText = operatorText;
+			if (displayText !== undefined && displayText !== (operatorText ?? text)) payload.displayText = displayText;
 			if (synthetic) {
 				payload.synthetic = true;
 				payload.source = "middleware_request_continuation";

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-recovery.ts

@@ -275,7 +275,8 @@ export function createTurnRecovery(deps: TurnRecoveryDeps): TurnRecovery {
 						maxAttempts: settings.maxRetries,
 						errorMessage: message,
 					});
-					deps.emitNotice(message);
+					// The exhausted status already exposes this failure and retains its full
+					// diagnostic. A second raw notice bypasses bounded error presentation.
 					pruneFailedAssistantFromContext(agentRuntime.agent);
 					return true;
 				}

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,6 +403,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
 		) {
 			// Same target+runtime+model. Settings may still have moved
@@ -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;
 			},
@@ -559,20 +571,30 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			stallTimer = setTimeout(
 				() => {
 					stallTimer = null;
-					const stallMs = deps.retrySettings().streamStallMs;
+					const retry = deps.retrySettings();
 					// Zero disables the escalation; an operator who wants a stream to
 					// hang forever keeps that by setting `retry.streamStallMs: 0`.
-					if (stallMs <= 0) return;
+					if (retry.streamStallMs <= 0) return;
 					if (stallSuspendDepth > 0 || toolsInFlight > 0) {
-						armStallTimer(stallMs);
+						armStallTimer(retry.streamStallMs);
+						return;
+					}
+					// Silence before a call's first delta is not silence mid-stream. A
+					// local server that slept reloads the model and prefills cold before
+					// it can emit anything, which is minutes of healthy quiet; a stream
+					// that already produced output and stops is a wedged slot.
+					const awaitingFirstToken = apiCallStartedAt !== null && apiCallFirstDeltaAt === null;
+					if (awaitingFirstToken && retry.firstTokenStallMs <= 0) {
+						armStallTimer(retry.streamStallMs);
 						return;
 					}
+					const stallMs = awaitingFirstToken ? Math.max(retry.firstTokenStallMs, retry.streamStallMs) : retry.streamStallMs;
 					const idleMs = performance.now() - lastActivityAt;
 					if (idleMs < stallMs) {
 						armStallTimer(stallMs - idleMs);
 						return;
 					}
-					state.streamStallReason = `stream stalled: no output from ${localRuntime.targetId} for ${Math.round(idleMs / 1000)}s, aborting (stream timeout)`;
+					state.streamStallReason = `stream stalled: no ${awaitingFirstToken ? "first token" : "output"} from ${localRuntime.targetId} for ${Math.round(idleMs / 1000)}s, aborting (stream timeout)`;
 					localRuntime.agent.abort();
 				},
 				Math.max(1, delayMs),
@@ -755,7 +777,14 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 						typeof assistantEvent.delta === "string" &&
 						assistantEvent.delta.length > 0);
 				if (hasDelta && firstAssistantDeltaAt === null) firstAssistantDeltaAt = eventClock;
-				if (hasDelta && apiCallFirstDeltaAt === null) apiCallFirstDeltaAt = eventClock;
+				if (hasDelta && apiCallFirstDeltaAt === null) {
+					apiCallFirstDeltaAt = eventClock;
+					// The timer may be armed for the longer first-token window; the
+					// stream is live now, so the mid-stream window applies from here.
+					const stallMs = deps.retrySettings().streamStallMs;
+					clearStallTimer();
+					if (stallMs > 0) armStallTimer(stallMs);
+				}
 			}
 			if (enrichedEvent.type === "agent_end") {
 				context.noteRunCacheSummary(enrichedEvent.messages, runFirstCallVerdict);
@@ -777,6 +806,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 +941,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/artifacts.ts

@@ -1125,11 +1125,12 @@ export class WorkspaceArtifactProvider implements ArtifactProvider {
 				{
 					id: `workspace:${path}`,
 					category: this.category,
-					title: safeTitle(`${artifact.path} · ${artifact.tool}${kind}`, artifact.path),
+					title: safeTitle(`${basename(path)} · ${relative(workspace, path)} · ${artifact.tool}${kind}`, basename(path)),
 					timestamp: parseTime(artifact.timestamp),
 					sizeBytes: maybeSizeBytes(path),
 					path,
-					description: `${artifact.tool}${kind} · ${overwriteLabel}`,
+					description: `${artifact.tool}${kind} · ${overwriteLabel} · Workspace: ${workspace} · Turn: ${artifact.turnId}`,
+					...(this.deps.sessionMeta ? { sessionId: this.deps.sessionMeta.id } : {}),
 					toolName: artifact.tool,
 					searchText: [
 						artifact.path,