@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/interactive/slash-commands.ts

@@ -3,9 +3,15 @@ import { acceptanceFromTaskFlags } from "../cli/tasks.js";
 import { BusChannels } from "../core/bus-events.js";
 import { THINKING_LEVELS } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { resolveSettingsSection, SETTINGS_SECTIONS, type SettingsSectionId } from "../core/settings-navigation.js";
 import { parseCouncilReport, parseOracleResult } from "../domains/agents/index.js";
 import type { AgentSpec } from "../domains/agents/spec.js";
-import type { ContextInitOptions } from "../domains/context/init-options.js";
+import {
+	applyInitImplications,
+	CONTEXT_INIT_FLAG_TABLE,
+	type ContextInitOptions,
+	validateInitOptions,
+} from "../domains/context/init-options.js";
 import { AdmissionCanceledError } from "../domains/dispatch/admission-error.js";
 import type { DispatchContract, DispatchRequest } from "../domains/dispatch/contract.js";
 import { type AgentRoleFactsResolver, requestExecutionRole } from "../domains/dispatch/execution-role.js";
@@ -17,6 +23,7 @@ import { isExtensionCommandToken } from "../domains/extensions/operator-commands
 import type { OperatorExtensionRuntime } from "../domains/extensions/operator-runtime.js";
 import type { ExtensionOutput } from "../domains/extensions/public-api.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
+import type { DoctorFinding } from "../domains/lifecycle/doctor.js";
 import {
 	PANES_PRESET_IDS,
 	PANES_PRESETS,
@@ -106,16 +113,8 @@ type ArchiveCommandVariant =
 	| { kind: "archive-import"; path: string; dryRun: boolean; force: boolean }
 	| { kind: "archive-usage"; subcommand?: "export" | "import"; error?: string };
 
-export const SETTINGS_AREA_IDS = [
-	"chat",
-	"fleet",
-	"targets",
-	"context",
-	"safety",
-	"interface",
-	"integrations",
-] as const;
-export type SettingsAreaId = (typeof SETTINGS_AREA_IDS)[number];
+export const SETTINGS_AREA_IDS = SETTINGS_SECTIONS.map((section) => section.id);
+export type SettingsAreaId = SettingsSectionId;
 
 /** What `/library <verb> <ref>` asks the browser to review once it is open. */
 export type LibraryBrowseIntent = "install" | "update" | "enable" | "disable" | "remove";
@@ -137,6 +136,7 @@ export interface LibraryBrowseRequest {
 
 type SlashCommandVariant =
 	| { kind: "mcp"; argv: string[] }
+	| { kind: "doctor"; deep: boolean }
 	| { kind: "quit" }
 	| { kind: "help"; query?: string }
 	| { kind: "init"; options: InitCommandOptions }
@@ -707,6 +707,16 @@ export interface SlashCommandContext {
 	exportShareArchive?: (outPath: string) => { fileCount: number; path: string };
 	importShareArchive?: (path: string, options: { dryRun?: boolean; force?: boolean }) => ShareImportPlan;
 	openCost: () => void;
+	/**
+	 * `/doctor [deep]`: the CLI doctor's findings, rendered as one notice.
+	 * `deep` adds the live tool probe on the session's targets and the
+	 * validation-contract dry run at the session's autonomy. Absent on a host
+	 * with no providers, in which case the command says so.
+	 */
+	showDoctor?: (findings: ReadonlyArray<DoctorFinding>) => void;
+	runDoctor?: (options: {
+		deep: boolean;
+	}) => Promise<{ level: NoticeLevel; text: string; findings?: ReadonlyArray<DoctorFinding> }>;
 	/**
 	 * `/btw <question>`: one model round beside the session, answered in an
 	 * overlay. Nothing about it enters the transcript, the ledger, or the task
@@ -883,10 +893,6 @@ function isRunThinkingLevel(value: string): value is JobThinkingLevel {
 	return RUN_THINKING_LEVELS.some((level) => level === value);
 }
 
-function isSettingsAreaId(value: string): value is SettingsAreaId {
-	return SETTINGS_AREA_IDS.some((area) => area === value);
-}
-
 /** `/context compact` alone keeps a free-form optional instruction tail. */
 const COMPACT_POSITIONALS: ReadonlyArray<CommandPositionalSpec> = [
 	{ name: "instructions", required: false, rest: true },
@@ -1252,6 +1258,43 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			ctx.notice(result.code ? "error" : "info", result.text);
 		},
 	},
+	{
+		name: "doctor",
+		description: "Diagnose this install in-session; /doctor deep adds live tool probes and a contract dry run",
+		group: "Inspect",
+		kinds: ["doctor"],
+		args: { positionals: [{ name: "deep", required: false, values: ["deep"] }] },
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "doctor", reason: parsed.error };
+			if (parsed.positionals[0] && parsed.positionals[0] !== "deep")
+				return { kind: "usage-error", command: "doctor", reason: "doctor accepts only deep" };
+			return { kind: "doctor", deep: parsed.positionals[0] === "deep" };
+		},
+		handle(command, ctx) {
+			if (command.kind !== "doctor") return;
+			const runDoctor = ctx.runDoctor;
+			if (!runDoctor) {
+				ctx.notice("error", "doctor is not wired in this session; run clio-coder doctor from a shell");
+				return;
+			}
+			ctx.notice(
+				"info",
+				command.deep
+					? "doctor: running deep checks; the tool probe can load a cold local model and releases only that one"
+					: "doctor: running checks",
+			);
+			void (async () => {
+				try {
+					const report = await runDoctor({ deep: command.deep });
+					if (ctx.showDoctor && report.findings) ctx.showDoctor(report.findings);
+					else ctx.notice(report.level, report.text);
+				} catch (error) {
+					ctx.notice("error", `doctor failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				ctx.render();
+			})();
+		},
+	},
 	{
 		name: "extensions",
 		description: "Inspect harness extensions or reload their commands, hooks and operator UI",
@@ -1669,7 +1712,9 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			subcommands: {
 				compact: { positionals: [...COMPACT_POSITIONALS] },
 				recall: { positionals: [...RECALL_POSITIONALS] },
-				init: {},
+				init: {
+					flags: CONTEXT_INIT_FLAG_TABLE.flatMap(({ flag, aliases = [] }) => [flag, ...aliases].map((name) => ({ name }))),
+				},
 				refresh: {},
 				reset: {},
 			},
@@ -1681,8 +1726,16 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 					return { kind: "compact", instructions: parsed.rest };
 				case "recall":
 					return { kind: "context-recall", ref: parsed.positionals[0] ?? "" };
-				case "init":
-					return { kind: "init", options: {} };
+				case "init": {
+					const options: ContextInitOptions = {};
+					for (const { flag, aliases = [], field } of CONTEXT_INIT_FLAG_TABLE) {
+						if ([flag, ...aliases].some((name) => parsed.flags.has(name))) options[field] = true;
+					}
+					const reason = validateInitOptions(options);
+					return reason
+						? { kind: "usage-error", command: "context", reason }
+						: { kind: "init", options: applyInitImplications(options) };
+				}
 				case "refresh":
 					return { kind: "context-refresh" };
 				case "reset":
@@ -1904,7 +1957,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 					);
 					return;
 				case "disabled":
-					ctx.notice("warn", "task memory is disabled; enable memory.intervention before seeding");
+					ctx.notice("warn", "task memory is disabled; enable context.memory.enabled before seeding");
 					return;
 				case "not-found":
 					ctx.notice("info", "no structured task-memory snapshot found in the newest handoff");
@@ -2252,13 +2305,14 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 		fromArgs(parsed) {
 			if (parsed.error) return { kind: "usage-error", command: "settings", reason: parsed.error };
-			const area = parsed.positionals[0];
-			if (area === undefined) return { kind: "settings" };
-			if (!isSettingsAreaId(area)) {
+			const name = parsed.positionals[0];
+			if (name === undefined) return { kind: "settings" };
+			const area = resolveSettingsSection(name);
+			if (!area) {
 				return {
 					kind: "usage-error",
 					command: "settings",
-					reason: `Unknown area: ${area} (one of ${SETTINGS_AREA_IDS.join(", ")})`,
+					reason: `Unknown area: ${name} (one of ${SETTINGS_AREA_IDS.join(", ")})`,
 				};
 			}
 			return { kind: "settings", area, ...(parsed.positionals[1] ? { group: parsed.positionals[1] } : {}) };
@@ -2595,6 +2649,7 @@ const COMMAND_ORDER = [
 	"view",
 	"panes",
 	"cost",
+	"doctor",
 	"decisions",
 	"library",
 	"skills",

package/src/interactive/startup-background.ts

@@ -0,0 +1,131 @@
+import { publishClioCompileCache } from "../core/compile-cache.js";
+import type { ClioSettings } from "../core/config.js";
+import { canonicalEndpointUrl } from "../core/endpoint-key.js";
+import { endpointCapacityUsage } from "../domains/dispatch/index.js";
+import { observeCacheDeployment } from "../domains/providers/cache-deployment.js";
+import type { ProvidersContract, TargetStatus } from "../domains/providers/contract.js";
+import { canonicalEndpointKey, registerForegroundStream } from "../domains/providers/endpoint-capacity.js";
+import { type PrewarmRoundResult, runPrewarmRound } from "../engine/prewarm.js";
+import { recordStartupDiagnostic } from "./startup-diagnostics.js";
+
+interface StartupPreparation {
+	settings: Readonly<ClioSettings>;
+	providers: ProvidersContract;
+	signal: AbortSignal;
+	isBusy: () => boolean;
+	recordWarm?: (target: string, model: string, result: PrewarmRoundResult) => void;
+	/** Test seams; production always uses the normal engine and deployment checks. */
+	observe?: typeof observeCacheDeployment;
+	warm?: typeof runPrewarmRound;
+}
+
+/** One tiny inference handshake, not a claim to cache a future worker's prompt. */
+async function warmWorkerTarget(input: StartupPreparation, status: TargetStatus, modelId: string): Promise<void> {
+	const { target, runtime } = status;
+	if (!runtime || target.cache?.warm?.startup !== true || target.cache.retention === "none") return;
+	if (target.pricing && Object.values(target.pricing).some((rate) => rate > 0)) return;
+	const identity = JSON.stringify(target);
+	const signal = AbortSignal.any([
+		input.signal,
+		AbortSignal.timeout(Math.min(2000, target.cache.warm.maxDurationMs ?? 2000)),
+	]);
+	const auth = await input.providers.auth.resolveForTarget(target, runtime, { signal });
+	const deployment = await (input.observe ?? observeCacheDeployment)(target, modelId, {
+		signal,
+		...(auth.apiKey ? { gatewayApiKey: auth.apiKey } : {}),
+	});
+	if (
+		!deployment.endpoint ||
+		(deployment.warm !== "bounded" && !(deployment.backend === "lmstudio" && deployment.reason === "model-not-loaded"))
+	) {
+		recordStartupDiagnostic({
+			kind: "worker-warm",
+			target: target.id,
+			model: modelId,
+			ran: false,
+			reason: deployment.reason,
+		});
+		return;
+	}
+	if (signal.aborted || input.isBusy() || JSON.stringify(input.providers.getTarget(target.id)) !== identity) return;
+	if ((endpointCapacityUsage()[deployment.endpoint] ?? 0) > 0) return;
+	const model = runtime.synthesizeModel(target, modelId, input.providers.knowledgeBase?.lookup(modelId) ?? null);
+	const release = registerForegroundStream(deployment.endpoint);
+	let result: PrewarmRoundResult;
+	try {
+		result = await (input.warm ?? runPrewarmRound)({
+			model,
+			state: { systemPrompt: "", messages: [], tools: [], thinkingLevel: "off" },
+			...(auth.apiKey === undefined ? {} : { apiKey: auth.apiKey }),
+			signal,
+			maxInputTokens: Math.min(256, target.cache.warm.maxInputTokens ?? 256),
+			canSend: () =>
+				!signal.aborted && !input.isBusy() && JSON.stringify(input.providers.getTarget(target.id)) === identity,
+		});
+	} finally {
+		release();
+	}
+	input.recordWarm?.(target.id, modelId, result);
+	recordStartupDiagnostic({
+		kind: "worker-warm",
+		target: target.id,
+		model: modelId,
+		ran: true,
+		timing: result.timing,
+		aborted: result.aborted,
+		failed: Boolean(result.errorMessage),
+	});
+}
+
+/** Post-paint, bounded work. No model requests unless the target explicitly opts in. */
+export async function prepareWorkerTargets(input: StartupPreparation): Promise<void> {
+	const { settings, providers, signal, isBusy } = input;
+	if (signal.aborted || isBusy()) return;
+	publishClioCompileCache();
+	const routes = [
+		settings.fleet.default,
+		...Object.values(settings.fleet.profiles),
+		...Object.values(settings.fleet.rosters).flatMap((roster) => roster.members),
+	];
+	const mainTarget = settings.chat.target ? providers.getTarget(settings.chat.target) : null;
+	const mainEndpoints = new Set([
+		mainTarget ? canonicalEndpointKey(mainTarget) : null,
+		canonicalEndpointUrl(mainTarget?.cache?.deployment?.controlUrl),
+	]);
+	const endpoints = new Set<string>();
+	let remaining = 4;
+	for (const route of routes) {
+		if (signal.aborted || isBusy()) return;
+		if (!route.target || route.target === settings.chat.target || ("node" in route && route.node)) continue;
+		const status = providers.list().find((entry) => entry.target.id === route.target);
+		if (!status?.available || !status.runtime || status.runtime.kind !== "http") continue;
+		if (
+			status.runtime.tier !== "local-native" &&
+			!(
+				status.runtime.id === "litellm" &&
+				status.target.cache?.deployment?.backend === "lmstudio" &&
+				status.target.cache.warm?.startup === true
+			)
+		)
+			continue;
+		const endpoint =
+			canonicalEndpointUrl(status.target.cache?.deployment?.controlUrl) ?? canonicalEndpointKey(status.target);
+		if (!endpoint || mainEndpoints.has(endpoint) || endpoints.has(endpoint)) continue;
+		endpoints.add(endpoint);
+		if (remaining-- <= 0) break;
+		try {
+			if (status.health.lastCheckAt === null) {
+				await providers.probeTarget(route.target, {
+					reasoning: false,
+					tools: false,
+					signal: AbortSignal.any([signal, AbortSignal.timeout(1500)]),
+				});
+			}
+			if (signal.aborted || isBusy()) return;
+			const model = route.model ?? status.target.defaultModel;
+			if (model) await warmWorkerTarget(input, status, model);
+		} catch {
+			// Foreground admission retries normally. An optional warm is never a notice.
+		}
+	}
+}

package/src/interactive/startup-diagnostics.ts

@@ -0,0 +1,16 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { clioStateDir } from "../core/xdg.js";
+
+/** Diagnostics survive an empty session and never write into the terminal. */
+export function recordStartupDiagnostic(event: Record<string, unknown>): void {
+	const at = new Date().toISOString();
+	const directory = join(clioStateDir(), "startup");
+	void mkdir(directory, { recursive: true, mode: 0o700 })
+		.then(() =>
+			appendFile(join(directory, `${at.slice(0, 10)}.jsonl`), `${JSON.stringify({ ...event, at, pid: process.pid })}\n`, {
+				mode: 0o600,
+			}),
+		)
+		.catch(() => {});
+}

package/src/interactive/status/state-machine.ts

@@ -362,8 +362,20 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			return next;
 		}
 		case "message_start":
-		case "message_update":
 			return refreshMeaningful(prev, ctx);
+		case "message_update": {
+			const next = refreshMeaningful(prev, ctx);
+			const streamed = event.assistantMessageEvent;
+			const base = activePhaseAfterStuck(prev);
+			if (
+				(streamed.type === "toolcall_start" || streamed.type === "toolcall_delta") &&
+				CORE_ACTIVE_PHASES.has(base) &&
+				base !== "tool_running"
+			) {
+				return { ...next, phase: "writing", preparingToolCall: true, resumePhase: undefined };
+			}
+			return next;
+		}
 		case "tool_execution_update":
 			return refreshMeaningful(prev, ctx);
 		case "message_end":
@@ -413,7 +425,7 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 		}
 		case "thinking_delta": {
 			const base = activePhaseAfterStuck(prev);
-			const next = refreshMeaningful({ ...prev, phase: base }, ctx);
+			const next = refreshMeaningful({ ...prev, phase: base, preparingToolCall: false }, ctx);
 			// Model reasoning arriving while a tool still shows as running means the
 			// tool is done (its end never landed or was an admission block): the
 			// model is generating, nothing is executing, so drop the tool display.
@@ -432,7 +444,7 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 		}
 		case "text_delta": {
 			const base = activePhaseAfterStuck(prev);
-			const next = refreshMeaningful({ ...prev, phase: base }, ctx);
+			const next = refreshMeaningful({ ...prev, phase: base, preparingToolCall: false }, ctx);
 			// Streamed answer text while a tool still shows as running: same as
 			// above, the model is writing, so the running-tool spinner must clear.
 			if (base === "preparing" || base === "waiting_model" || base === "thinking" || base === "tool_running") {
@@ -460,6 +472,7 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			return {
 				...refreshMeaningful(prev, ctx),
 				phase: "tool_running",
+				preparingToolCall: false,
 				tool,
 				toolStartedAt: ctx.now,
 				activeTools: [...(prev.activeTools ?? []).filter((active) => active.toolCallId !== event.toolCallId), tool],

package/src/interactive/status/types.ts

@@ -94,6 +94,8 @@ export interface AgentStatus {
 	watchdogTier: WatchdogTier;
 	watchdogPeak: WatchdogTier;
 	localRuntime: boolean;
+	/** The model is streaming tool arguments; execution has not started. */
+	preparingToolCall?: boolean;
 	runId?: string | null | undefined;
 	resumePhase?: StatusPhase | undefined;
 	activePhases?: ReadonlySet<OverlayPhase> | undefined;

package/src/interactive/status/verbs.ts

@@ -53,7 +53,7 @@ function coreVerb(status: AgentStatus): { text: string; toneHint: VerbRender["to
 		case "thinking":
 			return { text: "Thinking", toneHint: "normal" };
 		case "writing":
-			return { text: "Writing", toneHint: "normal" };
+			return { text: status.preparingToolCall ? "Preparing tool call" : "Writing", toneHint: "normal" };
 		case "tool_running": {
 			const name = status.tool?.toolName ?? "tool";
 			if (name === ToolNames.Dispatch) return { text: "Waiting for worker", toneHint: "normal" };

package/src/interactive/terminal-lease.ts

@@ -9,6 +9,7 @@
  */
 
 import type { ClioSettings } from "../core/config.js";
+import { installDiagnosticSink } from "../core/diagnostics.js";
 import { getTerminationCoordinator } from "../core/termination.js";
 import {
 	type Component,
@@ -17,14 +18,14 @@ import {
 	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 { brandMark, clioTheme, GLYPH } from "./theme/index.js";
+import { type ClioKeybindingManager, createKeybindingManager, formatKeyLabel } from "./keybinding-manager.js";
+import { clioTheme, GLYPH } from "./theme/index.js";
+import { createBootWelcome } from "./welcome-dashboard.js";
 
 export const INSTANT_SHELL_ENV = "CLIO_CODER_INSTANT_SHELL";
 const DOUBLE_TAP_MS = 500;
@@ -137,34 +138,24 @@ class BootSubmissionPanel implements Component {
 }
 
 function stageZeroRoot(
-	mode: Readonly<ClioSettings>["interface"]["mode"],
+	settings: Readonly<ClioSettings>,
+	submitKeyLabel: string | null,
 	editor: ClioEditor,
 	pending: Component,
 	shutdownArmed: () => boolean,
+	keybindings: ClioKeybindingManager,
 ): 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(
-		`${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 heading = createBootWelcome(settings, submitKeyLabel, (action) => {
+		const key = keybindings.isDisabled(action) ? undefined : keybindings.getKeys(action)[0];
+		return key ? formatKeyLabel(key, "") : null;
+	});
 	const footer: Component = {
 		render: () =>
 			shutdownArmed() ? [theme.fg("warning", "Ctrl+C again to exit · typed input will be recovered")] : [""],
 		invalidate: () => {},
 	};
-	if (mode === "fullscreen") {
+	if (settings.interface.mode === "fullscreen") {
 		const document = new Container();
 		document.addChild(heading);
 		const transcript = new ScrollView(document, { follow: "end", primary: true, overscroll: "chain" });
@@ -199,12 +190,14 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 		getModelLabel: () =>
 			[settings.chat.target, settings.chat.model].filter((part) => part && part.length > 0).join("·") || "starting",
 		getThinkingLabel: () => settings.chat.thinkingLevel ?? "off",
+		getAutonomy: () => settings.safety.autonomy,
 		getSubmitKeyLabel: () => keybindings.getKeys("tui.input.submit")[0] ?? "Enter",
 		getNewlineKeyLabel: () => keybindings.getKeys("tui.input.newLine")[0] ?? "Ctrl+J",
 	};
 	const editorChromeProxy: EditorChrome = {
 		getModelLabel: () => editorChrome.getModelLabel(),
 		getThinkingLabel: () => editorChrome.getThinkingLabel(),
+		getAutonomy: () => editorChrome.getAutonomy?.() ?? settings.safety.autonomy,
 		isStreaming: () => editorChrome.isStreaming?.() ?? false,
 		isAwaitingApproval: () => editorChrome.isAwaitingApproval?.() ?? false,
 		getPermissionInspection: () => editorChrome.getPermissionInspection?.() ?? "none",
@@ -224,7 +217,15 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	editor.focused = true;
 	const pendingPanel = new BootSubmissionPanel();
 	let shutdownArmed = false;
-	const stage0 = stageZeroRoot(settings.interface.mode, editor, pendingPanel, () => shutdownArmed);
+	const submitKey = keybindings.isDisabled("tui.input.submit") ? undefined : keybindings.getKeys("tui.input.submit")[0];
+	const stage0 = stageZeroRoot(
+		settings,
+		submitKey ? formatKeyLabel(submitKey, "") : null,
+		editor,
+		pendingPanel,
+		() => shutdownArmed,
+		keybindings,
+	);
 	const host = new RootHost(stage0);
 
 	let state: TerminalLeaseState = "created";
@@ -245,6 +246,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	let closePromise: Promise<void> | null = null;
 	let inputDisposed = false;
 	let signalDisposed = false;
+	let removeDiagnosticSink = () => {};
 
 	const termination = options.testing?.termination ?? getTerminationCoordinator();
 	const signals = options.testing?.signals ?? process;
@@ -492,6 +494,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 					}
 				} finally {
 					state = "closed";
+					removeDiagnosticSink();
 				}
 				if (errors.length > 0) throw new AggregateError(errors, "terminal lease cleanup failed");
 			})();
@@ -502,6 +505,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 		},
 	};
 
+	removeDiagnosticSink = installDiagnosticSink((text) => lease.writeDiagnostic("stderr", text));
 	termination.onDrain(() => lease.close({ recoverInput: state !== "adopted" }));
 	try {
 		shell.mount(host, editor);

package/src/interactive/theme/components.ts

@@ -49,7 +49,7 @@ export function settingsListTheme(theme: ClioTheme): SettingsListTheme {
 
 export function editorTheme(theme: ClioTheme): EditorTheme {
 	return {
-		borderColor: (text) => theme.style("frameStrong", text, { bold: true }),
+		borderColor: (text) => theme.style("editor", text, { bold: true }),
 		selectList: selectListTheme(theme),
 	};
 }

package/src/interactive/theme/rules.ts

@@ -62,7 +62,7 @@ export function rule(theme: ClioTheme, width: number, options: RuleOptions = {})
 	const labelsWidth = visibleWidth(left) + visibleWidth(right);
 	if (labelsWidth >= safeWidth) return truncateToWidth(`${left}${right}`.trim(), safeWidth, "", true);
 	const fill = theme.style(options.fillToken ?? "frame", "─".repeat(safeWidth - labelsWidth), {
-		bold: options.fillToken === "frameStrong",
+		bold: options.fillToken === "frameStrong" || options.fillToken === "editor",
 	});
 	return `${left}${fill}${right}`;
 }

package/src/interactive/theme/tokens.ts

@@ -8,23 +8,29 @@ interface TokenColor {
 }
 
 const TOKENS: Record<ClioToken, TokenColor> = {
-	accent: { rgb: [70, 229, 208], xterm: 80 },
-	accentDeep: { rgb: [31, 183, 166], xterm: 44 },
-	// Second brand color: neon orange. The token name teaches the rule: orange
+	// The composer rails alone own the neon intensity tier.
+	editor: { rgb: [64, 255, 191], xterm: 85 },
+	editorDanger: { rgb: [255, 80, 88], xterm: 203 },
+	editorAction: { rgb: [255, 171, 69], xterm: 215 },
+	accent: { rgb: [83, 177, 150], xterm: 72 },
+	accentDeep: { rgb: [62, 147, 137], xterm: 66 },
+	tool: { rgb: [111, 173, 165], xterm: 109 },
+	agent: { rgb: [207, 144, 91], xterm: 173 },
+	// Secondary orange remains below the composer intensity tier. The token name teaches the rule: orange
 	// means Clio is acting. It fires only for Clio's signature actions
 	// (dispatching, queued and running fleet work, steering) and for the border
 	// of a prompt that has taken the keyboard and is waiting on a decision, never
 	// as decoration, and never a metric, at most one orange element per region of
 	// the screen. warning stays the soft amber for actual warnings.
-	action: { rgb: [255, 126, 41], xterm: 208 },
-	success: { rgb: [87, 227, 137], xterm: 114 },
-	warning: { rgb: [255, 180, 84], xterm: 221 },
-	error: { rgb: [255, 92, 102], xterm: 203 },
-	info: { rgb: [91, 168, 255], xterm: 75 },
-	reason: { rgb: [157, 140, 255], xterm: 141 },
+	action: { rgb: [217, 155, 98], xterm: 179 },
+	success: { rgb: [119, 184, 145], xterm: 108 },
+	warning: { rgb: [211, 176, 107], xterm: 179 },
+	error: { rgb: [219, 130, 137], xterm: 174 },
+	info: { rgb: [128, 167, 206], xterm: 110 },
+	reason: { rgb: [175, 155, 201], xterm: 146 },
 	dim: { rgb: [106, 122, 133], xterm: 59 },
 	muted: { rgb: [138, 153, 164], xterm: 102 },
-	title: { rgb: [70, 229, 208], xterm: 80 },
+	title: { rgb: [114, 184, 173], xterm: 109 },
 	frame: { rgb: [47, 93, 90], xterm: 23 },
 	frameStrong: { rgb: [42, 171, 158], xterm: 37 },
 };

package/src/interactive/transcript-detail.ts

@@ -4,6 +4,7 @@ import type { OutputStyle } from "../core/defaults.js";
 export interface TranscriptDetailPolicy {
 	style: OutputStyle;
 	reasoningRows: number;
+	invocationRows: number;
 	resultRows: number;
 	bashRows: number;
 	operatorBashRows: number;
@@ -17,6 +18,7 @@ export interface TranscriptDetailPolicy {
 const POLICIES: Record<OutputStyle, TranscriptDetailPolicy> = {
 	compact: {
 		style: "compact",
+		invocationRows: 4,
 		reasoningRows: 0,
 		resultRows: 0,
 		bashRows: 0,
@@ -29,6 +31,7 @@ const POLICIES: Record<OutputStyle, TranscriptDetailPolicy> = {
 	},
 	standard: {
 		style: "standard",
+		invocationRows: 8,
 		reasoningRows: 3,
 		resultRows: 0,
 		bashRows: 0,
@@ -41,6 +44,7 @@ const POLICIES: Record<OutputStyle, TranscriptDetailPolicy> = {
 	},
 	detailed: {
 		style: "detailed",
+		invocationRows: 18,
 		reasoningRows: 12,
 		resultRows: 8,
 		bashRows: 12,