@iowarp/clio-coder 0.4.1 → 0.4.2

package/src/interactive/panes-runtime.ts

@@ -27,6 +27,7 @@ import type { MuxContract, MuxPaneRecord } from "../domains/mux/index.js";
 import {
 	PANES_PRESETS,
 	type PanesCloseResult,
+	type PanesFilesResult,
 	type PanesInventoryEntry,
 	type PanesOpenResult,
 	type PanesOperations,
@@ -36,6 +37,7 @@ import {
 	type PanesYaziController,
 	type PanesYaziStatus,
 	type PanesZoomResult,
+	resolvePanesPresetId,
 } from "../domains/mux/operations.js";
 import { resolveBinary } from "../tools/executables.js";
 import { type PaneWatchSource, paneWatchDecision } from "./pane-policy.js";
@@ -54,7 +56,16 @@ export interface PanesRuntimeDeps {
 	newestJournalRunId?: () => string | null;
 }
 
-const UNAVAILABLE = "the pane layer is not available in this session";
+/**
+ * Why there is no pane layer, in the operator's terms. Detection already
+ * knows (no `HERDR_ENV`, no socket, a refused rung); repeating that reason
+ * beside the refusal is what turns "unavailable" into a next step, and the
+ * `--with-panes` hint covers the session that never asked for panes.
+ */
+function unavailableReason(mux: MuxContract): string {
+	const reason = mux.detection().reason;
+	return `the pane layer is not available in this session: ${reason}. Start Clio inside a herdr session with \`clio-coder --with-panes\` to get panes`;
+}
 
 /** Fuzzy operator addressing shared by `close` and `zoom`: id, label, purpose; newest first. */
 function matchOwnedPane(owned: ReadonlyArray<MuxPaneRecord>, target: string): MuxPaneRecord | null {
@@ -78,6 +89,27 @@ function inventory(records: ReadonlyArray<MuxPaneRecord>): ReadonlyArray<PanesIn
 	}));
 }
 
+/**
+ * The sentence `/quit` prints about the panes it did not close, or null when
+ * there are none.
+ *
+ * Policy (#272): docks close with the session and utility panes stay. A dock
+ * is a Clio surface (the files pane, the workers watch pane), so it goes the
+ * way a native application's windows go. A pane opened with `/panes open
+ * shell|logs|<argv>` is a terminal the operator may be typing in, and killing
+ * it on quit is the one thing a pane host must never do behind the operator's
+ * back. The next session does not adopt it either, so without this line the
+ * pane simply sat there with nothing naming it. Computed before the mux
+ * domain stops, because shutdown forgets its registry.
+ */
+export function describePanesLeftBehind(mux: Pick<MuxContract, "list" | "docks">): string | null {
+	const dockIds = new Set(mux.docks().map((dock) => dock.paneId));
+	const left = mux.list().filter((record) => !dockIds.has(record.ref.paneId));
+	if (left.length === 0) return null;
+	const named = left.map((record) => `${record.label} (${record.ref.paneId})`).join(", ");
+	return `Clio left ${left.length} ${left.length === 1 ? "pane" : "panes"} open in herdr: ${named}. Utility panes stay when a session ends; the docks closed with it. Next time run \`/panes close all\` before \`/quit\` to take them with you, or close ${left.length === 1 ? "it" : "them"} now with \`herdr pane close <paneId>\`.`;
+}
+
 export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 	const probe = deps.resolveBinaryPath ?? resolveBinary;
 	const journalRoot = deps.journalRoot ?? runEventJournalRoot;
@@ -143,7 +175,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 	};
 
 	const show = async (target: string, source: PaneWatchSource): Promise<PanesShowResult> => {
-		if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+		if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 		const match = matchRun(target);
 		if (match === null) {
 			// The candidate list is what turns a miss into a next step: it names
@@ -164,7 +196,58 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
 	};
 
+	/**
+	 * The files pane's open half, shared by `/files`, `/panes open files`, the
+	 * keybinding, and the model tool. The settings gate and the missing-engine
+	 * message live here so every door says the same thing.
+	 */
+	const openFiles = async (once: boolean): Promise<Exclude<PanesFilesResult, { status: "closed" }>> => {
+		const preset = PANES_PRESETS[0];
+		if (!deps.getSettings().interface.panes.files.enabled) {
+			return { status: "refused", reason: "the files pane is disabled by interface.panes.files.enabled" };
+		}
+		if (!yaziController) {
+			return { status: "unavailable", reason: "the files pane return path is not ready" };
+		}
+		const pendingId = beginPendingOpen(preset.id);
+		try {
+			const result = await yaziController.open(once ? { once: true } : undefined);
+			if (result.status === "opened") {
+				return { status: "opened", paneId: result.paneId, existing: result.existing };
+			}
+			if (result.status === "missing-binary") {
+				return {
+					status: "missing-binary",
+					binary: result.binary,
+					installHint: preset.installHint,
+					// The engine's own resolution sentence, prefixed with the surface it
+					// serves: an operator who typed `/files` should not have to know the
+					// name of the program to read the answer.
+					detail: `the files pane engine is not available: ${result.detail}`,
+				};
+			}
+			return {
+				status: result.status === "profile-error" ? "refused" : "unavailable",
+				reason: result.reason,
+			};
+		} finally {
+			pendingOpens.delete(pendingId);
+		}
+	};
+
 	return {
+		async files(action): Promise<PanesFilesResult> {
+			if (action === "close") {
+				await yaziController?.close();
+				return { status: "closed" };
+			}
+			if (action === "toggle" && yaziController?.isOpen()) {
+				await yaziController.close();
+				return { status: "closed" };
+			}
+			return openFiles(action === "pick");
+		},
+
 		status(): PanesStatus {
 			const detection = deps.mux.detection();
 			const settings = deps.getSettings();
@@ -201,41 +284,31 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		async open(request: { preset?: string; argv?: ReadonlyArray<string>; once?: boolean }): Promise<PanesOpenResult> {
 			const cwd = deps.getCwd();
 			if (request.preset !== undefined) {
-				const preset = PANES_PRESETS.find((entry) => entry.id === request.preset);
+				const presetId = resolvePanesPresetId(request.preset);
+				const preset = presetId === null ? undefined : PANES_PRESETS.find((entry) => entry.id === presetId);
 				if (!preset) {
 					return { status: "refused", reason: `unknown preset: ${request.preset}` };
 				}
-				if (preset.id === "yazi") {
-					if (!deps.getSettings().interface.panes.files.enabled) {
-						return { status: "refused", reason: "the files pane is disabled by panes.yazi.enabled" };
-					}
-					if (!yaziController) {
-						return { status: "unavailable", reason: "the files-pane return path is not ready" };
+				if (preset.id === "files") {
+					const result = await openFiles(request.once === true);
+					if (result.status === "opened") {
+						return { status: "opened", label: preset.id, paneId: result.paneId, existing: result.existing };
 					}
-					const pendingId = beginPendingOpen(preset.id);
-					try {
-						const result = await yaziController.open(request.once ? { once: true } : undefined);
-						if (result.status === "opened") {
-							return { status: "opened", label: preset.id, paneId: result.paneId };
-						}
-						if (result.status === "missing-binary") {
-							return {
-								status: "missing-binary",
-								preset: preset.id,
-								binary: result.binary,
-								installHint: preset.installHint,
-								detail: result.detail,
-							};
-						}
-						return {
-							status: result.status === "profile-error" ? "refused" : "unavailable",
-							reason: result.reason,
-						};
-					} finally {
-						pendingOpens.delete(pendingId);
+					if (result.status === "missing-binary") {
+						return { ...result, preset: preset.id };
 					}
+					return result;
+				}
+				if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+				// One pane per preset. A second `/panes open shell` is a request to
+				// see the shell that is already there, not to split the screen again;
+				// the pane host is asked for focus so the operator lands in it.
+				const live = deps.mux.list().find((record) => record.purpose === "utility" && record.label === preset.id);
+				if (live) {
+					await deps.mux.unzoomSelf();
+					await deps.mux.focusPane(live.ref.paneId);
+					return { status: "opened", label: preset.id, paneId: live.ref.paneId, existing: true };
 				}
-				if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
 				const binaryPath = probe(preset.binary);
 				if (binaryPath === null) {
 					return {
@@ -248,7 +321,10 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 				}
 				const argv = presetArgv(preset.id, binaryPath);
 				if (argv === null) {
-					return { status: "refused", reason: `preset ${preset.id} has nothing to show yet` };
+					return {
+						status: "refused",
+						reason: `no dispatched run has written a journal under ${journalRoot()} yet; the logs pane follows the newest run once one starts`,
+					};
 				}
 				const pendingId = beginPendingOpen(preset.id);
 				try {
@@ -259,7 +335,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 					pendingOpens.delete(pendingId);
 				}
 			}
-			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 			const argv = request.argv ?? [];
 			if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
 			const label = argv[0] ?? "pane";
@@ -274,7 +350,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		},
 
 		async zoom(target: string): Promise<PanesZoomResult> {
-			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 			const match = matchOwnedPane(deps.mux.list(), target.trim().length === 0 ? "watch" : target);
 			if (!match) return { status: "not-found", target: target.trim().length === 0 ? "watch" : target };
 			const changed = await deps.mux.zoomPane(match.ref.paneId, "toggle");
@@ -285,7 +361,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		},
 
 		async close(target: string): Promise<PanesCloseResult> {
-			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 			const owned = deps.mux.list();
 			if (target === "all") {
 				const labels: string[] = [];

package/src/interactive/prompt-cache-identity.ts

@@ -0,0 +1,88 @@
+import type { SessionPromptInputs } from "../domains/prompts/compiler.js";
+import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import type { ContextWindowSource } from "../domains/providers/index.js";
+import type { AutonomyLevel } from "../domains/safety/autonomy.js";
+
+/** The exact schema bytes pi attaches to a provider request for one tool. */
+export interface AttachedToolSchema {
+	name: string;
+	description: string;
+	parameters: unknown;
+}
+
+/**
+ * Project the live agent tools onto the schema fields sent to the provider.
+ * Array order is preserved because providers serialize the attached tools in
+ * that order, so reordering them changes prompt-prefix bytes too.
+ */
+export function attachedToolSchemasFromState(tools: ReadonlyArray<unknown>): AttachedToolSchema[] {
+	const schemas: AttachedToolSchema[] = [];
+	for (const tool of tools) {
+		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
+		const record = tool as Record<string, unknown>;
+		schemas.push({
+			name: typeof record.name === "string" ? record.name : "",
+			description: typeof record.description === "string" ? record.description : "",
+			parameters: record.parameters ?? null,
+		});
+	}
+	return schemas;
+}
+
+/**
+ * Serialize the exact ordered schema sequence attached to a provider request.
+ *
+ * `canonicalJson` is deliberately not used here: provider JSON preserves tool
+ * array order and nested object insertion order, so canonicalizing parameters
+ * can alias two byte-distinct request prefixes. Standard `JSON.stringify`
+ * matches the request serialization boundary and throws for unsupported
+ * values such as circular references and bigint.
+ */
+export function attachedToolSchemaBytes(schemas: ReadonlyArray<AttachedToolSchema>): string {
+	try {
+		const bytes = JSON.stringify(schemas);
+		if (bytes === undefined) throw new Error("JSON.stringify returned undefined");
+		return bytes;
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(`attached tool schemas are not JSON-serializable: ${reason}`, { cause: err });
+	}
+}
+
+export interface MainPromptCacheIdentityInput {
+	targetId: string;
+	runtimeId: string;
+	wireModelId: string;
+	autonomy: AutonomyLevel;
+	sessionId: string;
+	cwd: string;
+	workingContextPaths: ReadonlyArray<string>;
+	contextWindowSource: ContextWindowSource | null;
+	promptInputEpoch: string;
+	sessionInputs: SessionPromptInputs;
+	attachedToolSchemas: ReadonlyArray<AttachedToolSchema>;
+}
+
+/**
+ * Canonical identity for the interactive session-prompt compile cache.
+ * Config hot reload explicitly invalidates compiler-owned fragments and
+ * rosters; this identity covers every live/caller input resolved per turn.
+ */
+export function mainPromptCacheIdentity(input: MainPromptCacheIdentityInput): string {
+	return sha256(
+		canonicalJson({
+			version: 2,
+			targetId: input.targetId,
+			runtimeId: input.runtimeId,
+			wireModelId: input.wireModelId,
+			autonomy: input.autonomy,
+			sessionId: input.sessionId,
+			cwd: input.cwd,
+			workingContextPaths: [...input.workingContextPaths].sort((a, b) => a.localeCompare(b)),
+			contextWindowSource: input.contextWindowSource,
+			promptInputEpoch: input.promptInputEpoch,
+			sessionInputs: input.sessionInputs,
+			attachedToolSchemaBytes: attachedToolSchemaBytes(input.attachedToolSchemas),
+		}),
+	);
+}

package/src/interactive/slash-commands.ts

@@ -13,12 +13,12 @@ import type { ReceiptIntegrityOutcome } from "../domains/evidence/trust-status.j
 import type { InstalledExtension } from "../domains/extensions/index.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
 import {
-	isPanesPresetId,
 	PANES_PRESET_IDS,
 	PANES_PRESETS,
 	type PanesOperations,
 	type PanesPresetId,
 	type PanesStatus,
+	resolvePanesPresetId,
 } from "../domains/mux/operations.js";
 import type { ProvidersContract, ResolvedModelRef } from "../domains/providers/index.js";
 import { resolveModelReference } from "../domains/providers/index.js";
@@ -31,6 +31,7 @@ import type {
 import { parseSkillCommand } from "../domains/resources/index.js";
 import type { ShareImportPlan } from "../domains/share/index.js";
 import type { UserTask } from "../domains/user-tasks/store.js";
+import type { ExtensionReloadOutcome } from "../entry/extension-reload.js";
 import { isToolProfileName, TOOL_PROFILE_NAMES, type ToolProfileName } from "../tools/profiles.js";
 import type { NoticeLevel } from "./command-output.js";
 import {
@@ -115,7 +116,7 @@ type SlashCommandVariant =
 	/** `ref` is the turnId an `[evicted ...]` marker names. */
 	| { kind: "context-recall"; ref: string }
 	| { kind: "skill-selector" }
-	| { kind: "resources"; family?: "skills" | "prompts" | "extensions"; tab?: LibraryEntryKind }
+	| { kind: "resources"; family?: "skills" | "prompts" | "extensions"; tab?: LibraryEntryKind; action?: "reload" }
 	| { kind: "skill-invocation"; text: string }
 	| ShareCommandVariant
 	| ArchiveCommandVariant
@@ -161,6 +162,9 @@ type SlashCommandVariant =
 	| { kind: "panes-zoom"; target: string }
 	| { kind: "panes-close"; target: string }
 	| { kind: "panes-usage"; reason?: string }
+	/** `/files`: toggle the files pane; `pick` borrows it for one selection; `close` closes it. */
+	| { kind: "files"; action: "toggle" | "open" | "close" | "pick" }
+	| { kind: "files-usage"; reason: string }
 	| { kind: "thinking-set"; level: string }
 	| { kind: "thinking-picker" }
 	| { kind: "output-set"; verbosity: string }
@@ -599,6 +603,13 @@ export interface SlashCommandContext {
 	 */
 	expandPromptTemplate?: (text: string) => PromptTemplateExpansion;
 	listExtensions?: () => ReadonlyArray<InstalledExtension>;
+	/**
+	 * `/resources extensions reload`: build, validate, and commit the next
+	 * extension generation together with its user hooks, or report why it was
+	 * refused. Absent on a host without the reload coordinator, in which case
+	 * the command says so instead of pretending.
+	 */
+	reloadExtensions?: () => ExtensionReloadOutcome;
 	/** Detection report, pending proposals, and the two consent actions `/interop` drives. */
 	interop?: {
 		report: () => InteropReport | null;
@@ -937,22 +948,27 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			skills: "Browse installed skills",
 			prompts: "Browse prompt templates",
 			library: "Browse resource libraries",
-			extensions: "Browse installed extensions",
+			extensions: "Browse installed extensions; `reload` commits a new extension generation",
 		},
 		args: {
 			subcommands: {
 				skills: {},
 				prompts: {},
 				library: { positionals: [{ name: "kind", required: false }] },
-				extensions: {},
+				extensions: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
 			},
 		},
 		fromArgs(parsed) {
 			if (parsed.error) return { kind: "usage-error", command: "resources", reason: parsed.error };
 			if (parsed.subcommand === undefined || parsed.subcommand === "skills")
 				return { kind: "resources", family: "skills" };
-			if (parsed.subcommand === "prompts" || parsed.subcommand === "extensions")
-				return { kind: "resources", family: parsed.subcommand };
+			if (parsed.subcommand === "prompts") return { kind: "resources", family: "prompts" };
+			if (parsed.subcommand === "extensions") {
+				const action = parsed.positionals[0];
+				if (action === undefined) return { kind: "resources", family: "extensions" };
+				if (action === "reload") return { kind: "resources", family: "extensions", action: "reload" };
+				return { kind: "usage-error", command: "resources", reason: `Unknown action: ${action} (one of reload)` };
+			}
 			const tab = parsed.positionals[0];
 			if (tab === undefined) return { kind: "resources" };
 			if (!isLibraryTab(tab)) {
@@ -964,8 +980,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		handle(command, ctx) {
 			if (command.kind !== "resources") return;
 			if (command.family === "prompts") ctx.openPrompts();
-			else if (command.family === "extensions") ctx.openExtensions();
-			else ctx.openSkillsHub?.(command.tab);
+			else if (command.family === "extensions") {
+				if (command.action === "reload") reloadExtensionsCommand(ctx);
+				else ctx.openExtensions();
+			} else ctx.openSkillsHub?.(command.tab);
 		},
 	},
 	{
@@ -1643,7 +1661,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 		subcommandDescriptions: {
 			show: "watch a live run or agent in the watch pane",
-			open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, or a command)`,
+			open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, \`files --once\` for one pick, or a command)`,
 			zoom: "toggle zoom on a Clio-owned pane (default: the watch pane)",
 			close: "close a Clio-owned pane, or all of them",
 		},
@@ -1659,9 +1677,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				const first = argv[0] ?? "";
 				// A bare preset name is a preset; anything else is operator argv,
 				// which the tool surface deliberately cannot ask for.
-				if (argv.length === 1 && isPanesPresetId(first)) return { kind: "panes-open", preset: first };
-				if (argv.length === 2 && first === "yazi" && argv[1] === "--once") {
-					return { kind: "panes-open", preset: "yazi", once: true };
+				const preset = resolvePanesPresetId(first);
+				if (argv.length === 1 && preset !== null) return { kind: "panes-open", preset };
+				if (argv.length === 2 && preset === "files" && argv[1] === "--once") {
+					return { kind: "panes-open", preset: "files", once: true };
 				}
 				return { kind: "panes-open", argv };
 			}
@@ -1691,7 +1710,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				// every `--with-panes` session, even one where no pane host answered.
 				ctx.notice(
 					"info",
-					"panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set panes.enabled=auto",
+					"panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto",
 				);
 				return;
 			}
@@ -1728,7 +1747,14 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 						// The in-terminal chooser has already restored the TUI by the
 						// time this resolves. A pick emitted its composer notice; an empty
 						// chooser was cancellation and deliberately stays silent.
-						if (result.paneId !== null) ctx.notice("success", `opened pane ${result.label} (${result.paneId})`);
+						if (result.paneId !== null) {
+							ctx.notice(
+								"success",
+								result.existing
+									? `focused pane ${result.label} (${result.paneId})`
+									: `opened pane ${result.label} (${result.paneId})`,
+							);
+						}
 					} else if (result.status === "missing-binary") {
 						// This is a synchronous slash-surface line, not a transient pane-host
 						// notification. It remains visible when no pane was ever created and
@@ -1768,6 +1794,62 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			});
 		},
 	},
+	{
+		name: "files",
+		description: "Toggle the files pane; picks land in the composer as @ mentions",
+		group: "Inspect",
+		kinds: ["files", "files-usage"],
+		args: { positionals: [{ name: "action", required: false }] },
+		subcommandDescriptions: {
+			open: "open the files pane, or focus it when it is already open",
+			close: "close the files pane",
+			pick: "borrow the files pane for one selection, then close it",
+		},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "files-usage", reason: parsed.error };
+			const action = parsed.positionals[0];
+			if (action === undefined) return { kind: "files", action: "toggle" };
+			if (action === "open" || action === "close" || action === "pick" || action === "toggle") {
+				return { kind: "files", action };
+			}
+			return { kind: "files-usage", reason: `Unexpected argument: ${action}` };
+		},
+		handle(command, ctx) {
+			if (command.kind === "files-usage") {
+				ctx.notice("info", `${command.reason}\nusage: /files [open|close|pick]`);
+				return;
+			}
+			if (command.kind !== "files") return;
+			const panes = ctx.panes;
+			if (!panes) {
+				ctx.notice(
+					"info",
+					"the files pane is inactive: this session started without panes. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto",
+				);
+				return;
+			}
+			const runLocal = ctx.runLocalOperation ?? ((operation: () => Promise<void>) => void operation());
+			runLocal(async () => {
+				const result = await panes.files(command.action);
+				if (result.status === "opened") {
+					// The in-terminal chooser reports through its own composer notice.
+					if (result.paneId !== null) {
+						ctx.notice(
+							"success",
+							result.existing ? `files pane focused (${result.paneId})` : `files pane opened (${result.paneId})`,
+						);
+					}
+				} else if (result.status === "closed") {
+					ctx.notice("info", "files pane closed");
+				} else if (result.status === "missing-binary") {
+					ctx.io.stdout(`${result.detail}\n`);
+					ctx.render();
+				} else {
+					ctx.notice("warn", result.reason);
+				}
+			});
+		},
+	},
 	{
 		name: "thinking",
 		description: "Set the chat thinking level",
@@ -2069,6 +2151,39 @@ function retiredCommandHint(token: string): string | undefined {
 }
 
 /** Pure slash-command parser: no I/O, no side effects. Walks the registry in order. */
+/**
+ * One notice line for a reload outcome. Success when the generation committed
+ * cleanly; warn when it committed with dropped hooks or declaration issues;
+ * error when it was refused and the previous generation stays active.
+ */
+export function formatExtensionReloadNotice(outcome: ExtensionReloadOutcome): [NoticeLevel, string] {
+	if (outcome.status !== "committed") {
+		return ["error", `extensions: reload rejected (${outcome.reason}); generation ${outcome.generation} stays active`];
+	}
+	const delta = outcome.changed
+		? `changed: +${outcome.added.length} -${outcome.removed.length} ~${outcome.modified.length}`
+		: "unchanged";
+	const issueCount = outcome.hooks.fileIssues + outcome.hooks.issues;
+	const hookParts = [`${outcome.hooks.registered} registered`];
+	if (outcome.hooks.dropped > 0) hookParts.push(`${outcome.hooks.dropped} dropped`);
+	if (issueCount > 0) hookParts.push(`${issueCount} issue${issueCount === 1 ? "" : "s"}`);
+	if (outcome.hooks.overridden > 0) hookParts.push(`${outcome.hooks.overridden} overridden`);
+	const level: NoticeLevel = outcome.hooks.dropped > 0 || issueCount > 0 ? "warn" : "success";
+	return [level, `extensions: generation ${outcome.generation} committed (${delta}); hooks: ${hookParts.join(", ")}`];
+}
+
+function reloadExtensionsCommand(ctx: SlashCommandContext): void {
+	if (!ctx.reloadExtensions) {
+		ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
+		return;
+	}
+	const outcome = ctx.reloadExtensions();
+	const [level, text] = formatExtensionReloadNotice(outcome);
+	ctx.notice(level, text);
+	for (const line of outcome.lines) ctx.notice("warn", line);
+	if (outcome.status === "committed") ctx.openExtensions();
+}
+
 export function parseSlashCommand(input: string): SlashCommand {
 	const trimmed = input.trim();
 	if (trimmed.length === 0) return { kind: "empty" };

package/src/interactive/stream-pacing-policy.ts

@@ -1,28 +1,6 @@
-import type { SmoothStreaming } from "../core/defaults.js";
-
-export const SMOOTH_STREAM_ENV = "CLIO_CODER_SMOOTH_STREAM";
-
-/**
- * One-process override precedence: a valid environment value wins, while an
- * invalid value can never accidentally enable animation. `0` is the immediate
- * escape hatch; `1` is accepted as the explicit `on` spelling.
- */
-export function resolveSmoothStreamingMode(
-	configured: SmoothStreaming,
-	env: NodeJS.ProcessEnv = process.env,
-): SmoothStreaming {
-	const raw = env[SMOOTH_STREAM_ENV]?.trim().toLowerCase();
-	if (!raw) return configured;
-	if (raw === "0" || raw === "off" || raw === "false") return "off";
-	if (raw === "auto") return "auto";
-	if (raw === "1" || raw === "on" || raw === "true") return "on";
-	return "off";
-}
-
 export interface AutoPacingEnvironment {
 	isTTY: boolean;
 	term?: string;
-	termProgram?: string;
 	sshConnection?: string;
 	sshTty?: string;
 	tmux?: string;
@@ -53,7 +31,6 @@ export function processAutoPacingAllowed(backpressureObserved: boolean, env: Nod
 	return autoPacingAllowed({
 		isTTY: process.stdout.isTTY === true,
 		...(env.TERM === undefined ? {} : { term: env.TERM }),
-		...(env.TERM_PROGRAM === undefined ? {} : { termProgram: env.TERM_PROGRAM }),
 		...(env.SSH_CONNECTION === undefined ? {} : { sshConnection: env.SSH_CONNECTION }),
 		...(env.SSH_TTY === undefined ? {} : { sshTty: env.SSH_TTY }),
 		...(env.TMUX === undefined ? {} : { tmux: env.TMUX }),