@iowarp/clio-coder 0.4.6 → 0.4.8

package/src/entry/orchestrator.ts

@@ -36,7 +36,7 @@ import {
 import { getSharedBus } from "../core/shared-bus.js";
 import { isSkillActivation } from "../core/skill-activation.js";
 import { StartupTimer } from "../core/startup-timer.js";
-import { getTerminationCoordinator } from "../core/termination.js";
+import { getTerminationCoordinator, resolveShutdownHookBudgetMs } from "../core/termination.js";
 import { captureProjectSurface, projectSurfaceTrustNotice } from "../core/workspace-trust.js";
 import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import { renderAgentCatalogSectionsFromSpecs } from "../domains/agents/catalog.js";
@@ -108,6 +108,7 @@ import type { BackgroundMemoryUsageSink } from "../domains/observability/backgro
 import { recordFailedCompactionCalls } from "../domains/observability/compaction-usage.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import { ObservabilityDomainModule } from "../domains/observability/index.js";
+import { PluginsDomainModule } from "../domains/plugins/index.js";
 import type { PromptsContract } from "../domains/prompts/contract.js";
 import { createPromptsDomainModule } from "../domains/prompts/index.js";
 import type { ProvidersContract, TargetDescriptor, ThinkingLevel } from "../domains/providers/index.js";
@@ -199,6 +200,7 @@ import type { BootOptions } from "./boot-options.js";
 import { readCompactionSystemPrompt } from "./compaction-prompt.js";
 import { createExtensionReloadCoordinator } from "./extension-reload.js";
 import { resolvePanesEnablement } from "./panes-activation.js";
+import { reloadPluginResourcesAndNotify } from "./plugin-reload.js";
 import { bindTaskMemoryLifecycle, captureTaskMemoryUsage } from "./task-memory-lifecycle.js";
 
 export type { BootOptions, HeadlessSamplingOverrides } from "./boot-options.js";
@@ -1005,7 +1007,7 @@ function estimateTokensAfterCompaction(entries: ReadonlyArray<SessionEntry>, res
 }
 
 /**
- * Alt+J / Alt+K step the orchestrator through the `scope` list of target
+ * Scoped model cycle actions step the orchestrator through the `scope` list of target
  * ids or target/model refs. Absent scope is a no-op so unconfigured users
  * feel nothing.
  */
@@ -1140,6 +1142,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		[
 			options.startupSettings ? createConfigDomainModule(options.startupSettings) : ConfigDomainModule,
 			ExtensionsDomainModule,
+			PluginsDomainModule,
 			InteropDomainModule,
 			createResourcesDomainModule({
 				reservedPromptNames: new Set(BUILTIN_SLASH_COMMANDS.map((entry) => entry.name)),
@@ -1200,8 +1203,10 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			await dispatch.drain();
 		});
 	}
-	termination.onPersist(async () => {
-		await result.stop();
+	// The loader caps each domain separately. The outer hook must allow the
+	// whole sequence to finish, including cleanup after a timed-out domain.
+	termination.onPersist(() => result.stop(), {
+		timeoutMs: Math.min(2 ** 31 - 1, (result.loaded.length + 1) * resolveShutdownHookBudgetMs()),
 	});
 
 	bus.emit(BusChannels.SessionStart, { at: Date.now() });
@@ -1370,12 +1375,10 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// this boot projection below.
 	configureRunEventJournal(resolvedSettings.fleet.history.journal);
 
-	// Guard registrations on the middleware contract, in order: loop guard,
-	// protected artifacts (last among guards so it absorbs protect_path effects
-	// from everything before it), dispatch dedup. Workers register their own
-	// loop guard and protected-artifacts instances inside their subprocess in
-	// worker-runtime.ts; the orchestrator instances carry the bus and the
-	// session persistence sink.
+	// Register the loop and dispatch guards first. The protected-artifact guard
+	// is constructed here but registered after user hooks below, so it can
+	// absorb their protect_path effects. Workers register their own guards in
+	// worker-runtime.ts; these instances carry the bus and session persistence.
 	middleware.registerHook(
 		createLoopGuardRegistration({
 			safety,
@@ -1424,7 +1427,6 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		}
 		return protectedArtifactsGuard.state();
 	};
-	middleware.registerHook(protectedArtifactsGuard);
 	middleware.registerHook(createDispatchDedupRegistration());
 	// Observers run after the guards; they emit no effects and their sinks are
 	// best-effort (session ledger, codewiki refresh).
@@ -1522,9 +1524,9 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	}
 	// User-defined hooks: extensions and the project (.clio-coder/hooks.yaml,
 	// .clio-coder/hooks.local.yaml) declare a conservative, receipted hook set on the
-	// same effect machinery. They register after the guards, so safety stays
-	// authoritative: a hook may add effects (including request block_tool) but
-	// cannot grant a permission safety would deny. Loading is best-effort.
+	// same effect machinery. A hook may add effects (including request block_tool)
+	// but cannot grant a permission safety would deny. The protected-artifact
+	// guard follows them to consume protect_path before tool execution.
 	// The coordinator is the only writer of the "user-hooks" owner and the only
 	// caller of the extensions reload; it publishes the extension generation
 	// and the hook registrations with two adjacent assignments on one stack
@@ -1532,9 +1534,11 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// published here too (the extensions bundle publishes nothing at start),
 	// so no consumer ever sees extension resources paired with hooks from a
 	// different generation. The owner slot is anchored here, so user hooks
-	// keep evaluating after the guards and before the assessors below.
+	// keep evaluating before the protection consumer and assessors below.
 	const hookReceiptLog = createHookReceiptLog({ persistPath: join(clioStateDir(), "hook-receipts.json") });
 	let bootHookNotices = true;
+	const reloadPlugins = () =>
+		reloadPluginResourcesAndNotify(process.cwd(), (event) => bus.emit(BusChannels.PluginsReloaded, event));
 	const extensionReload = createExtensionReloadCoordinator({
 		extensions,
 		middleware,
@@ -1545,9 +1549,13 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			else if (bootHookNotices) initialNotices.push(line);
 			else bus.emit(BusChannels.ExtensionsLoadIssue, { message: line });
 		},
-		onCommitted: (event) => bus.emit(BusChannels.ExtensionsReloaded, event),
+		onCommitted: (event) => {
+			reloadPlugins();
+			bus.emit(BusChannels.ExtensionsReloaded, event);
+		},
 	});
 	extensionReload.applyBoot();
+	middleware.registerHook(protectedArtifactsGuard);
 	bootHookNotices = false;
 	termination.onDrain(() => hookReceiptLog.flush());
 	// Autonomy is hot-reloaded for interactive and headless admissions. ACP
@@ -1593,7 +1601,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				listInstalledSkillNames: () => resources.skills(process.cwd()).items.map((skill) => skill.name),
 				listMarketplaceEntries: () => discoverMarketplaceSkills({ cwd: process.cwd() }).skills,
 				installEntry: (entry, scope) => {
-					const installed = installSkill({ source: entry.sourceUrl, scope, name: entry.name, cwd: process.cwd() });
+					const installed = installSkill({ source: `skill:${entry.name}`, scope, name: entry.name, cwd: process.cwd() });
 					return { path: installed.path, sourceUrl: installed.sourceUrl, installedHash: installed.installedHash };
 				},
 			}),
@@ -1718,6 +1726,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				})
 			: null;
 	registerAllTools(toolRegistry, {
+		captureWorkerContext: () => chat.captureWorkerContext?.() ?? null,
 		...(session
 			? {
 					session,
@@ -1803,7 +1812,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	const getCurrentSettings = (): ClioSettings => {
 		// Recents live in the data dir (core/recent-models.ts), never in
 		// settings.yaml; consumers that need them call listRecentModels
-		// directly, so an Alt+L pick in another session does not churn the
+		// directly, so an Alt+M pick in another session does not churn the
 		// config watcher here.
 		const base = config?.get();
 		// No config domain (unit tests, degraded boot): readSettings() returns a
@@ -1827,8 +1836,12 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// The config bundle publishes saved values on reload; session-scoped
 	// overrides must win, so re-derive every process-local projection from the
 	// effective session view after it.
-	const unsubscribeSettingsProjectionSync = bus.on(BusChannels.ConfigHotReload, () => bumpSessionState());
-	termination.onDrain(() => unsubscribeSettingsProjectionSync());
+	const unsubscribeSettingsProjectionSync = [BusChannels.ConfigHotReload, BusChannels.ConfigNextTurn].map((channel) =>
+		bus.on(channel, () => bumpSessionState()),
+	);
+	termination.onDrain(() => {
+		for (const unsubscribe of unsubscribeSettingsProjectionSync) unsubscribe();
+	});
 	const getTaskMemorySeedOffer = (): { source: string; count: number } | null => {
 		return taskMemoryHandoffSeedOffer(process.cwd(), getCurrentSettings().context.memory.enabled);
 	};
@@ -2000,7 +2013,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		bumpSessionState();
 		persistSavedMutation((saved) => setAtPath(saved, id, value));
 	};
-	/** Alt+J / Alt+K: step this session's orchestrator through the scope list. */
+	/** Scoped model cycle actions: step this session's orchestrator through the scope list. */
 	const cycleScopedSession = (direction: "forward" | "backward"): boolean => {
 		const next = advanceScopedTarget(getCurrentSettings(), direction);
 		if (!next) return false;
@@ -2323,6 +2336,14 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				await termination.shutdown(1);
 				return { exitCode: 1, bootTimeMs: timer.snapshot().totalMs };
 			}
+			// A display-only template that reached boot (the CLI preflight answers
+			// most of them earlier) is printed for the operator and the run ends;
+			// its body was never model text.
+			if (promptExpansion?.expanded === false && promptExpansion.display) {
+				process.stdout.write(`${promptExpansion.display.text}\n`);
+				await termination.shutdown(0);
+				return { exitCode: 0, bootTimeMs: timer.snapshot().totalMs };
+			}
 			const fileExpansion = await expandInlineFileReferencesAsync(
 				promptExpansion?.expanded ? promptExpansion.text : parsedSkillRequest.text,
 				{
@@ -2382,6 +2403,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		...(resources ? { resources } : {}),
 		...(extensions ? { extensions } : {}),
 		reloadExtensions: () => extensionReload.reload(),
+		reloadPlugins,
 		...(interop ? { interop } : {}),
 		...(share ? { share } : {}),
 		...(mux ? { mux } : {}),
@@ -2435,6 +2457,9 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		getSettings: getCurrentSettings,
 		getFleetNodes: () => result.getContract<SchedulingContract>("scheduling")?.fleet?.list() ?? [],
 		onBackgroundDispatch: () => dispatchBackground.backgroundNewest(),
+		// A boot-time resume opens onto an existing conversation, so the welcome
+		// header starts collapsed rather than offering fresh-start onboarding.
+		...(resumedSessionAtBoot ? { startsResumed: true } : {}),
 		...(session ? { getSessionId: () => session.current()?.id ?? null } : {}),
 		...(contextDomain
 			? {

package/src/entry/plugin-reload.ts

@@ -0,0 +1,18 @@
+import type { PluginsReloadedPayload } from "../core/bus-events.js";
+import { type PluginSnapshot, pluginSnapshotFor, reloadPluginResources } from "../domains/plugins/index.js";
+
+/** Publish data-only plugin resources before asking session caches to refresh. */
+export function reloadPluginResourcesAndNotify(
+	cwd: string,
+	notify: (event: PluginsReloadedPayload) => void,
+): PluginSnapshot {
+	const previous = pluginSnapshotFor(cwd);
+	const next = reloadPluginResources(cwd);
+	notify({
+		generation: next.generation,
+		previousGeneration: previous.generation,
+		changed: previous.generation === 0 || previous.digest !== next.digest,
+		digest: next.digest,
+	});
+	return next;
+}

package/src/interactive/application-controller.ts

@@ -1,11 +1,11 @@
 import type { ClioKeybinding } from "../domains/config/keybindings.js";
-import { isKeyRelease, matchesKey } from "../engine/tui.js";
+import { isKeyRelease, isKeyRepeat, matchesKey } from "../engine/tui.js";
 import type { LeaderKeyController } from "./leader-key.js";
 import { isEscapeKey, type OverlayState, overlayOwnsInput } from "./overlay-lifecycle.js";
 
 export const APPLICATION_DOUBLE_TAP_MS = 500;
 
-const CLOSED_ACTION_ORDER = [
+export const CLOSED_ACTION_ORDER = [
 	"clio-coder.output.cycle",
 	"clio-coder.notifications.dismiss",
 	"clio-coder.editor.external",
@@ -24,6 +24,7 @@ export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.decisions.open",
 	"clio-coder.dispatch.background",
 	"clio-coder.model.select",
+	"clio-coder.library.toggle",
 	// Backward stays ahead of forward so prefix-overlapping user bindings keep
 	// the same more-specific-first behavior as the original input listener.
 	"clio-coder.model.cycleBackward",
@@ -31,7 +32,13 @@ export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.exit",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
-export type CtrlCAction = "cancel-stream" | "close-overlay" | "clear-editor" | "arm-shutdown" | "shutdown";
+export type CtrlCAction =
+	| "cancel-stream"
+	| "close-overlay"
+	| "clear-editor"
+	| "arm-shutdown"
+	| "shutdown"
+	| "protect-queue";
 
 export interface CtrlCActionState {
 	overlayState: OverlayState;
@@ -39,13 +46,15 @@ export interface CtrlCActionState {
 	editorText: string;
 	lastCtrlCAt: number;
 	now: number;
+	hasQueuedMessages?: boolean;
 }
 
 function resolveApplicationCtrlCAction(state: CtrlCActionState): CtrlCAction {
 	if (state.overlayState !== "closed") return "close-overlay";
-	if (state.lastCtrlCAt > 0 && state.now - state.lastCtrlCAt <= APPLICATION_DOUBLE_TAP_MS) return "shutdown";
 	if (state.streaming) return "cancel-stream";
 	if (state.editorText.length > 0) return "clear-editor";
+	if (state.hasQueuedMessages) return "protect-queue";
+	if (state.lastCtrlCAt > 0 && state.now - state.lastCtrlCAt <= APPLICATION_DOUBLE_TAP_MS) return "shutdown";
 	return "arm-shutdown";
 }
 
@@ -78,6 +87,15 @@ export interface ApplicationControllerDeps {
 	intervals: ApplicationIntervalCoordinator;
 	intervalsToClear: ReadonlyArray<ApplicationIntervalHandle>;
 	leaderKeys: LeaderKeyController;
+	isSearchFocused?: () => boolean;
+	closeSearch?: () => void;
+	forwardFocusedInput?: (data: string) => void;
+	cancelFocusedOwner?: () => void;
+	isAutocompleteVisible?: () => boolean;
+	matchesRepeatableInput?: (data: string) => boolean;
+	routeComposerKey?: (data: string) => boolean;
+	hasQueuedMessages?: () => boolean;
+	explainProtectedExit?: () => void;
 	getOverlayState: () => OverlayState;
 	routeOverlayKey: (data: string) => boolean;
 	/** Let pi-tui's focused Editor own dedicated prompt-history actions before app bindings. */
@@ -136,7 +154,7 @@ export interface ApplicationController {
 	run: Promise<number>;
 	handleInput(data: string): ApplicationInputResult;
 	handleCtrlC(): void;
-	dismissNotifications(): void;
+	dismissNotifications(all?: boolean): void;
 	shutdown(): Promise<void>;
 }
 
@@ -152,9 +170,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	const keepAlive = deps.intervals.setInterval(() => {}, 1 << 30);
 	let shuttingDown = false;
 	let lastCtrlCAt = 0;
-	let lastNotificationDismissAt = 0;
-
-	const isDoubleTap = (lastAt: number, now: number): boolean => lastAt > 0 && now - lastAt <= APPLICATION_DOUBLE_TAP_MS;
 
 	let shutdownArmed = false;
 	let armedIndicator: ApplicationIntervalHandle | null = null;
@@ -273,12 +288,31 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	};
 
 	const handleCtrlC = (): void => {
+		deps.leaderKeys.reset();
+		if (deps.isSearchFocused?.()) {
+			deps.closeSearch?.();
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
+		if (deps.getOverlayState() !== "closed" && deps.cancelFocusedOwner) {
+			deps.cancelFocusedOwner();
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
+		if (deps.getOverlayState() === "closed" && deps.cancelActiveEditorBash()) {
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			return;
+		}
 		const action = resolveApplicationCtrlCAction({
 			overlayState: deps.getOverlayState(),
 			streaming: deps.isStreaming(),
 			editorText: deps.getEditorText(),
 			lastCtrlCAt,
 			now: deps.clock.now(),
+			hasQueuedMessages: deps.hasQueuedMessages?.() ?? false,
 		});
 		if (action === "shutdown") {
 			lastCtrlCAt = 0;
@@ -317,16 +351,19 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 			deps.requestRender();
 			return;
 		}
+		if (action === "protect-queue") {
+			lastCtrlCAt = 0;
+			setShutdownArmed(false);
+			deps.explainProtectedExit?.();
+			return;
+		}
 		// arm-shutdown. The one branch that used to fall off the end of this
 		// function with nothing to show for the press.
 		setShutdownArmed(true);
 	};
 
-	const dismissNotifications = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastNotificationDismissAt, now);
-		lastNotificationDismissAt = now;
-		if (doubleTap) {
+	const dismissNotifications = (all = false): void => {
+		if (all) {
 			deps.dismissAllNotifications();
 			return;
 		}
@@ -335,19 +372,27 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	};
 
 	const handleInput = (data: string): ApplicationInputResult => {
-		const initialOverlayState = deps.getOverlayState();
-		if (overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending()) deps.leaderKeys.reset();
-		if (!overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending() && deps.leaderKeys.route(data)) {
+		if (isKeyRelease(data)) return { consume: true };
+		if (isKeyRepeat(data) && !(deps.matchesRepeatableInput?.(data) ?? false)) return { consume: true };
+		if (matchesKey(data, "ctrl+c")) {
+			handleCtrlC();
 			return { consume: true };
 		}
-
-		if (matchesKey(data, "ctrl+c") && !isKeyRelease(data)) {
-			handleCtrlC();
+		if (deps.leaderKeys.isPending() && deps.leaderKeys.route(data)) return { consume: true };
+		if (deps.leaderKeys.route(data)) return { consume: true };
+		if (deps.isSearchFocused?.()) {
+			deps.forwardFocusedInput?.(data);
 			return { consume: true };
 		}
 		if (deps.routeOverlayKey(data)) return { consume: true };
-		if (overlayOwnsInput(deps.getOverlayState())) return undefined;
-		if (deps.getOverlayState() === "closed" && deps.leaderKeys.route(data)) return { consume: true };
+		if (overlayOwnsInput(deps.getOverlayState())) {
+			if (deps.forwardFocusedInput) {
+				deps.forwardFocusedInput(data);
+				return { consume: true };
+			}
+			return undefined;
+		}
+		if (isEscapeKey(data) && deps.isAutocompleteVisible?.()) return undefined;
 		if (isEscapeKey(data) && deps.cancelActiveEditorBash()) return { consume: true };
 		if (isEscapeKey(data) && deps.isStreaming()) {
 			deps.cancelActiveRun();
@@ -369,6 +414,7 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 			if (!deps.matchesAction(data, id)) continue;
 			return deps.dispatchAction(id) ? { consume: true } : undefined;
 		}
+		if (deps.routeComposerKey?.(data)) return { consume: true };
 		return undefined;
 	};
 

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

@@ -362,6 +362,7 @@ export interface RunUsageSummary {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoning: number;
 	apiCalls: number;
 	hadReasoning: boolean;
@@ -407,6 +408,7 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 						output?: unknown;
 						cacheRead?: unknown;
 						cacheWrite?: unknown;
+						cacheWrite1h?: unknown;
 						totalTokens?: unknown;
 						cost?: { total?: unknown };
 					};
@@ -432,6 +434,7 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 		summary.output += output;
 		summary.cacheRead += cacheRead;
 		summary.cacheWrite += cacheWrite;
+		if (typeof usage.cacheWrite1h === "number") summary.cacheWrite1h = (summary.cacheWrite1h ?? 0) + usage.cacheWrite1h;
 		const reasoning = extractReasoningTokens(usage);
 		if (reasoning !== null) {
 			summary.reasoning += reasoning;

package/src/interactive/chat-loop.ts

@@ -1,3 +1,5 @@
+import type { WorkerContextSnapshot } from "../domains/context/worker/contract.js";
+import { captureWorkerContext } from "../domains/context/worker/snapshot.js";
 /**
  * The chat loop: one turn's state machine.
  *
@@ -129,6 +131,7 @@ export interface QueueUpdateEvent {
  * same beat. Enqueue time shows the text only in the steering-queue panel.
  */
 export interface QueuedUserTurnEvent {
+	display?: { text: string; note: string };
 	type: "queued_user_turn";
 	text: string;
 	/** `interrupt` marks a message that cancelled the run and was submitted as a fresh prompt. */
@@ -198,6 +201,8 @@ export type ChatLoopEvent =
 	| ToolApprovalStateEvent;
 
 export interface ChatSubmitOptions {
+	/** Presentation only; never part of the model message or persisted text. */
+	display?: { text: string; note: string };
 	/** Host-owned run identity, scoped to this submit and its internal continuations. */
 	hostRun?: ToolInvokeOptions["hostRun"];
 	images?: ReadonlyArray<ImageContent>;
@@ -315,6 +320,7 @@ export interface ChatLoop {
 	cancel(options?: ChatCancelOptions): void;
 	onEvent(handler: (event: ChatLoopEvent) => void): () => void;
 	getSessionId(): string | null;
+	captureWorkerContext?(): WorkerContextSnapshot | null;
 	lastRunSnapshot?(): ChatLoopRunSnapshot | null;
 	isStreaming(): boolean;
 	/**
@@ -751,7 +757,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	const queues = createTurnQueues({
 		state,
 		emitQueueUpdateEvent: (messages) => emit({ type: "queue_update", messages }),
-		emitQueuedUserTurn: (entry) => emit({ type: "queued_user_turn", text: entry.text, kind: entry.kind }),
+		emitQueuedUserTurn: (entry) => emit({ type: "queued_user_turn", ...entry }),
 		emitNotice,
 		// The loop's own resubmits (stranded steers, continuation requests) run
 		// from submit's finally and bypass the admission gate: an interrupt that
@@ -856,11 +862,9 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		deps.bus?.on(BusChannels.ConfigHotReload, () => {
 			context.invalidateSessionPromptCache();
 		}) ?? null;
-	// A committed extension generation with new content can change the skill
-	// and prompt inputs the session prompt compiles from; same invalidation.
-	const unsubscribeExtensionsReload =
-		deps.bus?.on(BusChannels.ExtensionsReloaded, (payload) => {
-			if (payload.changed) context.invalidateSessionPromptCache();
+	const unsubscribePluginsReload =
+		deps.bus?.on(BusChannels.PluginsReloaded, () => {
+			context.invalidateSessionPromptCache();
 		}) ?? null;
 
 	const unsubscribeSynthesisLock =
@@ -970,6 +974,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				output: usage.output,
 				cacheRead: usage.cacheRead,
 				cacheWrite: usage.cacheWrite,
+				...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 				reasoningTokens: usage.reasoning,
 				totalTokens: usage.totalTokens,
 				apiCalls: 1,
@@ -993,6 +998,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				output: usage.output,
 				cacheRead: usage.cacheRead,
 				cacheWrite: usage.cacheWrite,
+				...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 				reasoning: usage.reasoning,
 				totalTokens: usage.totalTokens,
 				costUsd: usage.costUsd,
@@ -1097,13 +1103,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 						// Enter while streaming means "correct it now": the engine
 						// steering queue drains after every tool batch, so the text
 						// lands as a user message before the next model turn.
-						// alt+enter (queueFollowUp) keeps the after-this-run intent.
+						// Ctrl+Q (queueFollowUp) keeps the after-this-run intent.
 						if (isWorkerShareNote(trimmed)) state.turnSharedWorkerNote = true;
 						// The queue carries the submitted bytes, not the trimmed copy the
 						// guard above reads: a steer is a model-facing turn and the
 						// payload contract applies to it too (issue #244).
-						if (mode === "end-of-turn") queues.queueFollowUp(text);
-						else queues.steer(text);
+						if (mode === "end-of-turn") queues.queueFollowUp(text, options.display);
+						else queues.steer(text, options.display);
 						return;
 					}
 					emitNotice("[Clio Coder] response already in progress. Press Esc to cancel the active run.");
@@ -1287,7 +1293,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// An interrupt was submitted while a run was active, so no caller drew
 			// it in the transcript; render it here, after the cancel notice and the
 			// cancelled run's leftovers, which is the order the ledger has.
-			if (interrupted) emit({ type: "queued_user_turn", text, kind: "interrupt" });
+			if (interrupted)
+				emit({
+					type: "queued_user_turn",
+					text,
+					kind: "interrupt",
+					...(options.display ? { display: options.display } : {}),
+				});
 			context.logPromptCompileIfPending();
 			const previousThinkingLevel = previousRunSnapshot?.runtimeResolution?.effectiveThinkingLevel;
 			if (
@@ -1484,6 +1496,15 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			};
 		},
 
+		captureWorkerContext(): WorkerContextSnapshot | null {
+			const meta = deps.session?.current();
+			if (!meta) return null;
+			return captureWorkerContext(
+				{ sessionId: meta.id, leafTurnId: state.lastTurnId, cwd: meta.cwd },
+				state.runtime?.agent.state.messages ?? state.replayedContextMessages,
+			);
+		},
+
 		getSessionId(): string | null {
 			return deps.session?.current()?.id ?? null;
 		},
@@ -1546,7 +1567,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		dispose(): void {
 			unsubscribeConfigReload?.();
-			unsubscribeExtensionsReload?.();
+			unsubscribePluginsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();

package/src/interactive/chat-panel.ts

@@ -1401,7 +1401,11 @@ export function createChatPanel(options: ChatPanelOptions = {}): ChatPanel {
 				// A queued steer or follow-up the engine just injected. Rendering it
 				// here, at injection time, keeps the transcript in the order the
 				// model saw: enqueue time shows the text only in the queue panel.
-				transcript.push({ role: "user", text: event.text });
+				transcript.push({ role: "user", text: event.display?.text ?? event.text });
+				if (event.display) {
+					const note = event.display.note;
+					transcript.push({ role: "replayBlock", renderBlock: (width) => wrapTextWithAnsi(`  ${note}`, width) });
+				}
 				markDirty();
 				return;
 			}