@iowarp/clio-coder 0.4.5 → 0.4.7

package/src/engine/worker-tools.ts

@@ -1,3 +1,4 @@
+import type { WorkerRecall } from "../domains/context/worker/recall.js";
 /**
  * Worker-subprocess tool construction.
  *
@@ -29,6 +30,7 @@ import {
 import { CONFIRMED_SCOPE, isSubset, READONLY_SCOPE, WORKSPACE_SCOPE } from "../domains/safety/scope.js";
 import { effectiveToolNames } from "../tools/agent-tools.js";
 import { assertRegisteredBuiltinTools, registerCoreTools } from "../tools/core-bootstrap.js";
+import { registerHarnessExtensionTools } from "../tools/harness-extensions.js";
 import type { ToolProfileName } from "../tools/profiles.js";
 import { createRegistry, type RegistryDeps, type ToolRegistry } from "../tools/registry.js";
 import { type AgentLedgerPort, toolSignatureOf } from "../worker/protocol.js";
@@ -139,6 +141,7 @@ export function createWorkerToolRegistry(
 	autonomy?: AutonomyLevel,
 	onMiddlewareEffects?: RegistryDeps["onMiddlewareEffects"],
 	agentLedger?: AgentLedgerPort,
+	workerRecall?: WorkerRecall,
 ): ToolRegistry {
 	// A worker always gets a middleware contract, even without a snapshot from
 	// the orchestrator, because the loop guard rides on it as a before_tool
@@ -163,6 +166,7 @@ export function createWorkerToolRegistry(
 	// is what keeps that true now that the session registry omits the tool.
 	const registration = registerCoreTools(registry, {
 		includeLedgerTools: true,
+		...(workerRecall ? { workerRecall } : {}),
 		...(agentLedger ? { agentLedger } : {}),
 		// A worker cannot install a skill or reach the operator who could, so
 		// its skill listing carries installed (or bound) skills only; the
@@ -177,6 +181,7 @@ export function createWorkerToolRegistry(
 		}),
 	});
 	assertRegisteredBuiltinTools(registry, registration, false);
+	registerHarnessExtensionTools(registry);
 	return registry;
 }
 

package/src/entry/orchestrator.ts

@@ -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)),
@@ -1535,6 +1538,8 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// keep evaluating after the guards and before the 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,7 +1550,10 @@ 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();
 	bootHookNotices = false;
@@ -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
@@ -2000,7 +2009,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 +2332,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 +2399,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 +2453,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,21 +1,17 @@
 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.tool.expand",
-	"clio-coder.tool.expandAll",
-	"clio-coder.tool.liveOutput",
 	"clio-coder.editor.external",
 	"clio-coder.message.followUp",
 	"clio-coder.message.interrupt",
 	"clio-coder.message.dequeue",
-	"clio-coder.thinking.expand",
-	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
 export const GLOBAL_ACTION_ORDER = [
@@ -28,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",
@@ -35,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;
@@ -43,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";
 }
 
@@ -82,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. */
@@ -108,10 +122,6 @@ export interface ApplicationControllerDeps {
 	listNotifications: () => ReadonlyArray<{ id: string }>;
 	dismissNotification: (id: string) => void;
 	dismissAllNotifications: () => void;
-	toggleLastToolExpanded: () => boolean;
-	toggleAllToolsExpanded: () => boolean;
-	toggleLastThinking: () => boolean;
-	toggleAllThinking: () => boolean;
 	shutdownDisposers: ReadonlyArray<() => void>;
 	/** Settle the last presentation mutation into an accepted/drained frame. */
 	beforeStopUi?: () => Promise<void>;
@@ -144,9 +154,7 @@ export interface ApplicationController {
 	run: Promise<number>;
 	handleInput(data: string): ApplicationInputResult;
 	handleCtrlC(): void;
-	dismissNotifications(): void;
-	toggleToolExpansion(): void;
-	toggleThinkingExpansion(): void;
+	dismissNotifications(all?: boolean): void;
 	shutdown(): Promise<void>;
 }
 
@@ -162,11 +170,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	const keepAlive = deps.intervals.setInterval(() => {}, 1 << 30);
 	let shuttingDown = false;
 	let lastCtrlCAt = 0;
-	let lastNotificationDismissAt = 0;
-	let lastToolExpandAt = 0;
-	let lastThinkingExpandAt = 0;
-
-	const isDoubleTap = (lastAt: number, now: number): boolean => lastAt > 0 && now - lastAt <= APPLICATION_DOUBLE_TAP_MS;
 
 	let shutdownArmed = false;
 	let armedIndicator: ApplicationIntervalHandle | null = null;
@@ -285,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;
@@ -329,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;
 		}
@@ -346,36 +371,28 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		if (first) deps.dismissNotification(first.id);
 	};
 
-	const toggleToolExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastToolExpandAt, now);
-		lastToolExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllToolsExpanded() : deps.toggleLastToolExpanded();
-		if (changed) deps.requestRender();
-	};
-
-	const toggleThinkingExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastThinkingExpandAt, now);
-		lastThinkingExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllThinking() : deps.toggleLastThinking();
-		if (changed) deps.requestRender();
-	};
-
 	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();
@@ -397,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;
 	};
 
@@ -427,8 +445,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		handleInput,
 		handleCtrlC,
 		dismissNotifications,
-		toggleToolExpansion,
-		toggleThinkingExpansion,
 		shutdown,
 	};
 }

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
@@ -863,6 +869,11 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			if (payload.changed) context.invalidateSessionPromptCache();
 		}) ?? null;
 
+	const unsubscribePluginsReload =
+		deps.bus?.on(BusChannels.PluginsReloaded, () => {
+			context.invalidateSessionPromptCache();
+		}) ?? null;
+
 	const unsubscribeSynthesisLock =
 		deps.bus?.on(BusChannels.LoopBlocked, (payload) => {
 			const disposition = (payload as { disposition?: unknown } | null)?.disposition;
@@ -1097,13 +1108,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 +1298,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 +1501,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;
 		},
@@ -1547,6 +1573,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		dispose(): void {
 			unsubscribeConfigReload?.();
 			unsubscribeExtensionsReload?.();
+			unsubscribePluginsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();