@iowarp/clio-coder 0.4.5 → 0.4.7

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/status/controller.ts

@@ -206,9 +206,6 @@ export function createStatusController(deps: StatusControllerDeps): StatusContro
 			deps.bus.on(BusChannels.PermissionResolved, () => apply({ type: "overlay_pop", overlay: "tool_blocked" }, true)),
 			deps.bus.on(BusChannels.CompactionBegin, () => apply({ type: "overlay_push", overlay: "compacting" }, true)),
 			deps.bus.on(BusChannels.CompactionEnd, () => apply({ type: "overlay_pop", overlay: "compacting" }, true)),
-			deps.bus.on(BusChannels.DispatchStarted, (payload) =>
-				apply({ type: "overlay_push", overlay: "dispatching", data: payload }, true),
-			),
 			deps.bus.on(BusChannels.DispatchProgress, (payload) => {
 				if (!isWorkerStreamEvidence(payload)) return;
 				const at = now();
@@ -216,8 +213,6 @@ export function createStatusController(deps: StatusControllerDeps): StatusContro
 				lastDispatchProgressAt = at;
 				apply({ type: "dispatch_progress" });
 			}),
-			deps.bus.on(BusChannels.DispatchCompleted, () => apply({ type: "overlay_pop", overlay: "dispatching" }, true)),
-			deps.bus.on(BusChannels.DispatchFailed, () => apply({ type: "overlay_pop", overlay: "dispatching" }, true)),
 			deps.bus.on(BusChannels.RunAborted, (payload) => {
 				scheduleAbortCeiling();
 				// Carry abort provenance into the summary; a dispatch drain and a

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

@@ -245,6 +245,7 @@ function activePhaseAfterStuck(prev: AgentStatus): StatusPhase {
 }
 
 function isAwaitingDispatch(prev: AgentStatus): boolean {
+	if (activePhaseAfterStuck(prev) === "tool_running" && prev.tool?.toolName === ToolNames.Dispatch) return true;
 	if (prev.phase === "dispatching") return true;
 	if (prev.activePhases?.has("dispatching")) return true;
 	return (prev.overlayStack ?? []).some((frame) => frame.phase === "dispatching");
@@ -360,26 +361,9 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			if (base === "preparing") return { ...next, phase: "waiting_model", resumePhase: undefined };
 			return next;
 		}
-		case "message_start": {
-			const next = refreshMeaningful(prev, ctx);
-			const role = (event.message as { role?: unknown }).role;
-			if (role === "assistant" && prev.phase === "tool_running") return { ...next, phase: "writing" };
-			if (
-				role === "assistant" &&
-				(prev.phase === "preparing" || prev.phase === "waiting_model" || prev.phase === "thinking")
-			)
-				return { ...next, phase: "writing", resumePhase: undefined };
-			return next;
-		}
-		case "message_update": {
-			const base = activePhaseAfterStuck(prev);
-			const next = refreshMeaningful({ ...prev, phase: base }, ctx);
-			if (base === "preparing" || base === "waiting_model" || base === "thinking") {
-				return { ...next, phase: "writing", resumePhase: undefined };
-			}
-			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
-			return next;
-		}
+		case "message_start":
+		case "message_update":
+			return refreshMeaningful(prev, ctx);
 		case "tool_execution_update":
 			return refreshMeaningful(prev, ctx);
 		case "message_end":
@@ -390,10 +374,22 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 				runTally: foldMessageIntoRunTally(prev.runTally ?? emptyRunTally(), event.message),
 			};
 		case "tool_execution_end": {
-			const next = refreshMeaningful(prev, ctx);
-			if (prev.phase === "tool_running") return { ...next, phase: "preparing", tool: undefined, toolStartedAt: undefined };
+			const activeTools = (prev.activeTools ?? []).filter((tool) => tool.toolCallId !== event.toolCallId);
+			const next = { ...refreshMeaningful(prev, ctx), activeTools };
+			const remaining = activeTools.at(-1);
+			if (remaining && prev.phase === "tool_running")
+				return { ...next, tool: remaining, toolStartedAt: remaining.startedAt };
+			if (prev.phase === "tool_running")
+				return { ...next, phase: "preparing", tool: undefined, toolStartedAt: undefined, activeTools: [] };
 			if (prev.phase === "stuck" && prev.resumePhase === "tool_running") {
-				return { ...next, phase: "preparing", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "preparing",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			// A blocked call's end can land while an overlay is still visible
 			// (permission prompt not yet resolved, retry or dispatch in front).
@@ -422,7 +418,14 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			// tool is done (its end never landed or was an admission block): the
 			// model is generating, nothing is executing, so drop the tool display.
 			if (base === "preparing" || base === "waiting_model" || base === "writing" || base === "tool_running") {
-				return { ...next, phase: "thinking", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "thinking",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
 			return next;
@@ -433,19 +436,34 @@ export function reduceStatus(prev: AgentStatus, event: StatusInputEvent, ctx: Re
 			// 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") {
-				return { ...next, phase: "writing", resumePhase: undefined, tool: undefined, toolStartedAt: undefined };
+				return {
+					...next,
+					phase: "writing",
+					resumePhase: undefined,
+					tool: undefined,
+					toolStartedAt: undefined,
+					activeTools: [],
+				};
 			}
 			if (CORE_ACTIVE_PHASES.has(base)) return { ...next, resumePhase: undefined };
 			return next;
 		}
 		case "tool_execution_start": {
 			const tool: ToolOverlay = {
+				toolCallId: event.toolCallId,
+				startedAt: ctx.now,
 				toolName: event.toolName,
 				toolPreview: compactPreview(event.args),
 			};
 			// Stamp this call's own start so the footer's running-tool timer counts
 			// from here, not from turn start.
-			return { ...refreshMeaningful(prev, ctx), phase: "tool_running", tool, toolStartedAt: ctx.now };
+			return {
+				...refreshMeaningful(prev, ctx),
+				phase: "tool_running",
+				tool,
+				toolStartedAt: ctx.now,
+				activeTools: [...(prev.activeTools ?? []).filter((active) => active.toolCallId !== event.toolCallId), tool],
+			};
 		}
 		case "retry_status": {
 			const phase = event.status.phase;

package/src/interactive/status/types.ts

@@ -19,6 +19,8 @@ export interface RetryOverlay {
 }
 
 export interface ToolOverlay {
+	toolCallId?: string;
+	startedAt?: number;
 	toolName: string;
 	toolPreview: string;
 }
@@ -104,6 +106,7 @@ export interface AgentStatus {
 	 * phase leaves `tool_running`.
 	 */
 	toolStartedAt?: number | undefined;
+	activeTools?: readonly ToolOverlay[];
 	retry?: RetryOverlay | undefined;
 	dispatch?: DispatchOverlay | undefined;
 	/**

package/src/interactive/status/verbs.ts

@@ -44,30 +44,31 @@ function coreVerb(status: AgentStatus): { text: string; toneHint: VerbRender["to
 		case "idle":
 			return null;
 		case "preparing":
-			return { text: tier >= 2 ? "still preparing harness" : "preparing harness", toneHint: "normal" };
+			return { text: "Preparing", toneHint: "normal" };
 		case "waiting_model":
 			return {
-				text: tier >= 2 ? "still waiting on model" : status.localRuntime ? "waiting on local model" : "waiting on model",
+				text: tier >= 2 ? "Waiting for model" : status.localRuntime ? "Waiting for local model" : "Waiting for model",
 				toneHint: "normal",
 			};
 		case "thinking":
-			return { text: tier >= 2 ? "still receiving thinking" : "receiving thinking", toneHint: "normal" };
+			return { text: "Thinking", toneHint: "normal" };
 		case "writing":
-			return { text: "streaming response", toneHint: "normal" };
+			return { text: "Writing", toneHint: "normal" };
 		case "tool_running": {
 			const name = status.tool?.toolName ?? "tool";
-			if (name === ToolNames.AskUser) return { text: "waiting for user input", toneHint: "normal" };
-			return { text: tier >= 2 ? `still running tool: ${name}` : `running tool: ${name}`, toneHint: "normal" };
+			if (name === ToolNames.Dispatch) return { text: "Waiting for worker", toneHint: "normal" };
+			if (name === ToolNames.AskUser) return { text: "Needs input", toneHint: "normal" };
+			return { text: `Running ${name}`, toneHint: "normal" };
 		}
 		case "tool_blocked":
-			return { text: "awaiting confirmation", toneHint: "warn" };
+			return { text: "Needs approval", toneHint: "warn" };
 		case "retrying": {
 			const retry = status.retry;
 			const wait = retry && retry.waitMs > 0 ? ` · ${formatStatusElapsed(retry.waitMs)}` : "";
 			return { text: `retrying ${retry?.attempt ?? 0}/${retry?.maxAttempts ?? 0}${wait}`, toneHint: "warn" };
 		}
 		case "compacting":
-			return { text: "compacting context", toneHint: "normal" };
+			return { text: "Compacting context", toneHint: "normal" };
 		case "dispatching": {
 			const agent = status.dispatch?.agentName;
 			if (tier >= 2)
@@ -75,7 +76,7 @@ function coreVerb(status: AgentStatus): { text: string; toneHint: VerbRender["to
 			return { text: agent ? `dispatching agent: ${agent}` : "dispatching agent", toneHint: "normal" };
 		}
 		case "stuck":
-			return { text: "stuck", toneHint: "error" };
+			return { text: "No output", toneHint: "error" };
 		case "ended": {
 			const stop = status.summary?.stopReason ?? "stop";
 			const elapsed = status.summary ? ` · ${formatStatusElapsed(status.summary.elapsedMs)}` : "";
@@ -97,7 +98,7 @@ export function resolveFooterVerb(status: AgentStatus, now: number, terminalCols
 	if (status.phase === "stuck") {
 		const elapsed = elapsedSince(status, now);
 		return {
-			text: terminalCols < 60 ? "stuck" : `stuck · ${elapsed} · Esc to cancel`,
+			text: terminalCols < 60 ? "No output" : `No output · ${elapsed} · Esc to cancel`,
 			toneHint: "error",
 		};
 	}
@@ -117,12 +118,12 @@ function inlineParts(
 	terminalCols: number,
 ): { text: string; hint: string | null; toneHint: VerbRender["toneHint"] } | null {
 	if (status.phase === "stuck")
-		return { text: `Stuck for ${elapsedSince(status, now)}.`, hint: "Press Esc to cancel.", toneHint: "error" };
+		return { text: `No output for ${noProgressSince(status, now)}.`, hint: "Press Esc to cancel.", toneHint: "error" };
 	const core = coreVerb(status);
 	if (!core) return null;
 	const text = core.text.replace(/^[a-z]/, (c) => c.toUpperCase());
 	if (status.watchdogTier >= 3) {
-		const hint = terminalCols < 50 ? null : `(no progress for ${noProgressSince(status, now)}; press Esc to cancel)`;
+		const hint = terminalCols < 50 ? null : `(no output for ${noProgressSince(status, now)}; press Esc to cancel)`;
 		return { text, hint, toneHint: core.toneHint };
 	}
 	if (terminalCols < 50 || status.phase === "tool_blocked") return { text, hint: null, toneHint: core.toneHint };

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/transcript-detail.ts

@@ -1,120 +1,58 @@
-/**
- * Transcript detail policy: the one place `/output minimal|default|verbose`
- * becomes a decision about how much of each foldable transcript block is open
- * before the operator touches it.
- *
- * The chat panel used to consult the verbosity string in four places, each
- * spelling the rule a little differently, and nothing else (running rows, live
- * tool output, worker cards in replay) consulted it at all. The panel now reads
- * this policy once per frame and threads it down; the verbosity string never
- * reaches a renderer.
- *
- * Operator toggles (`Alt+O`, `Alt+R`, expand-all, collapse-all) are overrides
- * layered on top of this policy, not fights with it: the effective state of a
- * block is `override ?? policy`, and `resolveFold` is that one rule.
- *
- * Pure module: no I/O, no UI imports.
- */
-
-import type { OutputVerbosity } from "../core/defaults.js";
-import type { ToolFoldDefault, ToolPresentationPolicy } from "../tools/presentation.js";
-
-/** A block's fold state. The same vocabulary serves tools, workers, thinking, and local bash. */
-export type Fold = ToolFoldDefault;
-
-/** An operator's explicit choice for one block, or none. */
-export type FoldOverride = Fold | undefined;
+/** Presentation budgets for the same captured session. Detailed is still bounded. */
+import type { OutputStyle } from "../core/defaults.js";
 
 export interface TranscriptDetailPolicy {
-	/** Finished tool call body: folded subline, the tool's own default, or open. */
-	toolBody: "folded" | "per-tool" | "expanded";
-	/** In-flight tool call: one-line row with elapsed, or the header plus streaming body. */
-	runningTool: "row" | "body";
-	/** Reasoning stretch: bare marker, folded marker with live progress, or the open rail. */
-	thinking: "marker" | "folded" | "rail";
-	/** Worker block: folded card, the origin default, or open. */
-	worker: "folded" | "origin" | "expanded";
-	/** Settled turn receipt: none, `turn · in N · out M`, or the full receipt. */
+	style: OutputStyle;
+	reasoningRows: number;
+	resultRows: number;
+	bashRows: number;
+	operatorBashRows: number;
+	diffRows: number;
+	workerRows: number;
+	workerActivity: boolean;
+	errorRows: number;
 	receipt: "none" | "compact" | "full";
-	/** Failed tool under its folded row: the bounded excerpt, or the full body. */
-	errors: "excerpt" | "body";
 }
 
-const MINIMAL: TranscriptDetailPolicy = {
-	toolBody: "folded",
-	runningTool: "row",
-	thinking: "marker",
-	worker: "folded",
-	receipt: "none",
-	errors: "excerpt",
-};
-
-const DEFAULT: TranscriptDetailPolicy = {
-	toolBody: "per-tool",
-	runningTool: "row",
-	thinking: "folded",
-	worker: "origin",
-	receipt: "compact",
-	errors: "excerpt",
+const POLICIES: Record<OutputStyle, TranscriptDetailPolicy> = {
+	compact: {
+		style: "compact",
+		reasoningRows: 0,
+		resultRows: 0,
+		bashRows: 0,
+		operatorBashRows: 3,
+		diffRows: 0,
+		workerRows: 0,
+		workerActivity: false,
+		errorRows: 4,
+		receipt: "none",
+	},
+	standard: {
+		style: "standard",
+		reasoningRows: 3,
+		resultRows: 0,
+		bashRows: 0,
+		operatorBashRows: 6,
+		diffRows: 8,
+		workerRows: 3,
+		workerActivity: false,
+		errorRows: 4,
+		receipt: "compact",
+	},
+	detailed: {
+		style: "detailed",
+		reasoningRows: 12,
+		resultRows: 8,
+		bashRows: 12,
+		operatorBashRows: 12,
+		diffRows: 20,
+		workerRows: 8,
+		workerActivity: true,
+		errorRows: 12,
+		receipt: "full",
+	},
 };
 
-const VERBOSE: TranscriptDetailPolicy = {
-	toolBody: "expanded",
-	runningTool: "body",
-	thinking: "rail",
-	worker: "expanded",
-	receipt: "full",
-	errors: "body",
-};
-
-/**
- * Map a verbosity to the full policy table. An absent verbosity (a panel built
- * without settings) is the balanced default, so the literal never has to be
- * spelled by the caller.
- */
-export function transcriptDetail(verbosity: OutputVerbosity | undefined): TranscriptDetailPolicy {
-	switch (verbosity) {
-		case "minimal":
-			return MINIMAL;
-		case "verbose":
-			return VERBOSE;
-		default:
-			return DEFAULT;
-	}
-}
-
-/** Effective state of one block: the operator's override when set, else the policy's answer. */
-export function resolveFold(override: FoldOverride, policyFold: Fold): Fold {
-	return override ?? policyFold;
-}
-
-/** The fold the policy gives a finished tool call, through the tool's own presentation when asked to. */
-export function policyToolFold(detail: TranscriptDetailPolicy, presentation: ToolPresentationPolicy): Fold {
-	if (detail.toolBody === "per-tool") return presentation.foldDefault;
-	return detail.toolBody;
-}
-
-/** The fold the policy gives an in-flight tool call. */
-export function policyRunningToolFold(detail: TranscriptDetailPolicy): Fold {
-	return detail.runningTool === "body" ? "expanded" : "folded";
-}
-
-/** The fold the policy gives a reasoning stretch. */
-export function policyThinkingFold(detail: TranscriptDetailPolicy): Fold {
-	return detail.thinking === "rail" ? "expanded" : "folded";
-}
-
-/**
- * The fold the policy gives a worker block. `askedByModel` is the origin rule
- * the caller already knows: a run the model asked for folds, the operator's own
- * run opens.
- */
-export function policyWorkerFold(detail: TranscriptDetailPolicy, askedByModel: boolean): Fold {
-	if (detail.worker === "origin") return askedByModel ? "folded" : "expanded";
-	return detail.worker;
-}
-
-/** The override that flips a block away from its current effective state. */
-export function toggledFold(effective: Fold): Fold {
-	return effective === "expanded" ? "folded" : "expanded";
+export function transcriptDetail(style: OutputStyle = "standard"): TranscriptDetailPolicy {
+	return POLICIES[style];
 }

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

@@ -398,7 +398,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		) {
 			// 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(

package/src/interactive/view/artifacts.ts

@@ -44,6 +44,7 @@ import { clockLocal } from "../format-time.js";
 import { abbreviateModelId } from "../theme/index.js";
 
 export type ViewArtifactCategory =
+	| "transcript"
 	| "accountability"
 	| "evidence"
 	| "receipt"
@@ -86,6 +87,7 @@ export interface ArtifactProvider {
 }
 
 export interface ArtifactProviderDeps {
+	readTranscript?: (() => ViewArtifact[]) | undefined;
 	stateDir: string;
 	dataDir?: string | undefined;
 	dispatch?: Pick<DispatchContract, "listRuns" | "getRun"> | undefined;
@@ -94,6 +96,7 @@ export interface ArtifactProviderDeps {
 }
 
 export const VIEW_ARTIFACT_CATEGORIES: readonly ViewArtifactCategory[] = [
+	"transcript",
 	"accountability",
 	"evidence",
 	"receipt",
@@ -1560,6 +1563,7 @@ export class SafetyAuditArtifactProvider implements ArtifactProvider {
 
 export function createDefaultArtifactProviders(deps: ArtifactProviderDeps): ArtifactProvider[] {
 	return [
+		{ category: "transcript", list: async () => deps.readTranscript?.() ?? [] },
 		new AccountabilityArtifactProvider(deps),
 		new EvidenceArtifactProvider(deps),
 		new ReceiptArtifactProvider(deps),