@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/interactive/renderers/worker-entry.ts

@@ -76,14 +76,18 @@ function headerLine(entry: WorkerEntryState, width: number): string {
 /**
  * Outcome glyph, with the word on the footer. The folded row uses the glyph
  * alone, as a tool subline does, so a list of cards reads like a list of calls.
+ * Abandoned names itself rather than falling through to its `stalled`
+ * outcome code, so it reads as a ledger-side finding instead of the ordinary
+ * heartbeat-timeout `stalled` a sealed receipt reports.
  */
 function outcomeUnit(receipt: WorkerReceiptSummary, word: boolean): string {
 	if (receipt.outcome === "succeeded") return theme.fg("success", word ? `${GLYPH.ok} ok` : GLYPH.ok);
 	if (receipt.outcome === "canceled") return theme.fg("dim", `${GLYPH.cancelled} canceled`);
+	if (receipt.abandonedDetail !== undefined) return theme.fg("error", word ? `${GLYPH.error} abandoned` : GLYPH.error);
 	return theme.fg("error", `${GLYPH.error} ${receipt.outcomeCode ?? receipt.outcome}`);
 }
 
-/** Live status for a block that has not settled: a spinner-free, honest "running". */
+/** A block with no settled receipt yet: a spinner-free, honest "running". */
 function pendingUnit(entry: WorkerEntryState): string {
 	return theme.fg(
 		"action",
@@ -91,6 +95,16 @@ function pendingUnit(entry: WorkerEntryState): string {
 	);
 }
 
+/**
+ * Whether a block should render as still going rather than settled: live,
+ * never yet received a receipt (`entry.receipt === undefined`), or replayed
+ * from a `runs.json` row with no `endedAt` (`stillRunning`) because its
+ * process is still executing in another instance of Clio.
+ */
+function isPending(entry: WorkerEntryState): boolean {
+	return entry.receipt === undefined || entry.receipt.stillRunning === true;
+}
+
 /**
  * Receipt facts as footer units. A unit is dropped when unknown rather than
  * rendered as zero: an ACP peer reports no tokens at all, so its footer names
@@ -108,7 +122,8 @@ function footerUnits(receipt: WorkerReceiptSummary): string[] {
 	}
 	if (receipt.durationMs !== undefined) units.push(dim(formatCompactMs(receipt.durationMs)));
 	if (receipt.contract !== undefined) units.push(dim(`contract ${receipt.contract}`));
-	if (receipt.receiptUnavailable === true) units.push(theme.fg("warning", "receipt unavailable"));
+	if (receipt.abandonedDetail !== undefined) units.push(theme.fg("warning", receipt.abandonedDetail));
+	else if (receipt.receiptUnavailable === true) units.push(theme.fg("warning", "receipt unavailable"));
 	return units;
 }
 
@@ -221,7 +236,7 @@ function failureLines(entry: WorkerEntryState, width: number): string[] {
 
 /** The receipt line, whole units only; a unit that would not fit is dropped behind a dim ellipsis. */
 function footerLine(entry: WorkerEntryState, width: number): string {
-	const units = entry.receipt === undefined ? [pendingUnit(entry)] : footerUnits(entry.receipt);
+	const units = isPending(entry) || entry.receipt === undefined ? [pendingUnit(entry)] : footerUnits(entry.receipt);
 	return fitUnits(theme, dim(FOOTER), units, width);
 }
 
@@ -236,7 +251,8 @@ function footerLine(entry: WorkerEntryState, width: number): string {
  */
 function foldedLine(entry: WorkerEntryState, width: number, expandKey: string | undefined): string {
 	const identity = `${originGlyph(entry)} ${identityUnits(entry).join(dim(SEPARATOR))}`;
-	const status = entry.receipt === undefined ? pendingUnit(entry) : outcomeUnit(entry.receipt, false);
+	const status =
+		isPending(entry) || entry.receipt === undefined ? pendingUnit(entry) : outcomeUnit(entry.receipt, false);
 	const elapsed =
 		entry.receipt?.durationMs === undefined ? "" : dim(`${SEPARATOR}${formatCompactMs(entry.receipt.durationMs)}`);
 	const hint = expandKey === undefined || expandKey.length === 0 ? "" : dim(` (${expandKey})`);

package/src/interactive/session-switch-settlement.ts

@@ -0,0 +1,10 @@
+import type { ChatLoop } from "./chat-loop.js";
+
+type SessionSwitchChat = Pick<ChatLoop, "cancel" | "isStreaming" | "whenSettled">;
+
+/** Settle an active turn before its owning session writer can be replaced. */
+export function settleChatBeforeSessionSwitch(chat: SessionSwitchChat): Promise<void> | null {
+	if (!chat.isStreaming()) return null;
+	chat.cancel();
+	return chat.whenSettled();
+}

package/src/interactive/slash-autocomplete.ts

@@ -84,45 +84,6 @@ function argumentCompletionItems(
 	});
 }
 
-/**
- * The alias spellings tab-completion offers as commands of their own.
- *
- * An alias is a real invocation: `/exit`, `/ctx`, `/compact`, and `/models` all
- * run. Completion built its list from canonical names only, so typing `/exi`
- * offered nothing and the spelling the operator was taught by `/help` looked
- * like it did not exist. Colon aliases stay out: `/skill:` and `/skills:` are
- * routed by the dedicated skill branch, which offers skill names after the
- * colon, and listing the bare prefixes beside `/skill` would put three near
- * identical rows in front of that.
- */
-function aliasCompletionEntries(): SlashAutocompleteCommand[] {
-	const entries: SlashAutocompleteCommand[] = [];
-	for (const ref of commandReference()) {
-		for (const alias of ref.aliases) {
-			if (alias.includes(":")) continue;
-			const standsFor = ref.aliasArgs?.[alias];
-			const argumentHint = standsFor === undefined ? compactArgumentHint(ref.args) : undefined;
-			const args = standsFor === undefined ? ref.args : undefined;
-			entries.push({
-				name: alias,
-				// An alias that stands for a subcommand takes that subcommand's
-				// arguments, not the command's, so it gets neither hint nor argument
-				// completions: offering `/context`'s siblings after `/compact` would
-				// name subcommands that cannot follow it.
-				description: `${ref.description} (alias of /${ref.name}${standsFor === undefined ? "" : ` ${standsFor}`})`,
-				...(argumentHint ? { argumentHint } : {}),
-				...(args
-					? {
-							getArgumentCompletions: (argumentText: string) =>
-								argumentCompletionItems(args, argumentText, ref.subcommandDescriptions),
-						}
-					: {}),
-			});
-		}
-	}
-	return entries;
-}
-
 export function buildSlashAutocompleteCommands(): SlashAutocompleteCommand[] {
 	const reference = commandReference();
 	return SLASH_COMMAND_GROUPS.flatMap((group) => reference.filter((ref) => ref.group === group)).map((ref) => {
@@ -142,42 +103,12 @@ export function buildSlashAutocompleteCommands(): SlashAutocompleteCommand[] {
 	});
 }
 
-function commandCompletionItem(command: SlashAutocompleteCommand): AutocompleteItem {
-	const hint = command.argumentHint;
-	const description = compactCompletionDescription(hint ? `${hint} — ${command.description}` : command.description);
-	return {
-		value: command.name,
-		label: command.name,
-		...(description ? { description } : {}),
-	};
-}
-
 function compactCompletionDescription(description: string | undefined): string | undefined {
 	if (!description || visibleWidth(description) <= COMPLETION_DESCRIPTION_BUDGET) return description;
 	const clipped = truncateToWidth(description, COMPLETION_DESCRIPTION_BUDGET - 1, "", false).trimEnd();
 	return `${clipped}…`;
 }
 
-/**
- * Alias spellings that parse like their canonical command, e.g. /ctx for
- * /context. The /skill: family stays out: it is routed by the dedicated skill
- * branch and never reaches argument completion. So does an alias that stands
- * for a subcommand, e.g. /compact: its arguments are the tail of `/context
- * compact`, so completing them against `/context` would offer the sibling
- * subcommands where free-form instructions go.
- */
-function commandAliasMap(): Map<string, string> {
-	const map = new Map<string, string>();
-	for (const ref of commandReference()) {
-		for (const alias of ref.aliases) {
-			if (alias.includes(":")) continue;
-			if (ref.aliasArgs?.[alias] !== undefined) continue;
-			map.set(alias, ref.name);
-		}
-	}
-	return map;
-}
-
 function isSlashCommandPrefix(lines: string[], cursorLine: number, cursorCol: number): string | null {
 	if (cursorLine !== 0) return null;
 	const currentLine = lines[cursorLine] ?? "";
@@ -195,49 +126,15 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 
 	private readonly provider: CombinedAutocompleteProvider;
 	private readonly listSkills: (() => { installed: Skill[]; marketplace: MarketplaceSkill[] }) | undefined;
-	private readonly aliases: Map<string, string>;
-	private readonly aliasCommands: SlashAutocompleteCommand[];
 
 	constructor(
 		commands: SlashAutocompleteCommand[],
 		basePath: string,
 		fdPath: string | null,
 		listSkills?: () => { installed: Skill[]; marketplace: MarketplaceSkill[] },
-		aliases: Map<string, string> = commandAliasMap(),
-		aliasCommands: SlashAutocompleteCommand[] = aliasCompletionEntries(),
 	) {
 		this.provider = new CombinedAutocompleteProvider(commands, basePath, fdPath);
 		this.listSkills = listSkills;
-		this.aliases = aliases;
-		this.aliasCommands = aliasCommands;
-	}
-
-	/**
-	 * An alias invocation parses exactly like its canonical command, so it must
-	 * complete like it too. The combined provider looks argument completions up
-	 * by exact command name, so the line it sees swaps the alias token for the
-	 * canonical name with the cursor shifted by the length delta. Completion
-	 * application still runs against the user's original spelling because
-	 * argument prefixes never include the command token.
-	 */
-	private canonicalizeAlias(
-		lines: string[],
-		cursorLine: number,
-		cursorCol: number,
-	): { lines: string[]; cursorCol: number } {
-		const line = lines[cursorLine] ?? "";
-		const match = line.match(/^(\s*)\/(\S+)\s/);
-		const lead = match?.[1];
-		const typed = match?.[2];
-		if (lead === undefined || typed === undefined) return { lines, cursorCol };
-		const canonical = this.aliases.get(typed);
-		if (!canonical) return { lines, cursorCol };
-		const nameStart = lead.length + 1;
-		const nameEnd = nameStart + typed.length;
-		if (cursorCol <= nameEnd) return { lines, cursorCol };
-		const next = [...lines];
-		next[cursorLine] = `${line.slice(0, nameStart)}${canonical}${line.slice(nameEnd)}`;
-		return { lines: next, cursorCol: cursorCol + (canonical.length - typed.length) };
 	}
 
 	async getSuggestions(
@@ -257,7 +154,7 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 		// submit, so submitting the bare selector would silently commit
 		// whichever skill happened to sort first instead of opening the Skills
 		// Hub (see FINDINGS.md F1).
-		const skillMatch = textBeforeCursor.match(/^\s*\/skill(?::|\s+)([a-zA-Z0-9_-]*)$/i);
+		const skillMatch = textBeforeCursor.match(/^\s*\/skill\s+([a-zA-Z0-9_-]*)$/i);
 		if (skillMatch && this.listSkills) {
 			const typedPrefix = skillMatch[1]?.toLowerCase() ?? "";
 			const { installed, marketplace } = this.listSkills();
@@ -291,8 +188,7 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 			if (items.length > 0) return { items, prefix: typedPrefix };
 		}
 
-		const canonical = this.canonicalizeAlias(lines, cursorLine, cursorCol);
-		const suggestions = await this.provider.getSuggestions(canonical.lines, cursorLine, canonical.cursorCol, options);
+		const suggestions = await this.provider.getSuggestions(lines, cursorLine, cursorCol, options);
 		const commandPrefix = isSlashCommandPrefix(lines, cursorLine, cursorCol);
 		if (commandPrefix !== null) {
 			const canonicalItems = (suggestions?.items ?? [])
@@ -302,11 +198,7 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 					if (description === item.description || description === undefined) return item;
 					return { ...item, description };
 				});
-			const aliasItems =
-				commandPrefix.length === 0
-					? []
-					: this.aliasCommands.filter((command) => command.name.startsWith(commandPrefix)).map(commandCompletionItem);
-			const items = [...canonicalItems, ...aliasItems];
+			const items = canonicalItems;
 			if (items.length === 0) return null;
 			return { items, prefix: suggestions?.prefix ?? textBeforeCursor };
 		}
@@ -333,16 +225,16 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 		const textBeforeCursor = currentLine.slice(0, cursorCol);
 		const textAfterCursor = currentLine.slice(cursorCol);
 
-		const skillMatch = textBeforeCursor.match(/^\s*\/skill(?::|\s+)[a-zA-Z0-9_-]*$/i);
+		const skillMatch = textBeforeCursor.match(/^\s*\/skill\s+[a-zA-Z0-9_-]*$/i);
 		if (skillMatch && (item.value.startsWith("skill:") || item.value.startsWith("marketplace:"))) {
 			const skillName = item.value.slice(item.value.indexOf(":") + 1);
-			const newLine = `/skill:${skillName} ${textAfterCursor}`;
+			const newLine = `/skill ${skillName} ${textAfterCursor}`;
 			const newLines = [...lines];
 			newLines[cursorLine] = newLine;
 			return {
 				lines: newLines,
 				cursorLine,
-				cursorCol: `/skill:${skillName} `.length,
+				cursorCol: `/skill ${skillName} `.length,
 			};
 		}
 

package/src/interactive/slash-commands.ts

@@ -15,6 +15,7 @@ import { resolveModelReference } from "../domains/providers/index.js";
 import type { PromptTemplate, PromptTemplateExpansion, ResourceList } from "../domains/resources/index.js";
 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 { isToolProfileName, TOOL_PROFILE_NAMES, type ToolProfileName } from "../tools/profiles.js";
 import type { NoticeLevel } from "./command-output.js";
 import { SETTINGS_SECTIONS, type SettingsCenterRowId, type SettingsSectionId } from "./overlays/settings.js";
@@ -58,6 +59,11 @@ type SlashCommandVariant =
 	| { kind: "cost" }
 	| { kind: "context-view" }
 	| { kind: "tasks" }
+	| { kind: "decisions" }
+	| { kind: "tasks-add"; text: string }
+	| { kind: "tasks-hand"; id: string }
+	| { kind: "tasks-done"; id: string }
+	| { kind: "tasks-drop"; id: string }
 	| { kind: "memory" }
 	| { kind: "memory-seed" }
 	| { kind: "view"; filter?: string }
@@ -84,6 +90,8 @@ export type SlashCommand = SlashCommandVariant;
 
 export type SlashCommandKind = SlashCommand["kind"];
 
+export type SlashCommandDispatchResult = "accepted" | "rejected";
+
 export interface RunIo {
 	stdout: (s: string) => void;
 	stderr: (s: string) => void;
@@ -216,7 +224,10 @@ export async function handleRun(
 	options: RunCommandOptions = {},
 ): Promise<void> {
 	if (options.target && options.workerProfile) {
-		deps.notice("warn", `--target ${options.target} takes precedence; --worker ${options.workerProfile} will be ignored`);
+		deps.notice(
+			"warn",
+			`--target ${options.target} takes precedence; --agent-profile ${options.workerProfile} will be ignored`,
+		);
 	}
 	if (options.target && options.workerRuntime) {
 		deps.notice(
@@ -364,6 +375,15 @@ export interface SlashCommandContext {
 	openContextView: () => void;
 	/** Open the read-only `/tasks` overlay: the session task board with receipts. */
 	openTasks: () => void;
+	/** Open the settled, branch-local interview decision board. */
+	openDecisions: () => void;
+	/** Project-scoped operator task inbox backing `/tasks` mutations. */
+	userTasks?: {
+		add(title: string): UserTask;
+		hand(id: string): UserTask;
+		done(id: string): UserTask;
+		drop(id: string): UserTask;
+	};
 	/** Open the read-only `/memory` overlay: approved lessons and the live task bank. */
 	openMemory: () => void;
 	/** Opt-in import from the newest structured handoff; absent when the host has no task bank. */
@@ -418,6 +438,12 @@ export interface SlashCommandContext {
 	render: () => void;
 }
 
+/** The one operator-authored turn used by slash and overlay handoff paths. */
+export function formatUserTaskHandoff(task: Pick<UserTask, "id" | "title" | "note">): string {
+	const note = task.note ? ` ${task.note}.` : "";
+	return `Operator task ${task.id}: ${task.title}.${note} Pick it up with tasks action="pick" id="${task.id}" and work it when appropriate.`;
+}
+
 /** The verb a command performs, in the order /help lists the groups. */
 export const SLASH_COMMAND_GROUPS = ["Run", "Inspect", "Configure", "Sessions"] as const;
 export type SlashCommandGroup = (typeof SLASH_COMMAND_GROUPS)[number];
@@ -426,13 +452,6 @@ export interface BuiltinSlashCommand {
 	name: string;
 	description: string;
 	group: SlashCommandGroup;
-	aliases?: ReadonlyArray<string>;
-	/**
-	 * Argument text an alias stands in for, prepended to whatever the operator
-	 * typed after it. `/compact` names a subcommand of `/context`, not the
-	 * command itself, so it cannot be spelled as a bare alias.
-	 */
-	aliasArgs?: Readonly<Record<string, string>>;
 	/** Excluded from /help, autocomplete, and the docs command table. */
 	hidden?: boolean;
 	args?: CommandArgsSpec;
@@ -505,7 +524,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "quit",
 		description: "Exit Clio Coder",
 		group: "Sessions",
-		aliases: ["exit"],
 		kinds: ["quit"],
 		args: {},
 		fromArgs: fromArgsOrUsage("quit", { kind: "quit" }),
@@ -532,7 +550,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "skill",
 		description: "Open the Skills Hub or invoke a skill",
 		group: "Run",
-		aliases: ["skill:", "skills:"],
 		kinds: ["skill-selector", "skill-invocation"],
 		args: {
 			positionals: [
@@ -541,7 +558,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			],
 		},
 		match(trimmed) {
-			if (trimmed === "/skill" || trimmed === "/skill:" || trimmed === "/skills:") {
+			if (trimmed === "/skill") {
 				return { kind: "skill-selector" };
 			}
 			const command = parseSkillCommand(trimmed);
@@ -687,8 +704,8 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		args: {
 			parseFlagsBeforeRest: true,
 			flags: [
-				{ name: "--agent-profile", aliases: ["--worker-profile", "--worker"], takesValue: true, valueName: "profile" },
-				{ name: "--runtime", aliases: ["--agent-runtime", "--worker-runtime"], takesValue: true, valueName: "runtimeId" },
+				{ name: "--agent-profile", takesValue: true, valueName: "profile" },
+				{ name: "--runtime", takesValue: true, valueName: "runtimeId" },
 				{ name: "--target", takesValue: true, valueName: "id" },
 				{ name: "--model", takesValue: true, valueName: "id" },
 				{ name: "--thinking", takesValue: true, values: RUN_THINKING_LEVELS, valueName: "level" },
@@ -844,8 +861,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "context",
 		description: "Context hub: window overlay plus compact, init, refresh, and reset",
 		group: "Inspect",
-		aliases: ["ctx", "compact"],
-		aliasArgs: { compact: "compact" },
 		kinds: ["context-view", "compact", "init", "context-clear", "context-refresh"],
 		subcommandDescriptions: {
 			compact: "Compact session context",
@@ -904,14 +919,92 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	},
 	settingsDeepLink("fleet", "fleet", "Open Settings → Fleet: defaults, profiles, agent bindings, nodes"),
 	{
-		name: "tasks",
-		description: "Show the session task board the agent tracks with the tasks tool",
+		name: "decisions",
+		description: "Show settled interview decisions and operator revisions",
 		group: "Inspect",
-		kinds: ["tasks"],
-		args: {},
-		fromArgs: fromArgsOrUsage("tasks", { kind: "tasks" }),
+		kinds: ["decisions"],
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "decisions", reason: parsed.error };
+			return { kind: "decisions" };
+		},
 		handle(_command, ctx) {
-			ctx.openTasks();
+			ctx.openDecisions();
+		},
+	},
+	{
+		name: "tasks",
+		description: "Show the session board or manage project operator tasks",
+		group: "Inspect",
+		kinds: ["tasks", "tasks-add", "tasks-hand", "tasks-done", "tasks-drop"],
+		subcommandDescriptions: {
+			add: "Log a project task without notifying the agent",
+			hand: "Hand an operator task to the agent",
+			done: "Mark an operator task done",
+			drop: "Drop an operator task",
+		},
+		args: {
+			subcommands: {
+				add: { positionals: [{ name: "text", required: true, rest: true }] },
+				hand: { positionals: [{ name: "id", required: true }] },
+				done: { positionals: [{ name: "id", required: true }] },
+				drop: { positionals: [{ name: "id", required: true }] },
+			},
+		},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "tasks", reason: parsed.error };
+			switch (parsed.subcommand) {
+				case "add":
+					return parsed.rest
+						? { kind: "tasks-add", text: parsed.rest }
+						: { kind: "usage-error", command: "tasks", reason: "add requires task text" };
+				case "hand":
+				case "done":
+				case "drop": {
+					const id = parsed.positionals[0];
+					if (!id || !/^u[1-9]\d*$/.test(id)) {
+						return { kind: "usage-error", command: "tasks", reason: `${parsed.subcommand} requires a uN id` };
+					}
+					if (parsed.subcommand === "hand") return { kind: "tasks-hand", id };
+					if (parsed.subcommand === "done") return { kind: "tasks-done", id };
+					return { kind: "tasks-drop", id };
+				}
+				default:
+					return { kind: "tasks" };
+			}
+		},
+		handle(command, ctx) {
+			if (command.kind === "tasks") {
+				ctx.openTasks();
+				return;
+			}
+			if (!ctx.userTasks) {
+				ctx.notice("error", "operator task inbox is not wired in this session");
+				return;
+			}
+			try {
+				if (command.kind === "tasks-add") {
+					const task = ctx.userTasks.add(command.text);
+					ctx.notice("success", `logged operator task ${task.id}: ${task.title}`);
+					return;
+				}
+				if (command.kind === "tasks-hand") {
+					const task = ctx.userTasks.hand(command.id);
+					ctx.submitChat(formatUserTaskHandoff(task));
+					return;
+				}
+				if (command.kind === "tasks-done") {
+					const task = ctx.userTasks.done(command.id);
+					ctx.notice("success", `marked operator task ${task.id} done`);
+					return;
+				}
+				if (command.kind === "tasks-drop") {
+					const task = ctx.userTasks.drop(command.id);
+					ctx.notice("success", `dropped operator task ${task.id}`);
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.notice("error", message);
+			}
 		},
 	},
 	{
@@ -1044,7 +1137,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "model",
 		description: "Open model selector or set a model",
 		group: "Configure",
-		aliases: ["models"],
 		kinds: ["model", "model-set"],
 		args: {
 			positionals: [{ name: "pattern", required: false, rest: true }],
@@ -1093,7 +1185,6 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "settings",
 		description: "Open interactive settings",
 		group: "Configure",
-		aliases: ["config"],
 		kinds: ["settings"],
 		args: { positionals: [{ name: "section", required: false }] },
 		fromArgs(parsed) {
@@ -1156,13 +1247,14 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	},
 	{
 		name: "export",
-		description: "Export the session transcript to Markdown",
+		description: "Export a self-contained HTML transcript by default; a .md path writes Markdown",
 		group: "Sessions",
 		kinds: ["export"],
 		args: {
 			positionals: [{ name: "path", required: false }],
 		},
 		fromArgs(parsed) {
+			if (parsed.error) return { kind: "usage-error", command: "export", reason: parsed.error };
 			return { kind: "export", path: parsed.positionals[0] };
 		},
 		handle(command, ctx) {
@@ -1173,15 +1265,12 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 ];
 
 const HANDLER_BY_KIND = new Map<SlashCommandKind, BuiltinSlashCommand>();
-const COMMAND_TERM_OWNER = new Map<string, string>();
+const COMMAND_NAMES = new Set<string>();
 for (const entry of BUILTIN_SLASH_COMMANDS) {
-	for (const term of [entry.name, ...(entry.aliases ?? [])]) {
-		const owner = COMMAND_TERM_OWNER.get(term);
-		if (owner) {
-			throw new Error(`BUILTIN_SLASH_COMMANDS: command term "${term}" is owned by both "${owner}" and "${entry.name}"`);
-		}
-		COMMAND_TERM_OWNER.set(term, entry.name);
+	if (COMMAND_NAMES.has(entry.name)) {
+		throw new Error(`BUILTIN_SLASH_COMMANDS: command name "${entry.name}" is registered more than once`);
 	}
+	COMMAND_NAMES.add(entry.name);
 	for (const kind of entry.kinds) {
 		if (HANDLER_BY_KIND.has(kind)) {
 			throw new Error(`BUILTIN_SLASH_COMMANDS: kind "${kind}" is owned by multiple entries`);
@@ -1192,7 +1281,9 @@ for (const entry of BUILTIN_SLASH_COMMANDS) {
 
 /**
  * A token that could only have been meant as a command: one word of letters,
- * digits, and hyphens after the leading slash.
+ * digits, hyphens, or colons after the leading slash. Colons are included so
+ * retired compact forms such as `/skill:name` fail closed instead of becoming
+ * model input.
  *
  * A spelling that names no command used to match nothing and fall through to
  * the model as prose. Measured: `/compact` was answered "/compact (completed)"
@@ -1207,12 +1298,12 @@ for (const entry of BUILTIN_SLASH_COMMANDS) {
  * `/not/a/command` carry a separator, so they are not one word and still reach
  * the model unchanged.
  *
- * One word followed by prose stays ambiguous: `/compact tidy up` is the defect
+ * One word followed by prose stays ambiguous: `/status please` is the defect
  * and `/tmp is full` is a sentence, and nothing in the text separates them. It
  * resolves as a command, so a sentence that has to open this way needs
  * COMMAND_ESCAPE.
  */
-const COMMAND_SHAPED_TOKEN = /^[A-Za-z][A-Za-z0-9-]*$/u;
+const COMMAND_SHAPED_TOKEN = /^[A-Za-z][A-Za-z0-9:-]*$/u;
 
 /**
  * Prefix that sends a command-shaped line to the model as text.
@@ -1248,13 +1339,14 @@ export function parseSlashCommand(input: string): SlashCommand {
 /**
  * Dispatches a parsed SlashCommand to its owning registry entry. `empty` is a
  * no-op and `unknown` falls through to chat submission; every other kind
- * resolves to exactly one registry entry at module load.
+ * resolves to exactly one registry entry at module load. The result tells the
+ * editor whether dispatch accepted the line or left it as a correctable draft.
  */
-export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandContext): void {
-	if (command.kind === "empty") return;
+export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandContext): SlashCommandDispatchResult {
+	if (command.kind === "empty") return "rejected";
 	if (command.kind === "unknown") {
 		ctx.submitChat(command.text);
-		return;
+		return "accepted";
 	}
 	if (command.kind === "unknown-command") {
 		// The registry does not own the token, but a prompt template might. The
@@ -1265,32 +1357,30 @@ export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandCon
 		const expansion = ctx.expandPromptTemplate?.(command.text);
 		if (expansion?.expanded === true) {
 			ctx.submitChat(command.text);
-			return;
+			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;
 		ctx.notice("error", refusal ? refusal.message : `/${command.token} is not a command. Type /help for the list.`);
 		ctx.render();
-		return;
+		return "rejected";
 	}
 	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}`);
 		ctx.render();
-		return;
+		return "rejected";
 	}
 	const entry = HANDLER_BY_KIND.get(command.kind);
-	if (!entry) return;
+	if (!entry) return "rejected";
 	entry.handle(command, ctx);
+	return "accepted";
 }
 
 export interface CommandReferenceEntry {
 	name: string;
-	aliases: ReadonlyArray<string>;
-	/** Argument text each alias in `aliases` stands in for, when it stands for any. */
-	aliasArgs?: Readonly<Record<string, string>>;
 	usage: string;
 	description: string;
 	group: SlashCommandGroup;
@@ -1307,8 +1397,6 @@ export function commandReference(): ReadonlyArray<CommandReferenceEntry> {
 			.replace(/\n$/, "");
 		return {
 			name: entry.name,
-			aliases: entry.aliases ?? [],
-			...(entry.aliasArgs ? { aliasArgs: entry.aliasArgs } : {}),
 			usage,
 			description: entry.description,
 			group: entry.group,