@iowarp/clio-coder 0.4.5 → 0.4.7

package/src/interactive/slash-commands.ts

@@ -12,6 +12,9 @@ import type { RunReceipt } from "../domains/dispatch/types.js";
 import type { JobThinkingLevel } from "../domains/dispatch/validation.js";
 import type { ReceiptIntegrityOutcome } from "../domains/evidence/trust-status.js";
 import type { InstalledExtension } from "../domains/extensions/index.js";
+import { isExtensionCommandToken } from "../domains/extensions/operator-commands.js";
+import type { OperatorExtensionRuntime } from "../domains/extensions/operator-runtime.js";
+import type { ExtensionOutput } from "../domains/extensions/public-api.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
 import {
 	PANES_PRESET_IDS,
@@ -30,6 +33,7 @@ import type {
 	ResourceList,
 } from "../domains/resources/index.js";
 import { parseSkillCommand, SKILL_SURFACE_CLEAR_ARG } from "../domains/resources/index.js";
+import { isLibraryKind } from "../domains/resources/library-types.js";
 import { activeDecisionRefs } from "../domains/session/decision-board.js";
 import type { DecisionLedgerEntry } from "../domains/session/entries.js";
 import type { ShareImportPlan } from "../domains/share/index.js";
@@ -56,7 +60,7 @@ import {
 	type OracleDigestSources,
 	packOracleDigest,
 } from "./oracle.js";
-import { isLibraryTab, LIBRARY_TABS } from "./overlays/library-tabs.js";
+import { promptSourceLabel } from "./prompt-source-label.js";
 import type { CommandArgsSpec, CommandPositionalSpec, ParsedArgs } from "./slash-spec.js";
 import { matchFromSpec, usageLine } from "./slash-spec.js";
 import {
@@ -85,9 +89,9 @@ import type { WorkerEntryState } from "./worker-stream.js";
  * `../engine/tui.js`. Those modules share one bundle chunk with the instant
  * shell's Stage 0 closure, and a second, disjoint reacher makes esbuild split
  * it, which is a startup-latency regression rather than a style problem. The
- * parse-time data tables the registry needs live in leaves for that reason:
- * `./overlays/library-tabs.js` and `COUNCIL_SYNTHESIS_LABEL` in
- * `./council.js`. Import from those, not from overlays that re-export them.
+ * parse-time data tables the registry needs live in leaves for that reason,
+ * such as `COUNCIL_SYNTHESIS_LABEL` in `./council.js`. Import from those,
+ * not from overlays that re-export them.
  *
  * Boundaries rule6 in `tests/boundaries/check-boundaries.ts` refuses a violation
  * at lint time; `tests/contracts/instant-shell-import-graph.test.ts` is the
@@ -112,6 +116,24 @@ export const SETTINGS_AREA_IDS = [
 ] as const;
 export type SettingsAreaId = (typeof SETTINGS_AREA_IDS)[number];
 
+/** What `/library <verb> <ref>` asks the browser to review once it is open. */
+export type LibraryBrowseIntent = "install" | "update" | "enable" | "disable" | "remove";
+
+/**
+ * How a command opens the Library.
+ *
+ * A reference is a selection, never a write. `/library install <ref>` opens the
+ * browser on that row with its review armed, so the operator reads the plan
+ * that command produced before any of it lands.
+ */
+export interface LibraryBrowseRequest {
+	tab?: LibraryEntryKind;
+	focus?: string;
+	intent?: LibraryBrowseIntent;
+	importSource?: string;
+	scope?: "user" | "project";
+}
+
 type SlashCommandVariant =
 	| { kind: "quit" }
 	| { kind: "help"; query?: string }
@@ -120,8 +142,20 @@ type SlashCommandVariant =
 	| { kind: "context-refresh" }
 	/** `ref` is the turnId an `[evicted ...]` marker names. */
 	| { kind: "context-recall"; ref: string }
-	| { kind: "skill-selector" }
-	| { kind: "resources"; family?: "skills" | "prompts" | "extensions"; tab?: LibraryEntryKind; action?: "reload" }
+	| {
+			kind: "resources";
+			family?: "extensions" | "plugins";
+			tab?: LibraryEntryKind;
+			action?: "reload";
+			/** A package ref or resource key the browser selects on open. */
+			focus?: string;
+			/** An operation to review on that row. Nothing is written before the review. */
+			intent?: LibraryBrowseIntent;
+			/** A path or URL `/library import` asks the import surface to review. */
+			importSource?: string;
+			/** Explicit `--user`/`--project`; absent leaves the browser's own selection. */
+			scope?: "user" | "project";
+	  }
 	| { kind: "skill-invocation"; text: string }
 	/** `/skill off`: drop the tool surface an activated skill armed for the session. */
 	| { kind: "skill-surface-clear" }
@@ -174,8 +208,6 @@ type SlashCommandVariant =
 	| { kind: "files-usage"; reason: string }
 	| { kind: "thinking-set"; level: string }
 	| { kind: "thinking-picker" }
-	| { kind: "output-set"; verbosity: string }
-	| { kind: "output-picker" }
 	| { kind: "model" }
 	| { kind: "model-set"; pattern: string }
 	| { kind: "settings"; area?: SettingsAreaId; group?: string }
@@ -191,7 +223,12 @@ type SlashCommandVariant =
 	| { kind: "usage-error"; command: string; reason: string }
 	| { kind: "empty" };
 
-export type SlashCommand = SlashCommandVariant;
+export type SlashCommand =
+	| SlashCommandVariant
+	| { kind: "background" }
+	| { kind: "editor"; text: string }
+	| { kind: "interrupt"; text: string }
+	| { kind: "notifications-dismiss"; all: boolean };
 
 export type SlashCommandKind = SlashCommand["kind"];
 
@@ -207,11 +244,6 @@ export type SetThinkingLevelResult =
 	| { status: "unsupported"; level: string; supported: ReadonlyArray<string> }
 	| { status: "unavailable" };
 
-export type SetOutputVerbosityResult =
-	| { status: "applied"; verbosity: string }
-	| { status: "unsupported"; verbosity: string; supported: ReadonlyArray<string> }
-	| { status: "unavailable" };
-
 /**
  * What one admitted dispatch-tool call reports back to `/council`. The council
  * itself is watched on the board and in the transcript, so success is silent;
@@ -560,12 +592,31 @@ function shareWorkerRun(runId: string | undefined, ctx: SlashCommandContext): vo
 	ctx.submitOperatorNote(note);
 }
 
+/** What the transcript shows for a display-only prompt template. */
+export interface PromptReferenceCard {
+	/** Command name as typed, without the slash: `materio:help`. */
+	command: string;
+	/** Where the template came from, in operator words: `plugin materio`. */
+	source: string;
+	/** The body to show, already reduced to its reference block. */
+	text: string;
+}
+
 /**
  * Runtime dependencies every slash-command handler may need. Every field is
  * injected at startInteractive construction time; handlers never reach into
  * the TUI, chat loop, or overlay module graph directly.
  */
 export interface SlashCommandContext {
+	keyboardActions?: {
+		background(): void;
+		editor(text: string): boolean;
+		interrupt(text: string): void;
+		dismiss(all: boolean): void;
+		outputLabel(): string;
+	};
+	operatorExtensions?: OperatorExtensionRuntime;
+	showExtensionOutput?: (invocation: string, output: ExtensionOutput) => void;
 	io: RunIo;
 	notice: (level: NoticeLevel, text: string) => void;
 	dispatch: DispatchContract;
@@ -579,6 +630,12 @@ export interface SlashCommandContext {
 	 * the request above it. Transcript-only; the line never enters model context.
 	 */
 	echoOperatorCommand?: (text: string) => void;
+	/**
+	 * Render a display-only prompt template as an operator card in the
+	 * transcript. Transcript-only, like the echo: the host that has no chat
+	 * panel leaves it unset and the card falls back to `io.stdout`.
+	 */
+	showReference?: (card: PromptReferenceCard) => void;
 	/**
 	 * Put operator-authored text into the session the way typed text enters it:
 	 * a user turn, persisted in the ledger, visible in the transcript. Used only
@@ -606,7 +663,7 @@ export interface SlashCommandContext {
 	 * until the host wires a session.
 	 */
 	runContextRecall?: (ref: string) => void;
-	openSkillsHub?: (tab?: LibraryEntryKind) => void;
+	openSkillsHub?: (request?: LibraryBrowseRequest) => void;
 	/**
 	 * `/skill off`: drop the tool surface an activated skill armed for the
 	 * session. Returns the names that were armed. Absent on a host with no
@@ -622,12 +679,13 @@ export interface SlashCommandContext {
 	expandPromptTemplate?: (text: string) => PromptTemplateExpansion;
 	listExtensions?: () => ReadonlyArray<InstalledExtension>;
 	/**
-	 * `/resources extensions reload`: build, validate, and commit the next
+	 * `/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;
+	reloadPlugins?: () => { generation: number };
 	/** Detection report, pending proposals, and the two consent actions `/interop` drives. */
 	interop?: {
 		report: () => InteropReport | null;
@@ -728,8 +786,6 @@ export interface SlashCommandContext {
 	thinkingLevelChoices?: () => ReadonlyArray<{ value: string; label: string }>;
 	openThinkingPicker?: () => void;
 	/** Apply a transcript verbosity named on the command line; refused values are reported by the caller. */
-	setOutputVerbosity?: (verbosity: string) => SetOutputVerbosityResult;
-	openOutputPicker?: () => void;
 	openModel: () => void;
 	/** Live providers contract used by `/model <pattern>` to resolve directly. */
 	providers: ProvidersContract;
@@ -746,8 +802,6 @@ export interface SlashCommandContext {
 	openTree: () => void;
 	openMessagePicker: () => void;
 	openHelp: (query?: string) => void;
-	openAgents: () => void;
-	openPrompts: () => void;
 	openExtensions: () => void;
 	openInterop?: () => void;
 	setEditorText?: (text: string) => void;
@@ -818,7 +872,7 @@ export interface BuiltinSlashCommand {
 	match?(trimmed: string): SlashCommand | null;
 	fromArgs?(parsed: ParsedArgs, trimmed: string): SlashCommand;
 	/** Execute `command` against `ctx`. Called only for kinds declared in `kinds`. */
-	handle(command: SlashCommand, ctx: SlashCommandContext): void;
+	handle(command: SlashCommand, ctx: SlashCommandContext): void | "rejected";
 }
 
 const RUN_THINKING_LEVELS: ReadonlyArray<JobThinkingLevel> = THINKING_LEVELS;
@@ -896,6 +950,85 @@ function formatPanesStatus(status: PanesStatus): ReadonlyArray<string> {
 }
 
 export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
+	{
+		name: "background",
+		description: "Detach the newest eligible attached dispatch",
+		group: "Work",
+		kinds: ["background"],
+		args: {},
+		fromArgs: fromArgsOrUsage("background", { kind: "background" }),
+		handle(_command, ctx) {
+			if (!ctx.keyboardActions) {
+				ctx.notice("warn", "Background action requires an interactive session");
+				return "rejected";
+			}
+			ctx.keyboardActions.background();
+		},
+	},
+	{
+		name: "editor",
+		description: "Edit explicit text (or an empty buffer) externally",
+		group: "Work",
+		kinds: ["editor"],
+		args: { positionals: [{ name: "text", required: false, rest: true }] },
+		match(text) {
+			const match = /^\/editor(?:\s+([\s\S]*))?$/u.exec(text);
+			return match ? { kind: "editor", text: match[1] ?? "" } : null;
+		},
+		handle(command, ctx) {
+			if (command.kind !== "editor") return;
+			if (!ctx.keyboardActions) {
+				ctx.notice("warn", "External editing requires an interactive session");
+				return "rejected";
+			}
+			if (!ctx.keyboardActions.editor(command.text)) return "rejected";
+		},
+	},
+	{
+		name: "interrupt",
+		description: "Interrupt the active run and send this text",
+		group: "Work",
+		kinds: ["interrupt"],
+		args: { positionals: [{ name: "text", required: true, rest: true }] },
+		match(text) {
+			const match = /^\/interrupt(?:\s+([\s\S]*))?$/u.exec(text);
+			return match
+				? match[1]?.trim()
+					? { kind: "interrupt", text: match[1] }
+					: { kind: "usage-error", command: "interrupt", reason: "Text is required" }
+				: null;
+		},
+		handle(command, ctx) {
+			if (command.kind !== "interrupt") return;
+			if (!ctx.keyboardActions) {
+				ctx.notice("warn", "Interrupt requires an interactive session");
+				return "rejected";
+			}
+			ctx.keyboardActions.interrupt(command.text);
+		},
+	},
+	{
+		name: "notifications",
+		description: "Dismiss the oldest notification or explicitly dismiss all",
+		group: "Inspect",
+		kinds: ["notifications-dismiss"],
+		args: { subcommands: { dismiss: { positionals: [{ name: "all", required: false }] } } },
+		match(text) {
+			if (!/^\/notifications(?:\s|$)/u.test(text)) return null;
+			const match = /^\/notifications\s+dismiss(?:\s+(all))?$/u.exec(text);
+			return match
+				? { kind: "notifications-dismiss", all: match[1] === "all" }
+				: { kind: "usage-error", command: "notifications", reason: "Use /notifications dismiss [all]" };
+		},
+		handle(command, ctx) {
+			if (command.kind !== "notifications-dismiss") return;
+			if (!ctx.keyboardActions) {
+				ctx.notice("warn", "Notifications require an interactive session");
+				return "rejected";
+			}
+			ctx.keyboardActions.dismiss(command.all);
+		},
+	},
 	{
 		name: "quit",
 		description: "Exit Clio Coder",
@@ -924,18 +1057,22 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	},
 	{
 		name: "skill",
-		description: "Open the Skills Hub, invoke a skill, or `off` to drop an active skill's tool surface",
+		description: "Invoke a skill, or use `off` to clear its tool surface",
 		group: "Work",
-		kinds: ["skill-selector", "skill-invocation", "skill-surface-clear"],
+		kinds: ["skill-invocation", "skill-surface-clear"],
 		args: {
 			positionals: [
-				{ name: "name", required: false },
+				{ name: "name", required: true },
 				{ name: "task", required: false, rest: true },
 			],
 		},
 		match(trimmed) {
 			if (trimmed === "/skill") {
-				return { kind: "skill-selector" };
+				return {
+					kind: "usage-error",
+					command: "skill",
+					reason: "Choose /skills to browse, /skill <name> to invoke, or /skill off to clear the active tool surface",
+				};
 			}
 			const command = parseSkillCommand(trimmed);
 			if (!command) return null;
@@ -948,9 +1085,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			return { kind: "skill-invocation", text: trimmed };
 		},
 		handle(command, ctx) {
-			if (command.kind === "skill-selector") {
-				ctx.openSkillsHub?.();
-			} else if (command.kind === "skill-invocation") {
+			if (command.kind === "skill-invocation") {
 				ctx.submitChat(command.text);
 			} else if (command.kind === "skill-surface-clear") {
 				const cleared = ctx.clearSkillSurface?.() ?? [];
@@ -962,50 +1097,153 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 	},
 	{
-		name: "resources",
-		description: "Browse skills, prompts, libraries, and extensions",
+		name: "library",
+		description: "Open the full-screen recipe library, review a package operation, or reload installed recipes",
 		group: "Inspect",
 		kinds: ["resources"],
 		subcommandDescriptions: {
-			skills: "Browse installed skills",
-			prompts: "Browse prompt templates",
-			library: "Browse resource libraries",
-			extensions: "Browse installed extensions; `reload` commits a new extension generation",
+			inspect: "Open the Library on one package or recipe",
+			install: "Review installing one package, then apply it",
+			remove: "Review removing one package, then apply it",
+			import: "Review a plugin source from a path or URL",
+			reload: "Refresh installed recipe resources in this session",
 		},
 		args: {
 			subcommands: {
-				skills: {},
-				prompts: {},
-				library: { positionals: [{ name: "kind", required: false }] },
-				extensions: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
+				inspect: {
+					positionals: [{ name: "ref", required: true }],
+					flags: [{ name: "--user" }, { name: "--project" }],
+				},
+				install: {
+					positionals: [{ name: "ref", required: true }],
+					flags: [{ name: "--user" }, { name: "--project" }],
+				},
+				remove: {
+					positionals: [{ name: "ref", required: true }],
+					flags: [{ name: "--user" }, { name: "--project" }],
+				},
+				import: {
+					positionals: [{ name: "path-or-url", required: true }],
+					flags: [{ name: "--user" }, { name: "--project" }],
+				},
+				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") 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)) {
-				const known = LIBRARY_TABS.map((entry) => entry.id).join(", ");
-				return { kind: "usage-error", command: "resources", reason: `Unknown kind: ${tab} (one of ${known})` };
-			}
-			return { kind: "resources", tab };
+			if (parsed.error) return { kind: "usage-error", command: "library", reason: parsed.error };
+			if (parsed.flags.has("--user") && parsed.flags.has("--project"))
+				return { kind: "usage-error", command: "library", reason: "Choose one destination: --user or --project" };
+			const scope = parsed.flags.has("--project")
+				? ("project" as const)
+				: parsed.flags.has("--user")
+					? ("user" as const)
+					: undefined;
+			const subcommand = parsed.subcommand;
+			if (subcommand === "reload") return { kind: "resources", family: "plugins", action: "reload" };
+			if (subcommand === "import") {
+				const source = parsed.rest ?? parsed.positionals[0];
+				if (!source)
+					return {
+						kind: "usage-error",
+						command: "library",
+						reason: "/library import needs a directory path or a source URL to review",
+					};
+				return { kind: "resources", tab: "plugin", importSource: source, ...(scope ? { scope } : {}) };
+			}
+			if (subcommand === "inspect" || subcommand === "install" || subcommand === "remove") {
+				const ref = parsed.positionals[0];
+				if (!ref)
+					return {
+						kind: "usage-error",
+						command: "library",
+						reason: `/library ${subcommand} needs a kind:name reference, such as plugin:materio, or a recipe name`,
+					};
+				const prefix = ref.split(":", 1)[0] ?? "";
+				return {
+					kind: "resources",
+					tab: isLibraryKind(prefix) && ref.includes(":") ? prefix : "plugin",
+					focus: ref,
+					...(subcommand === "inspect" ? {} : { intent: subcommand as LibraryBrowseIntent }),
+					...(scope ? { scope } : {}),
+				};
+			}
+			if (parsed.error || parsed.positionals.length > 0)
+				return {
+					kind: "usage-error",
+					command: "library",
+					reason:
+						"Use /library to browse, /library inspect|install|remove <ref>, /library import <path-or-url>, or /library reload; /skills, /agents and /prompts open the same browser on their category",
+				};
+			return { kind: "resources", tab: "plugin" };
 		},
 		handle(command, ctx) {
 			if (command.kind !== "resources") return;
-			if (command.family === "prompts") ctx.openPrompts();
-			else if (command.family === "extensions") {
+			if (command.family === "plugins") {
+				if (!ctx.reloadPlugins)
+					ctx.notice("warn", "library: reload is unavailable in this session; restart to refresh resources");
+				else {
+					try {
+						const snapshot = ctx.reloadPlugins();
+						ctx.notice("success", `library: generation ${snapshot.generation} committed`);
+					} catch (error) {
+						ctx.notice("error", `library: reload failed: ${error instanceof Error ? error.message : String(error)}`);
+					}
+				}
+				return;
+			}
+			if (command.family === "extensions") {
 				if (command.action === "reload") reloadExtensionsCommand(ctx);
 				else ctx.openExtensions();
-			} else ctx.openSkillsHub?.(command.tab);
+				return;
+			}
+			ctx.openSkillsHub?.({
+				...(command.tab ? { tab: command.tab } : {}),
+				...(command.focus ? { focus: command.focus } : {}),
+				...(command.intent ? { intent: command.intent } : {}),
+				...(command.importSource ? { importSource: command.importSource } : {}),
+				...(command.scope ? { scope: command.scope } : {}),
+			});
+		},
+	},
+	{
+		name: "skills",
+		description: "Open the Library on Skills",
+		group: "Inspect",
+		kinds: [],
+		args: {},
+		fromArgs: fromArgsOrUsage("skills", { kind: "resources", tab: "skill" }),
+		handle(_command, ctx) {
+			ctx.openSkillsHub?.({ tab: "skill" });
+		},
+	},
+	{
+		name: "prompts",
+		description: "Open the Library on Prompts",
+		group: "Inspect",
+		kinds: [],
+		args: {},
+		fromArgs: fromArgsOrUsage("prompts", { kind: "resources", tab: "prompt" }),
+		handle(_command, ctx) {
+			ctx.openSkillsHub?.({ tab: "prompt" });
+		},
+	},
+	{
+		name: "extensions",
+		description: "Inspect harness extensions or reload their commands, hooks and operator UI",
+		group: "Inspect",
+		// Harness navigation uses the shared overlay dispatcher, independently of recipe reload.
+		kinds: [],
+		args: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "extensions", reason: parsed.error };
+			if (parsed.positionals[0] && parsed.positionals[0] !== "reload")
+				return { kind: "usage-error", command: "extensions", reason: "extensions accepts only reload" };
+			return { kind: "resources", family: "extensions", ...(parsed.positionals[0] ? { action: "reload" as const } : {}) };
+		},
+		handle(command, ctx) {
+			if (command.kind !== "resources" || command.family !== "extensions") return;
+			if (command.action === "reload") reloadExtensionsCommand(ctx);
+			else ctx.openExtensions();
 		},
 	},
 	{
@@ -1347,23 +1585,36 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 	},
 	{
-		name: "agents",
-		description: "List agents or connect a detected external agent",
+		name: "interop",
+		description: "Inspect coding agents and adopt safe resources",
 		group: "Inspect",
 		kinds: ["agents"],
-		subcommandDescriptions: {
-			list: "List native and external agents",
-			connect: "Review detected external-agent proposals",
+		args: {},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "interop", reason: parsed.error };
+			return { kind: "agents", connect: true };
+		},
+		handle(_command, ctx) {
+			ctx.openInterop?.();
 		},
-		args: { subcommands: { list: {}, connect: {} } },
+	},
+	{
+		name: "agents",
+		description: "Open the Library on Agents",
+		group: "Inspect",
+		kinds: [],
+		args: {},
 		fromArgs(parsed) {
-			if (parsed.error) return { kind: "usage-error", command: "agents", reason: parsed.error };
-			return { kind: "agents", ...(parsed.subcommand === "connect" ? { connect: true } : {}) };
+			if (parsed.error)
+				return {
+					kind: "usage-error",
+					command: "agents",
+					reason: "Use /agents to browse recipes, or /interop to inspect another local agent's resources",
+				};
+			return { kind: "resources", tab: "agent" };
 		},
-		handle(command, ctx) {
-			if (command.kind !== "agents") return;
-			if (command.connect) ctx.openInterop?.();
-			else ctx.openAgents();
+		handle(_command, ctx) {
+			ctx.openSkillsHub?.({ tab: "agent" });
 		},
 	},
 	{
@@ -1917,35 +2168,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			ctx.render();
 		},
 	},
-	{
-		name: "output",
-		description: "Set transcript detail to minimal, default, or verbose",
-		group: "Configure",
-		kinds: ["output-set", "output-picker"],
-		args: { positionals: [{ name: "verbosity", required: false }] },
-		fromArgs(parsed) {
-			if (parsed.error) return { kind: "usage-error", command: "output", reason: parsed.error };
-			const verbosity = parsed.positionals[0];
-			return verbosity ? { kind: "output-set", verbosity } : { kind: "output-picker" };
-		},
-		handle(command, ctx) {
-			if (command.kind === "output-picker") {
-				if (ctx.openOutputPicker) ctx.openOutputPicker();
-				else ctx.notice("error", "output picker is not wired in this session");
-				return;
-			}
-			if (command.kind !== "output-set") return;
-			const result = ctx.setOutputVerbosity?.(command.verbosity) ?? { status: "unavailable" as const };
-			if (result.status === "applied") {
-				ctx.notice("success", `output detail: ${result.verbosity}`);
-			} else if (result.status === "unsupported") {
-				ctx.notice("error", `output detail "${result.verbosity}" is not one of ${result.supported.join(", ")}`);
-			} else {
-				ctx.notice("error", "output detail cannot be set right now");
-			}
-			ctx.render();
-		},
-	},
 	{
 		name: "model",
 		description: "Open model selector or set a model",
@@ -2185,6 +2407,12 @@ export function formatExtensionReloadNotice(outcome: ExtensionReloadOutcome): [N
 }
 
 function reloadExtensionsCommand(ctx: SlashCommandContext): void {
+	if (ctx.operatorExtensions) {
+		void ctx.operatorExtensions.reload().then((result) => {
+			if (result.status === "deferred") ctx.notice("info", result.message);
+		});
+		return;
+	}
 	if (!ctx.reloadExtensions) {
 		ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
 		return;
@@ -2199,6 +2427,22 @@ function reloadExtensionsCommand(ctx: SlashCommandContext): void {
 export function parseSlashCommand(input: string): SlashCommand {
 	const trimmed = input.trim();
 	if (trimmed.length === 0) return { kind: "empty" };
+	const retiredLibrary = /^\/(resources|plugins)(?:\s|$)/u.exec(trimmed);
+	if (retiredLibrary) {
+		return {
+			kind: "usage-error",
+			command: retiredLibrary[1] ?? "library",
+			reason: "Use /library to browse and manage recipes; use /extensions for harness extensions",
+		};
+	}
+	if (/^\/output(?:\s|$)/u.test(trimmed)) {
+		return {
+			kind: "usage-error",
+			command: "output",
+			reason:
+				"Use /help for the effective Output cycle keys, or /settings interface to save a default. Use /view for full details",
+		};
+	}
 	if (trimmed.startsWith(COMMAND_ESCAPE)) return { kind: "unknown", text: trimmed.slice(1) };
 	for (const entry of BUILTIN_SLASH_COMMANDS) {
 		const match = entry.match ? entry.match(trimmed) : matchFromSpec(entry, trimmed);
@@ -2206,7 +2450,8 @@ export function parseSlashCommand(input: string): SlashCommand {
 	}
 	if (trimmed.startsWith("/")) {
 		const token = trimmed.slice(1).split(/\s+/u)[0] ?? "";
-		if (COMMAND_SHAPED_TOKEN.test(token)) return { kind: "unknown-command", token, text: trimmed };
+		if (COMMAND_SHAPED_TOKEN.test(token) || isExtensionCommandToken(token))
+			return { kind: "unknown-command", token, text: trimmed };
 	}
 	return { kind: "unknown", text: trimmed };
 }
@@ -2234,9 +2479,49 @@ export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandCon
 			ctx.submitChat(command.text);
 			return "accepted";
 		}
+		// A display-only template is answered here, for the operator, and the
+		// model is never told it was asked: no turn, no session entry, no tokens.
+		if (expansion?.expanded === false && expansion.display) {
+			const { template, text } = expansion.display;
+			const card: PromptReferenceCard = {
+				command: template.name,
+				source: promptSourceLabel(template.sourceInfo),
+				text,
+			};
+			if (ctx.showReference) ctx.showReference(card);
+			else ctx.io.stdout(`/${card.command} (${card.source})\n${card.text}\n`);
+			ctx.render();
+			return "accepted";
+		}
 		// A template that exists and refused is not a typo. Its reason reaches the
 		// operator and nothing reaches the model.
 		const refusal = expansion?.expanded === false ? expansion.refusal : undefined;
+		if (!refusal && isExtensionCommandToken(command.token) && ctx.operatorExtensions) {
+			const runtime = ctx.operatorExtensions;
+			const promptNames = ctx.listPrompts().items.map((prompt) => prompt.name);
+			const row = runtime.commands(promptNames).find((row) => row.invocation === command.token);
+			if (!row?.available) {
+				ctx.notice("error", row?.reason ?? `/${command.token} is not an available extension command`);
+				ctx.render();
+				return "rejected";
+			}
+			const args = command.text.slice(command.token.length + 1).trim();
+			const runLocal = ctx.runLocalOperation ?? ((operation: () => Promise<void>) => void operation());
+			runLocal(async () => {
+				try {
+					const output = await runtime.invoke(
+						command.token,
+						args,
+						ctx.listPrompts().items.map((prompt) => prompt.name),
+					);
+					if (ctx.showExtensionOutput) ctx.showExtensionOutput(command.token, output);
+					else ctx.io.stdout(`${output.text}\n`);
+				} catch (error) {
+					ctx.notice("error", `${command.token}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+			return "accepted";
+		}
 		ctx.notice("error", refusal ? refusal.message : `/${command.token} is not a command. Type /help for the list.`);
 		ctx.render();
 		return "rejected";
@@ -2244,14 +2529,17 @@ export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandCon
 	if (command.kind === "usage-error") {
 		const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === command.command);
 		const usage = entry ? ` ${usageNotice(entry)}` : "";
-		ctx.notice("error", `${command.reason}.${usage}`);
+		const reason =
+			command.command === "output" && ctx.keyboardActions
+				? `Use ${ctx.keyboardActions.outputLabel()} to cycle Output style, or /settings interface to save a default`
+				: command.reason;
+		ctx.notice("error", `${reason}.${usage}`);
 		ctx.render();
 		return "rejected";
 	}
 	const entry = HANDLER_BY_KIND.get(command.kind);
 	if (!entry) return "rejected";
-	entry.handle(command, ctx);
-	return "accepted";
+	return entry.handle(command, ctx) === "rejected" ? "rejected" : "accepted";
 }
 
 export interface CommandReferenceEntry {
@@ -2275,6 +2563,7 @@ const COMMAND_ORDER = [
 	"share",
 	"skill",
 	"agents",
+	"interop",
 	"tasks",
 	"context",
 	"memory",
@@ -2282,11 +2571,13 @@ const COMMAND_ORDER = [
 	"panes",
 	"cost",
 	"decisions",
-	"resources",
+	"library",
+	"skills",
+	"prompts",
+	"extensions",
 	"help",
 	"model",
 	"thinking",
-	"output",
 	"settings",
 	"new",
 	"resume",