march-cli 0.1.33 → 0.1.35

package/src/cli/commands/registry/slash-command-registry.mjs

@@ -0,0 +1,293 @@
+import { listExtensionPathsCommand } from "../extensions-command.mjs";
+import { handleExportCommand, parseExportCommand } from "../export-command.mjs";
+import { handleModelCommand, parseModelCommand } from "../model-command.mjs";
+import { formatHotkeysPanel } from "../../repl-commands.mjs";
+import { copyLastAssistantMessage } from "../copy-command.mjs";
+import { handleSessionSourceCommand } from "../../session/session-source-command.mjs";
+import { statusCommand } from "../status-command.mjs";
+import { handleThinkingCommand, parseThinkingCommand } from "../thinking-command.mjs";
+import { formatPromptTemplateLines } from "../../input/prompt-templates.mjs";
+import { handleSettingsCommand, parseSettingsCommand } from "../../../config/settings-command.mjs";
+import { handleSessionNameCommand, parseSessionNameCommand } from "../../session/session-name-command.mjs";
+import { handleShellCommand, parseShellCommand } from "../../shell/shell-command.mjs";
+import { handleProviderCommand, parseProviderCommand } from "../provider-command.mjs";
+import { handleModeCommand, parseModeCommand } from "../mode-command.mjs";
+
+export const SLASH_COMMANDS = [
+  exactCommand({
+    name: "exit",
+    aliases: ["quit"],
+    description: "Exit March",
+    run: async (ctx) => {
+      await handleSessionSourceCommand("/save", ctx);
+      return { handled: true, exit: true };
+    },
+  }),
+  exactCommand({
+    name: "new",
+    description: "Start a new pi session",
+    run: handleNewCommand,
+  }),
+  exactCommand({
+    name: "help",
+    description: "Show available commands",
+    run: async ({ ui }) => writeLines(ui, formatHelpLines()),
+  }),
+  exactCommand({
+    name: "reload",
+    aliases: ["reload-runtime"],
+    description: "Restart the March runtime",
+    run: handleReloadCommand,
+  }),
+  parsedCommand({
+    names: ["do", "discuss", "mode"],
+    metadata: [
+      { name: "do", description: "Switch to Do mode" },
+      { name: "discuss", description: "Switch to Discuss mode" },
+      { name: "mode", description: "Show current mode" },
+    ],
+    parse: parseModeCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, handleModeCommand(command, { modeState: ctx.modeState })),
+  }),
+  exactCommand({
+    name: "hotkeys",
+    description: "Show keyboard shortcuts and input prefixes",
+    run: async ({ ui, keybindings, keybindingDiagnostics }) => writeLines(ui, formatHotkeysPanel(keybindings, keybindingDiagnostics)),
+  }),
+  exactCommand({
+    name: "templates",
+    description: "List project prompt templates",
+    run: async ({ ui, promptTemplates, promptTemplateDiagnostics }) => writeLines(ui, formatPromptTemplateLines(promptTemplates, promptTemplateDiagnostics)),
+  }),
+  parsedCommand({
+    names: ["export"],
+    metadata: [
+      { name: "export jsonl", description: "Export current session turns as JSONL" },
+      { name: "export html", description: "Export current session turns as HTML" },
+      { name: "export gist jsonl", helpSyntax: "export gist <jsonl|html>", description: "Share current session JSONL as a private GitHub Gist" },
+      { name: "export gist html", help: false, description: "Share current session HTML as a private GitHub Gist" },
+    ],
+    parse: parseExportCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, await handleExportCommand(command, ctx)),
+  }),
+  parsedCommand({
+    names: ["settings"],
+    metadata: [{ name: "settings", description: "Show or edit global/project settings" }],
+    parse: parseSettingsCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, handleSettingsCommand(command, { cwd: ctx.runner.engine.cwd, homeDir: ctx.settingsHomeDir })),
+  }),
+  exactCommand({
+    name: "extensions",
+    description: "List extension paths",
+    run: async ({ ui, runner, extensionPaths }) => writeLines(ui, listExtensionPathsCommand(
+      extensionPaths,
+      runner.getExtensionDiagnostics?.(),
+      runner.getExtensionLifecycleState?.(),
+    )),
+  }),
+  parsedCommand({
+    names: ["thinking"],
+    metadata: [
+      { name: "thinking", description: "Open thinking selector" },
+      { name: "thinking list", description: "List available thinking levels" },
+    ],
+    parse: parseThinkingCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, await handleThinkingCommand(command, { runner: ctx.runner, ui: ctx.ui })),
+  }),
+  exactCommand({
+    name: "status",
+    description: "Show runtime status",
+    run: async ({ ui, runner, sessionState, sessionSource }) => writeLines(ui, statusCommand({
+      runner,
+      sessionState,
+      sessionSource,
+      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
+      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
+    })),
+  }),
+  exactCommand({
+    name: "notify",
+    visible: false,
+    help: false,
+    autocomplete: false,
+    description: "Test desktop notifications",
+    run: async ({ ui, runner }) => writeLines(ui, [formatNotificationResult(await runner.notifyTest?.())]),
+  }),
+  parsedCommand({
+    names: ["shell"],
+    metadata: [
+      { name: "shell", description: "List shells or inspect shell output" },
+      { name: "shell spawn", helpSyntax: "shell spawn [name]", description: "Start a default PTY shell" },
+    ],
+    parse: parseShellCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, handleShellCommand(command, { shellRuntime: ctx.runner.shellRuntime })),
+  }),
+  parsedCommand({
+    names: ["name"],
+    metadata: [{ name: "name", description: "Show or set session name" }],
+    parse: parseSessionNameCommand,
+    run: async (ctx, command) => writeLines(ctx.ui, handleSessionNameCommand(command, ctx)),
+  }),
+  exactCommand({
+    name: "copy",
+    description: "Copy last assistant response to clipboard",
+    run: async ({ ui, runner, writeClipboard }) => writeLines(ui, copyLastAssistantMessage({ engine: runner.engine, writeClipboard })),
+  }),
+  exactCommand({
+    name: "mouse",
+    visible: false,
+    help: false,
+    autocomplete: false,
+    description: "Show mouse selection status",
+    run: async ({ ui }) => writeLines(ui, ["Mouse selection is always enabled."]),
+  }),
+  sessionSourceCommand(),
+  parsedCommand({
+    names: ["providers"],
+    metadata: [{ name: "providers", description: "List configured providers" }],
+    parse: parseProviderCommand,
+    run: async (ctx, command) => {
+      try {
+        writeLines(ctx.ui, [await handleProviderCommand(command, { ui: ctx.ui, runner: ctx.runner })]);
+      } catch (err) {
+        writeLines(ctx.ui, [`Error: ${err.message}`]);
+      }
+      return { handled: true };
+    },
+  }),
+  parsedCommand({
+    names: ["model"],
+    metadata: [{ name: "model", description: "Open model selector" }],
+    parse: parseModelCommand,
+    run: async (ctx, command) => {
+      try {
+        writeLines(ctx.ui, [await handleModelCommand(command, { runner: ctx.runner, ui: ctx.ui, configHomeDir: ctx.configHomeDir })]);
+      } catch (err) {
+        writeLines(ctx.ui, [`Error: ${err.message}`]);
+      }
+      return { handled: true };
+    },
+  }),
+];
+
+export async function runSlashCommand(trimmed, context) {
+  for (const command of SLASH_COMMANDS) {
+    const match = command.match(trimmed);
+    if (!match) continue;
+    return await command.run(context, match.parsed);
+  }
+  return { handled: false };
+}
+
+export function getVisibleCommandEntries() {
+  return SLASH_COMMANDS.flatMap((command) => command.metadata ?? [])
+    .filter((command) => command.visible !== false)
+    .map((command) => ({ ...command }));
+}
+
+export function getAutocompleteCommands() {
+  return getVisibleCommandEntries()
+    .filter((command) => command.autocomplete !== false)
+    .flatMap((command) => [command.name, ...(command.aliases ?? [])]
+      .map((name) => ({ name, description: command.description })));
+}
+
+export function getHelpCommandSyntaxes() {
+  return getVisibleCommandEntries()
+    .filter((command) => command.help !== false)
+    .map((command) => `/${command.helpSyntax ?? command.name}`);
+}
+
+function exactCommand({ name, aliases = [], description, visible = true, help = true, autocomplete = true, run }) {
+  const names = [name, ...aliases];
+  return {
+    metadata: [{ name, aliases, description, visible, help, autocomplete }],
+    match: (trimmed) => names.some((candidate) => trimmed === `/${candidate}`) ? { parsed: { type: name } } : null,
+    run,
+  };
+}
+
+function parsedCommand({ names, metadata, parse, run }) {
+  return {
+    metadata,
+    match: (trimmed) => {
+      if (!names.some((name) => trimmed === `/${name}` || trimmed.startsWith(`/${name} `))) return null;
+      const parsed = parse(trimmed);
+      return parsed?.type === "none" ? null : { parsed };
+    },
+    run,
+  };
+}
+
+function sessionSourceCommand() {
+  return {
+    metadata: [
+      { name: "session", description: "Open previous session selector" },
+      { name: "save", description: "Show auto-save status" },
+    ],
+    match: (trimmed) => (trimmed === "/session" || trimmed === "/save") ? { parsed: { trimmed } } : null,
+    run: async (ctx, { trimmed }) => handleSessionSourceCommand(trimmed, ctx),
+  };
+}
+
+async function handleNewCommand({ ui, runner, renderStartupBanner }) {
+  if (!runner.canSwitchPiSession?.()) {
+    ui.writeln("Error: pi runtime host is not enabled");
+    return { handled: true };
+  }
+  let refreshContextTokens = false;
+  try {
+    const result = await runner.startNewSession();
+    if (result?.cancelled) {
+      ui.writeln("New session cancelled");
+    } else {
+      refreshContextTokens = true;
+      ui.clearOutput?.();
+      const bannerLines = typeof renderStartupBanner === "function" ? renderStartupBanner() : [];
+      if (bannerLines.length > 0) {
+        writeLines(ui, bannerLines);
+      } else {
+        ui.writeln(`Started new session: ${result.sessionId}`);
+      }
+    }
+  } catch (err) {
+    ui.writeln(`Error: ${err.message}`);
+  }
+  return { handled: true, refreshContextTokens };
+}
+
+async function handleReloadCommand({ ui, runner }) {
+  if (typeof runner.restartRuntime !== "function") {
+    ui.writeln("Runtime reload is unavailable in in-process mode. Restart March to load code changes.");
+    return { handled: true };
+  }
+  try {
+    await runner.restartRuntime();
+    ui.writeln("● March runtime 已重启，下一轮将使用磁盘上的最新代码");
+    return { handled: true, refreshContextTokens: true };
+  } catch (err) {
+    ui.writeln(`Error: ${err.message}`);
+    return { handled: true };
+  }
+}
+
+function writeLines(ui, lines) {
+  for (const line of lines) ui.writeln(line);
+  return { handled: true };
+}
+
+export function formatHelpLines() {
+  return [
+    `Commands: ${getHelpCommandSyntaxes().join(", ")}`,
+    "Sessions: /session opens previous sessions and restores the selected one.",
+    "Shortcuts: Tab = toggle Do/Discuss, Esc = abort turn, Ctrl+C = abort turn / press twice to exit when idle, Ctrl+O = toggle tool output, Alt+S = shell pane, Alt+N = next shell, Alt+K/J = shell scroll, PageUp/PageDown = output scroll, Ctrl+G = external editor, Shift+Tab = thinking selector, Ctrl+T = thinking selector, Ctrl+L = model selector",
+  ];
+}
+
+function formatNotificationResult(result) {
+  if (!result) return "notification: unavailable";
+  const channels = (result.results ?? [])
+    .map((entry) => `${entry.channel}:${entry.ok ? "ok" : entry.reason ?? "failed"}`)
+    .join(", ");
+  return `notification: ${result.ok ? "ok" : result.reason ?? "failed"}${channels ? ` (${channels})` : ""}`;
+}

package/src/cli/input/autocomplete.mjs

@@ -1,30 +1,7 @@
 import { CombinedAutocompleteProvider } from "@earendil-works/pi-tui";
+import { getAutocompleteCommands } from "../commands/catalog/visible-commands.mjs";
 import { FileSearchIndex } from "./file-search/index.mjs";
 
-const MARCH_COMMANDS = [
-  { name: "new", description: "Start a new pi session" },
-  { name: "exit", description: "Exit March" },
-  { name: "quit", description: "Exit March" },
-  { name: "help", description: "Show available commands" },
-  { name: "model", description: "Open model selector" },
-  { name: "models", description: "List available models" },
-  { name: "session", description: "Open previous session selector" },
-  { name: "save", description: "Show auto-save status" },
-  { name: "name", description: "Show or set session name" },
-  { name: "copy", description: "Copy last assistant response to clipboard" },
-  { name: "thinking", description: "Open thinking selector" },
-  { name: "thinking list", description: "List available thinking levels" },
-  { name: "hotkeys", description: "Show keyboard shortcuts and input prefixes" },
-  { name: "templates", description: "List project prompt templates" },
-  { name: "export jsonl", description: "Export current session turns as JSONL" },
-  { name: "export html", description: "Export current session turns as HTML" },
-  { name: "export gist html", description: "Share current session HTML as a private GitHub Gist" },
-  { name: "export gist jsonl", description: "Share current session JSONL as a private GitHub Gist" },
-  { name: "settings", description: "Show or edit global/project settings" },
-  { name: "shell", description: "List shells or inspect shell output" },
-  { name: "shell spawn", description: "Start a default PTY shell" },
-];
-
 export function buildMarchCommands(promptTemplates = []) {
   const templateCommands = promptTemplates
     .map((template) => ({
@@ -32,7 +9,7 @@ export function buildMarchCommands(promptTemplates = []) {
       description: "Expand prompt template",
     }))
     .filter((command) => command.name && !command.name.startsWith("/"));
-  return [...MARCH_COMMANDS, ...templateCommands];
+  return [...getAutocompleteCommands(), ...templateCommands];
 }
 
 export class MarchAutocompleteProvider {

package/src/cli/repl-loop.mjs

@@ -1,11 +1,9 @@
-import { brightBlack, inverse } from "./tui/ui-theme.mjs";
+import { brightBlack } from "./tui/ui-theme.mjs";
 import { handleSlashCommand } from "./slash-commands.mjs";
-import { appendModeReminder } from "./input/mode-state.mjs";
 import { expandPromptTemplate } from "./input/prompt-templates.mjs";
 import { parseInlineShellInput, runInlineShellCommand } from "./repl-commands.mjs";
-import { formatRecallHints } from "../memory/markdown-store.mjs";
-import { formatMessageAttachmentsForDisplay } from "../session/attachment-display.mjs";
-import { formatShellHints } from "../shell/hints.mjs";
+import { prepareTurnInput } from "./turn/turn-input-preparer.mjs";
+export { formatUserDisplayMessage } from "./turn/turn-input-preparer.mjs";
 
 export async function runSingleShotPrompt({
   prompt,
@@ -13,26 +11,18 @@ export async function runSingleShotPrompt({
   memoryStore,
   currentProject,
   ui,
-  sessionState,
   refreshStatusBar,
   modeState = null,
 }) {
-  memoryStore.beginTurn();
-  const carryoverAlreadyRendered = runner.engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
-  const carryoverRecallHints = runner.engine.takePendingAssistantRecallHints?.() ?? [];
-  const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
-  const recallBlock = formatRecallHints("user", userRecallHints);
-  const carryoverRecallBlock = formatRecallHints("assistant", carryoverRecallHints);
-  const shellHints = formatShellHints(runner.shellRuntime);
-  const modePrompt = appendModeReminder(prompt, modeState?.get?.());
-  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
-  ui.writeln(formatUserDisplayMessage(prompt));
-  ui.recall?.({ source: "user", hints: userRecallHints });
-  if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.recall?.({ source: "assistant", hints: carryoverRecallHints });
+  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+  ui.writeln(turnInput.displayMessage);
+  ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
+  if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
   refreshStatusBar.startWorking?.();
   try {
-    await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+    const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
+    await handleTurnLifecycleAction(result?.lifecycleAction, { runner, ui });
   } finally {
     refreshStatusBar.stopWorking?.();
     memoryStore.endTurn();
@@ -42,7 +32,6 @@ export async function runSingleShotPrompt({
 
 export async function runInteractiveRepl({
   cwd,
-  args,
   ui,
   runner,
   memoryStore,
@@ -105,7 +94,6 @@ export async function runInteractiveRepl({
 
     await runReplTurn({
       prompt: trimmed,
-      args,
       runner,
       memoryStore,
       currentProject,
@@ -138,24 +126,17 @@ function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
   return { type: "none" };
 }
 
-async function runReplTurn({ prompt, args, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
-  memoryStore.beginTurn();
-  const carryoverAlreadyRendered = runner.engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
-  const carryoverRecallHints = runner.engine.takePendingAssistantRecallHints?.() ?? [];
-  const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
-  const recallBlock = formatRecallHints("user", userRecallHints);
-  const carryoverRecallBlock = formatRecallHints("assistant", carryoverRecallHints);
-  const shellHints = formatShellHints(runner.shellRuntime);
-  const modePrompt = appendModeReminder(prompt, modeState?.get?.());
-  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
+async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
+  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
   try {
-    ui.writeln(formatUserDisplayMessage(prompt));
-    ui.recall?.({ source: "user", hints: userRecallHints });
-    if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.recall?.({ source: "assistant", hints: carryoverRecallHints });
+    ui.writeln(turnInput.displayMessage);
+    ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
     setTurnRunning(true);
     refreshStatusBar.startWorking?.();
-    await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+    const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
+    await handleTurnLifecycleAction(result?.lifecycleAction, { runner, ui });
     ui.writeln("");
   } catch (err) {
     ui.writeln(`Error: ${err.message}`);
@@ -167,12 +148,14 @@ async function runReplTurn({ prompt, args, runner, memoryStore, currentProject,
   }
 }
 
-export function formatUserDisplayMessage(prompt) {
-  return `${inverse(" USER ")} ${formatMessageAttachmentsForDisplay(prompt)}`;
-}
-
-function appendPromptBlocks(prompt, ...blocks) {
-  return [prompt, ...blocks.filter(Boolean)].join("\n\n");
+async function handleTurnLifecycleAction(action, { runner, ui }) {
+  if (action?.type !== "restart_runtime") return;
+  if (typeof runner.restartRuntime !== "function") {
+    ui.writeln("March runtime restart requested, but runtime reload is unavailable in in-process mode. Restart March to load code changes.");
+    return;
+  }
+  await runner.restartRuntime();
+  ui.writeln("● March runtime 已重启，下一轮将使用磁盘上的最新代码");
 }
 
 function renderPendingAssistantRecallPreview({ runner, ui }) {

package/src/cli/slash-commands.mjs

@@ -1,25 +1,10 @@
-import { listExtensionPathsCommand } from "./commands/extensions-command.mjs";
-import { handleExportCommand, parseExportCommand } from "./commands/export-command.mjs";
-import { handleModelCommand, listModels, parseModelCommand } from "./commands/model-command.mjs";
-import { formatHotkeysPanel } from "./repl-commands.mjs";
-import { copyLastAssistantMessage } from "./commands/copy-command.mjs";
-import { handleSessionSourceCommand } from "./session/session-source-command.mjs";
-import { statusCommand } from "./commands/status-command.mjs";
-import { handleThinkingCommand, parseThinkingCommand } from "./commands/thinking-command.mjs";
-import { formatPromptTemplateLines } from "./input/prompt-templates.mjs";
-import { handleSettingsCommand, parseSettingsCommand } from "../config/settings-command.mjs";
-import { handleSessionNameCommand, parseSessionNameCommand } from "./session/session-name-command.mjs";
-import { handleShellCommand, parseShellCommand } from "./shell/shell-command.mjs";
-import { handleProviderCommand, parseProviderCommand } from "./commands/provider-command.mjs";
-import { handleModeCommand, parseModeCommand } from "./commands/mode-command.mjs";
-import { formatHelpLines } from "./commands/help-command.mjs";
+import { runSlashCommand } from "./commands/registry/slash-command-registry.mjs";
 
-export async function handleSlashCommand(trimmed, {
-  ui,
-  runner,
-  sessionState,
-  sessionsRoot,
-  projectMarchDir,
+export async function handleSlashCommand(trimmed, options) {
+  return runSlashCommand(trimmed, normalizeSlashCommandOptions(options));
+}
+
+function normalizeSlashCommandOptions({
   sessionSource = "pi",
   extensionPaths = [],
   keybindings,
@@ -30,170 +15,19 @@ export async function handleSlashCommand(trimmed, {
   renderStartupBanner = null,
   settingsHomeDir,
   configHomeDir = settingsHomeDir,
-  writeClipboard,
+  ...rest
 }) {
-  if (trimmed === "/exit" || trimmed === "/quit") {
-    await handleSessionSourceCommand("/save", { ui, runner, sessionState, sessionSource });
-    return { handled: true, exit: true };
-  }
-
-  if (trimmed === "/new") {
-    if (!runner.canSwitchPiSession?.()) {
-      ui.writeln("Error: pi runtime host is not enabled");
-      return { handled: true };
-    }
-    let refreshContextTokens = false;
-    try {
-      const result = await runner.startNewSession();
-      if (result?.cancelled) {
-        ui.writeln("New session cancelled");
-      } else {
-        refreshContextTokens = true;
-        ui.clearOutput?.();
-        const bannerLines = typeof renderStartupBanner === "function" ? renderStartupBanner() : [];
-        if (bannerLines.length > 0) {
-          for (const line of bannerLines) ui.writeln(line);
-        } else {
-          ui.writeln(`Started new session: ${result.sessionId}`);
-        }
-      }
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true, refreshContextTokens };
-  }
-
-  if (trimmed === "/help") {
-    for (const line of formatHelpLines()) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const modeCommand = parseModeCommand(trimmed);
-  if (modeCommand.type !== "none") {
-    for (const line of handleModeCommand(modeCommand, { modeState })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/hotkeys") {
-    for (const line of formatHotkeysPanel(keybindings, keybindingDiagnostics)) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/templates") {
-    for (const line of formatPromptTemplateLines(promptTemplates, promptTemplateDiagnostics)) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const exportCommand = parseExportCommand(trimmed);
-  if (exportCommand.type !== "none") {
-    for (const line of await handleExportCommand(exportCommand, { runner, sessionState, sessionSource, projectMarchDir })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const settingsCommand = parseSettingsCommand(trimmed);
-  if (settingsCommand.type !== "none") {
-    for (const line of handleSettingsCommand(settingsCommand, { cwd: runner.engine.cwd, homeDir: settingsHomeDir })) {
-      ui.writeln(line);
-    }
-    return { handled: true };
-  }
-
-  if (trimmed === "/extensions") {
-    for (const line of listExtensionPathsCommand(
-      extensionPaths,
-      runner.getExtensionDiagnostics?.(),
-      runner.getExtensionLifecycleState?.(),
-    )) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const thinkingCommand = parseThinkingCommand(trimmed);
-  if (thinkingCommand.type !== "none") {
-    for (const line of await handleThinkingCommand(thinkingCommand, { runner, ui })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/status") {
-    for (const line of statusCommand({
-      runner,
-      sessionState,
-      sessionSource,
-      extensionDiagnostics: runner.getExtensionDiagnostics?.() ?? [],
-      lifecycleState: runner.getExtensionLifecycleState?.() ?? null,
-    })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/notify") {
-    const result = await runner.notifyTest?.();
-    ui.writeln(formatNotificationResult(result));
-    return { handled: true };
-  }
-
-  const shellCommand = parseShellCommand(trimmed);
-  if (shellCommand.type !== "none") {
-    for (const line of handleShellCommand(shellCommand, { shellRuntime: runner.shellRuntime })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  const nameCommand = parseSessionNameCommand(trimmed);
-  if (nameCommand.type !== "none") {
-    for (const line of handleSessionNameCommand(nameCommand, { runner, sessionState, sessionSource })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/copy") {
-    for (const line of copyLastAssistantMessage({ engine: runner.engine, writeClipboard })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  if (trimmed === "/mouse") {
-    ui.writeln("Mouse selection is always enabled.");
-    return { handled: true };
-  }
-
-  const sessionSourceCommand = await handleSessionSourceCommand(trimmed, {
-    ui,
-    runner,
-    sessionState,
-    sessionsRoot,
-    projectMarchDir,
+  return {
+    ...rest,
     sessionSource,
-  });
-  if (sessionSourceCommand.handled) return sessionSourceCommand;
-
-  const providerCommand = parseProviderCommand(trimmed);
-  if (providerCommand.type !== "none") {
-    try {
-      ui.writeln(await handleProviderCommand(providerCommand, { ui, runner }));
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true };
-  }
-
-  const modelCommand = parseModelCommand(trimmed);
-  if (modelCommand.type !== "none") {
-    try {
-      ui.writeln(await handleModelCommand(modelCommand, { runner, ui, configHomeDir }));
-    } catch (err) {
-      ui.writeln(`Error: ${err.message}`);
-    }
-    return { handled: true };
-  }
-
-  if (trimmed === "/models") {
-    for (const line of listModels({ runner })) ui.writeln(line);
-    return { handled: true };
-  }
-
-  return { handled: false };
-}
-
-function formatNotificationResult(result) {
-  if (!result) return "notification: unavailable";
-  const channels = (result.results ?? [])
-    .map((entry) => `${entry.channel}:${entry.ok ? "ok" : entry.reason ?? "failed"}`)
-    .join(", ");
-  return `notification: ${result.ok ? "ok" : result.reason ?? "failed"}${channels ? ` (${channels})` : ""}`;
+    extensionPaths,
+    keybindings,
+    keybindingDiagnostics,
+    promptTemplates,
+    promptTemplateDiagnostics,
+    modeState,
+    renderStartupBanner,
+    settingsHomeDir,
+    configHomeDir,
+  };
 }