march-cli 0.1.0

package/src/cli/permissions.mjs

@@ -0,0 +1,103 @@
+// ── Permission categories ──────────────────────────────────────────────
+export const PERM = Object.freeze({
+  READ_ONLY: "read_only",
+  FILE_WRITE: "file_write",
+  COMMAND_EXEC: "command_exec",
+  NETWORK_EXTERNAL: "network_external",
+});
+
+const CATEGORY_LABEL = {
+  [PERM.READ_ONLY]: "read-only",
+  [PERM.FILE_WRITE]: "file write",
+  [PERM.COMMAND_EXEC]: "command exec",
+  [PERM.NETWORK_EXTERNAL]: "network",
+};
+
+export function permissionLabel(cat) {
+  return CATEGORY_LABEL[cat] ?? cat;
+}
+
+// ── Permitted modes ────────────────────────────────────────────────────
+export const MODE = Object.freeze({
+  DEFAULT: "default",
+  DONT_ASK: "dontAsk",
+  BYPASS: "bypassPermissions",
+  ACCEPT_EDITS: "acceptEdits",
+});
+
+// ── Default tool → category mapping ────────────────────────────────────
+const DEFAULT_CATEGORIES = {
+  context_stats: PERM.READ_ONLY,
+  find: PERM.READ_ONLY,
+  edit_file: PERM.FILE_WRITE,
+  command_exec: PERM.COMMAND_EXEC,
+  terminal_spawn: PERM.COMMAND_EXEC,
+  terminal_send: PERM.COMMAND_EXEC,
+  terminal_list: PERM.COMMAND_EXEC,
+  terminal_kill: PERM.COMMAND_EXEC,
+  terminal_resize: PERM.COMMAND_EXEC,
+  terminal_clear: PERM.COMMAND_EXEC,
+  terminal_search: PERM.COMMAND_EXEC,
+  terminal_read: PERM.COMMAND_EXEC,
+  terminal_snapshot: PERM.COMMAND_EXEC,
+  web_search: PERM.NETWORK_EXTERNAL,
+  web_fetch: PERM.NETWORK_EXTERNAL,
+};
+
+export function createPermissionController({
+  mode = MODE.DEFAULT,
+  toolCategories = {},
+  onRequestApproval = null,
+} = {}) {
+  const sessionApprovals = new Map();
+  const categories = { ...DEFAULT_CATEGORIES, ...toolCategories };
+
+  function getCategory(toolName) {
+    if (categories[toolName] !== undefined) return categories[toolName];
+    // MCP and unknown tools: default to most restrictive
+    if (toolName.startsWith("mcp__")) return PERM.NETWORK_EXTERNAL;
+    return PERM.COMMAND_EXEC;
+  }
+
+  function setCategory(toolName, category) {
+    categories[toolName] = category;
+  }
+
+  function check(toolName) {
+    const category = getCategory(toolName);
+
+    if (category === PERM.READ_ONLY) return { behavior: "allow" };
+    if (mode === MODE.BYPASS) return { behavior: "allow" };
+    if (mode === MODE.DONT_ASK) {
+      return { behavior: "deny", message: `Tool '${toolName}' requires ${permissionLabel(category)} permission, but permission mode is 'dontAsk'.` };
+    }
+    if (sessionApprovals.has(toolName)) return { behavior: "allow" };
+
+    return { behavior: "ask", category, toolName };
+  }
+
+  function approve(toolName) {
+    sessionApprovals.set(toolName, true);
+  }
+
+  function isApproved(toolName) {
+    return sessionApprovals.has(toolName);
+  }
+
+  async function requestApproval(toolName, params, requestFn) {
+    const decision = check(toolName);
+    if (decision.behavior !== "ask") return decision;
+    if (!requestFn) return decision;
+    const ok = await requestFn({ toolName, params, category: decision.category });
+    if (ok) {
+      approve(toolName);
+      return { behavior: "allow" };
+    }
+    return {
+      behavior: "deny",
+      message: `User denied ${toolName} (requires ${permissionLabel(decision.category)} permission).`,
+    };
+  }
+
+  return { check, approve, isApproved, getCategory, setCategory, requestApproval, get mode() { return mode; } };
+}

package/src/cli/repl-commands.mjs

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+import { DEFAULT_KEYBINDINGS, KEYBINDING_ACTIONS } from "./input/keybindings.mjs";
+import { dim, red } from "./tui/ui-theme.mjs";
+
+const HOTKEY_GROUPS = Object.freeze([
+  ["Turn control", ["abort", "interrupt"]],
+  ["Model and thinking", ["cycleThinking", "thinkingSelector", "modelSelector"]],
+  ["Editor and output", ["externalEditor", "toggleToolOutput", "pasteImage"]],
+  ["Shell pane", ["toggleShellDrawer", "nextShell", "shellScrollUp", "shellScrollDown"]],
+  ["Output scroll", ["outputScrollUp", "outputScrollDown"]],
+]);
+
+export function parseInlineShellInput(input, lastCommand = "") {
+  if (input === "!!") {
+    if (!lastCommand) return { type: "error", message: "No previous inline shell command." };
+    return { type: "command", command: lastCommand, repeated: true };
+  }
+  if (!input.startsWith("!")) return { type: "none" };
+  const command = input.slice(1).trim();
+  if (!command) return { type: "error", message: "Usage: ! <command>" };
+  return { type: "command", command, repeated: false };
+}
+
+export function runInlineShellCommand(command, { cwd = process.cwd(), ui } = {}) {
+  const shell = process.platform === "win32"
+    ? { bin: "powershell.exe", args: ["-NoProfile", "-Command", command] }
+    : { bin: "bash", args: ["-lc", command] };
+  ui?.writeln(dim(`$ ${command}`));
+  const result = spawnSync(shell.bin, shell.args, {
+    cwd,
+    encoding: "utf8",
+    windowsHide: true,
+    maxBuffer: 1024 * 1024,
+  });
+  if (result.stdout) {
+    for (const line of result.stdout.replace(/\s+$/, "").split("\n")) {
+      if (line) ui?.writeln(line);
+    }
+  }
+  if (result.stderr) {
+    for (const line of result.stderr.replace(/\s+$/, "").split("\n")) {
+      if (line) ui?.writeln(red(line));
+    }
+  }
+  if (result.error) {
+    ui?.writeln(red(`Error: ${result.error.message}`));
+  } else if (result.status !== 0) {
+    ui?.writeln(red(`exit ${result.status}`));
+  }
+  return result;
+}
+
+export function formatHotkeysPanel(keybindings = DEFAULT_KEYBINDINGS, diagnostics = []) {
+  return [
+    "Keyboard shortcuts:",
+    ...formatGroupedKeybindingLines(keybindings),
+    ...formatKeybindingDiagnostics(diagnostics),
+    "Input prefixes:",
+    "  /          Slash command autocomplete",
+    "  /session   Restore a previous session",
+    "  /thinking  Choose or list/set thinking level",
+    "  @          File path autocomplete",
+    "  ! cmd      Run local shell command without sending to the model",
+    "  !!         Repeat previous local shell command",
+  ];
+}
+
+export function formatGroupedKeybindingLines(keybindings = DEFAULT_KEYBINDINGS) {
+  return HOTKEY_GROUPS.flatMap(([label, actions]) => [
+    `  ${label}:`,
+    ...actions.map((action) => formatKeybindingLine(action, keybindings)),
+  ]);
+}
+
+function formatKeybindingLine(action, keybindings) {
+  const key = keybindings[action] ?? DEFAULT_KEYBINDINGS[action];
+  return `    ${key.padEnd(10, " ")} ${KEYBINDING_ACTIONS[action]}`;
+}
+
+function formatKeybindingDiagnostics(diagnostics) {
+  if (!diagnostics || diagnostics.length === 0) return [];
+  return [
+    "Keybinding diagnostics:",
+    ...diagnostics.map((diagnostic) => `  - ${diagnostic.type ?? "warning"}: ${diagnostic.message}`),
+  ];
+}

package/src/cli/repl-loop.mjs

@@ -0,0 +1,157 @@
+import { brightBlack, inverse } 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";
+
+export async function runSingleShotPrompt({
+  prompt,
+  runner,
+  memoryStore,
+  currentProject,
+  ui,
+  sessionState,
+  refreshStatusBar,
+  modeState = null,
+}) {
+  memoryStore.beginTurn();
+  const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
+  const recallBlock = formatRecallHints("user", userRecallHints);
+  const shellHints = formatShellHints(runner.shellRuntime);
+  const modePrompt = appendModeReminder(prompt, modeState?.get?.());
+  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, shellHints);
+  ui.writeln(formatUserDisplayMessage(prompt));
+  ui.memoryHint?.({ source: "user", hints: userRecallHints });
+  refreshStatusBar.startWorking?.();
+  try {
+    await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+  } finally {
+    refreshStatusBar.stopWorking?.();
+    memoryStore.endTurn();
+  }
+  refreshStatusBar();
+}
+
+export async function runInteractiveRepl({
+  cwd,
+  args,
+  ui,
+  runner,
+  memoryStore,
+  currentProject,
+  sessionState,
+  sessionsRoot,
+  projectMarchDir,
+  sessionSource,
+  extensionPaths,
+  keybindingConfig,
+  promptTemplateConfig,
+  renderStartupBanner = null,
+  refreshStatusBar,
+  setTurnRunning,
+  modeState = null,
+  configHomeDir,
+}) {
+  let lastInlineShellCommand = "";
+
+  for (;;) {
+    const line = await ui.readline("> ");
+    if (line === null) break;
+    let trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const handledInline = handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand });
+    if (handledInline.type === "handled") {
+      lastInlineShellCommand = handledInline.lastInlineShellCommand;
+      continue;
+    }
+    if (handledInline.type === "error") continue;
+
+    const slashResult = await handleSlashCommand(trimmed, {
+      ui,
+      runner,
+      sessionState,
+      sessionsRoot,
+      projectMarchDir,
+      sessionSource,
+      extensionPaths,
+      keybindings: keybindingConfig.keybindings,
+      keybindingDiagnostics: keybindingConfig.diagnostics,
+      promptTemplates: promptTemplateConfig.templates,
+      promptTemplateDiagnostics: promptTemplateConfig.diagnostics,
+      renderStartupBanner,
+      configHomeDir,
+    });
+    if (slashResult.exit) break;
+    if (slashResult.handled) {
+      refreshStatusBar();
+      continue;
+    }
+
+    const templateResult = expandPromptTemplate(trimmed, promptTemplateConfig.templates);
+    if (templateResult.type === "template") {
+      ui.writeln(brightBlack(`● template: ${templateResult.name}`));
+      trimmed = templateResult.prompt;
+    }
+
+    await runReplTurn({
+      prompt: trimmed,
+      args,
+      runner,
+      memoryStore,
+      currentProject,
+      ui,
+      refreshStatusBar,
+      setTurnRunning,
+      modeState,
+    });
+  }
+}
+
+function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
+  const inlineShell = parseInlineShellInput(trimmed, lastInlineShellCommand);
+  if (inlineShell.type === "error") {
+    ui.writeln(`Error: ${inlineShell.message}`);
+    return { type: "error" };
+  }
+  if (inlineShell.type === "command") {
+    runInlineShellCommand(inlineShell.command, { cwd, ui });
+    return { type: "handled", lastInlineShellCommand: inlineShell.command };
+  }
+  return { type: "none" };
+}
+
+async function runReplTurn({ prompt, args, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
+  memoryStore.beginTurn();
+  const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
+  const recallBlock = formatRecallHints("user", userRecallHints);
+  const shellHints = formatShellHints(runner.shellRuntime);
+  const modePrompt = appendModeReminder(prompt, modeState?.get?.());
+  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, shellHints);
+  try {
+    ui.writeln(formatUserDisplayMessage(prompt));
+    ui.memoryHint?.({ source: "user", hints: userRecallHints });
+    setTurnRunning(true);
+    refreshStatusBar.startWorking?.();
+    await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+    ui.writeln("");
+  } catch (err) {
+    ui.writeln(`Error: ${err.message}`);
+  } finally {
+    setTurnRunning(false);
+    refreshStatusBar.stopWorking?.();
+    memoryStore.endTurn();
+    refreshStatusBar();
+  }
+}
+
+export function formatUserDisplayMessage(prompt) {
+  return `${inverse(" USER ")} ${formatMessageAttachmentsForDisplay(prompt)}`;
+}
+
+function appendPromptBlocks(prompt, ...blocks) {
+  return [prompt, ...blocks.filter(Boolean)].join("\n\n");
+}

package/src/cli/selector-list.mjs

@@ -0,0 +1,21 @@
+export function formatSelectorList({
+  items = [],
+  currentIndex = -1,
+  emptyMessage = "(no items)",
+  instruction,
+  linePrefix = "",
+  formatItem = (item) => String(item),
+}) {
+  if (!items.length) return [emptyMessage];
+  const lines = items.map((item, index) => {
+    const mark = index === currentIndex ? "*" : " ";
+    return `${linePrefix}${mark} ${index + 1}. ${formatItem(item)}`;
+  });
+  if (instruction) lines.push(instruction);
+  return lines;
+}
+
+export function findCurrentIndex(items, predicate) {
+  if (!Array.isArray(items) || typeof predicate !== "function") return -1;
+  return items.findIndex(predicate);
+}

package/src/cli/session/pi-session-switch-command.mjs

@@ -0,0 +1,41 @@
+import { loadPiSessionSidecar } from "../../session/sidecar.mjs";
+
+export async function resumePiSessionById(id, { runner, sessions, projectMarchDir }) {
+  if (!runner.canSwitchPiSession?.()) {
+    return ["Error: pi session resume requires the pi runtime host"];
+  }
+
+  const matches = sessions.filter((session) => session.id.startsWith(id));
+  if (matches.length === 0) return [`Error: pi session not found: ${id}`];
+  if (matches.length > 1) {
+    return [`Error: pi session id is ambiguous: ${id} (${matches.map((session) => session.id).join(", ")})`];
+  }
+
+  const session = matches[0];
+  let sidecar;
+  try {
+    sidecar = loadPiSessionSidecar({ projectMarchDir, sessionRef: session.path });
+  } catch (err) {
+    return [`Error: pi session sidecar is invalid for ${session.id}: ${err.message}`];
+  }
+  if (!sidecar) {
+    return [`Error: pi session sidecar not found for ${session.id}; refusing partial resume`];
+  }
+  if (sidecar.state.cwd && sidecar.state.cwd !== runner.engine.cwd) {
+    return [`Error: pi session sidecar cwd mismatch for ${session.id}: ${sidecar.state.cwd}`];
+  }
+
+  let result;
+  try {
+    result = await runner.switchPiSession(session.path);
+  } catch (err) {
+    return [`Error: failed to switch pi session ${session.id}: ${err.message}`];
+  }
+  if (result?.cancelled) return [`Resume pi session cancelled: ${session.id}`];
+  runner.engine.restoreSession(toContextSessionState(sidecar.state), null, { replace: true });
+  return [`Resumed pi session: ${session.id}`];
+}
+
+function toContextSessionState(sidecarState) {
+  return { ...sidecarState };
+}

package/src/cli/session/session-command.mjs

@@ -0,0 +1,23 @@
+export function formatSessionStats(stats) {
+  const lines = [
+    `session: ${stats.sessionId}`,
+    `messages: ${stats.userMessages}u + ${stats.assistantMessages}a + ${stats.toolCalls}t = ${stats.totalMessages} total`,
+    `tokens: ${stats.tokens.input} in / ${stats.tokens.output} out (${stats.tokens.cacheRead} cache read, ${stats.tokens.cacheWrite} cache write)`,
+    `cost: $${stats.cost.toFixed(4)}`,
+  ];
+  if (typeof stats.persisted === "boolean") {
+    const mode = stats.persisted ? "pi-jsonl" : "in-memory";
+    const suffix = stats.sessionFile ? ` (${stats.sessionFile})` : "";
+    lines.splice(1, 0, `persistence: ${mode}${suffix}`);
+  }
+  if (typeof stats.runtimeHost === "boolean") {
+    const mode = stats.runtimeHost ? "pi-runtime-host" : "direct-agent-session";
+    const insertAt = typeof stats.persisted === "boolean" ? 2 : 1;
+    lines.splice(insertAt, 0, `runtime: ${mode}`);
+  }
+  return lines;
+}
+
+export function listSessionStats({ runner }) {
+  return formatSessionStats(runner.getSessionStats());
+}

package/src/cli/session/session-list-command.mjs

@@ -0,0 +1,68 @@
+import { formatSessionTree } from "../../session/tree.mjs";
+
+export function formatSessionList(sessions, currentSessionId = null) {
+  if (sessions.length === 0) return ["(no saved sessions)"];
+  const lines = sessions.map((session) => {
+    const marker = session.id === currentSessionId ? " *" : "  ";
+    const parent = session.parentSessionId ? `  fork:${session.parentSessionId}` : "";
+    return `${marker} ${session.id}  ${session.turnCount}t  ${session.cwd}  ${session.savedAt?.slice(0, 19) ?? "?"}${parent}`;
+  });
+  lines.push("(* = current session)");
+  return lines;
+}
+
+export function listSessionCommand({ sessions, currentSessionId, tree = false }) {
+  if (tree) return formatSessionTree(sessions, currentSessionId);
+  return formatSessionList(sessions, currentSessionId);
+}
+
+export function formatPiSessionList(sessions) {
+  if (sessions.length === 0) return ["(no pi sessions)"];
+  const lines = sessions.map((session) => {
+    const label = session.name || session.firstMessage || "(no messages)";
+    const savedAt = session.savedAt?.slice(0, 19) ?? "?";
+    return `  ${session.id}  ${session.turnCount}m  ${savedAt}  ${label}`;
+  });
+  lines.push("(pi JSONL session files; use /session to restore a previous session)");
+  return lines;
+}
+
+export function formatPiSessionTree(sessions, currentSessionId = null) {
+  if (sessions.length === 0) return ["(no pi sessions)"];
+
+  const nodes = new Map();
+  const byPath = new Map();
+  for (const session of sessions) {
+    const node = { ...session, children: [] };
+    nodes.set(session.id, node);
+    if (session.path) byPath.set(session.path, node);
+  }
+
+  const roots = [];
+  for (const node of nodes.values()) {
+    const parent = node.parentSessionPath ? byPath.get(node.parentSessionPath) : null;
+    if (parent) parent.children.push(node);
+    else roots.push(node);
+  }
+
+  const bySavedAtDesc = (a, b) => (b.savedAt ?? "").localeCompare(a.savedAt ?? "");
+  const sortDeep = (items) => {
+    items.sort(bySavedAtDesc);
+    for (const item of items) sortDeep(item.children);
+  };
+  sortDeep(roots);
+
+  const lines = [];
+  const visit = (node, depth) => {
+    const marker = node.id === currentSessionId ? "*" : "-";
+    const savedAt = node.savedAt?.slice(0, 19) ?? "?";
+    const label = node.name || node.firstMessage || "(no messages)";
+    const indent = "  ".repeat(depth);
+    lines.push(`${indent}${marker} ${node.id}  ${node.turnCount ?? 0}m  ${savedAt}  ${label}`);
+    for (const child of node.children) visit(child, depth + 1);
+  };
+
+  for (const root of roots) visit(root, 0);
+  lines.push("(* = current pi session; file-level tree uses pi JSONL parentSessionPath)");
+  return lines;
+}

package/src/cli/session/session-name-command.mjs

@@ -0,0 +1,26 @@
+export function parseSessionNameCommand(input) {
+  if (input !== "/name" && !input.startsWith("/name ")) return { type: "none" };
+  const name = input.slice("/name".length).trim();
+  if (!name) return { type: "show" };
+  if (name.length > 120) return { type: "error", message: "Session name must be 120 characters or less" };
+  return { type: "set", name };
+}
+
+export function handleSessionNameCommand(command, { runner } = {}) {
+  if (command.type === "error") return [`Error: ${command.message}`];
+  if (command.type === "show") return [`Session name: ${runner.engine.sessionName || "(unnamed)"}`];
+
+  const name = runner.setSessionName
+    ? runner.setSessionName(command.name)
+    : setEngineSessionName(runner.engine, command.name);
+  return [`Session named: ${name}`];
+}
+
+function setEngineSessionName(engine, name) {
+  if (typeof engine.setSessionName === "function") {
+    engine.setSessionName(name);
+  } else {
+    engine.sessionName = String(name || "").trim();
+  }
+  return engine.sessionName;
+}

package/src/cli/session/session-source-command.mjs

@@ -0,0 +1,89 @@
+import { listPiSessionInfos } from "../../session/pi-manager.mjs";
+import { loadPiSessionTranscriptTurns } from "../../session/transcript.mjs";
+import { resumePiSessionById } from "./pi-session-switch-command.mjs";
+
+export async function handleSessionSourceCommand(trimmed, {
+  ui,
+  runner,
+  sessionState,
+  sessionsRoot,
+  projectMarchDir,
+}) {
+  if (trimmed === "/save") {
+    const stats = runner.getSessionStats?.();
+    ui.writeln(`Pi session auto-saved: ${stats?.sessionId ?? sessionState.sessionId}`);
+    return { handled: true };
+  }
+
+  if (trimmed === "/session") {
+    const sessions = await listPiSessionInfos({
+      cwd: runner.engine.cwd,
+      projectMarchDir,
+    });
+    if (sessions.length === 0) {
+      ui.writeln("No previous sessions.");
+      return { handled: true };
+    }
+    if (!ui.selectList) {
+      ui.writeln("Session selector is only available in TUI.");
+      return { handled: true };
+    }
+    const currentSessionId = runner.getSessionStats?.().sessionId ?? null;
+    const item = await ui.selectList({
+      items: buildSessionSelectItems(sessions, currentSessionId),
+      selectedIndex: Math.max(0, sessions.findIndex((session) => session.id === currentSessionId)),
+      width: 72,
+      suppressInitialConfirm: true,
+      searchable: true,
+      getSearchText: sessionSelectSearchText,
+    });
+    if (!item) {
+      ui.writeln("Session unchanged.");
+      return { handled: true };
+    }
+    const lines = await resumePiSessionById(item.session.id, { runner, sessions, projectMarchDir });
+    if (isResumeSuccess(lines)) restoreTranscriptFromSession(item.session, ui);
+    for (const line of lines) {
+      ui.writeln(line);
+    }
+    return { handled: true };
+  }
+
+  return { handled: false };
+}
+
+export function buildSessionSelectItems(sessions, currentSessionId = null) {
+  return sessions.map((session) => {
+    const label = session.name || session.firstMessage || "(no messages)";
+    const savedAt = formatSessionSelectTime(session.savedAt);
+    return {
+      value: session.id,
+      label,
+      description: savedAt,
+      session,
+    };
+  });
+}
+
+function sessionSelectSearchText(item) {
+  const session = item?.session;
+  return `${item?.label ?? ""} ${item?.description ?? ""} ${session?.id ?? ""} ${session?.name ?? ""} ${session?.firstMessage ?? ""} ${session?.turnCount ?? ""}`;
+}
+
+function restoreTranscriptFromSession(session, ui) {
+  if (typeof ui.restoreTranscript !== "function") return;
+  try {
+    ui.restoreTranscript(loadPiSessionTranscriptTurns(session.path));
+  } catch (err) {
+    ui.writeln(`Warning: failed to restore session transcript: ${err.message}`);
+  }
+}
+
+function isResumeSuccess(lines) {
+  return Array.isArray(lines) && lines.some((line) => String(line).startsWith("Resumed pi session:"));
+}
+
+function formatSessionSelectTime(value) {
+  if (!value) return "?";
+  return String(value).slice(0, 16).replace("T", " ");
+}

package/src/cli/session/session-switch-command.mjs

@@ -0,0 +1 @@
+// Legacy session switch command removed. Use /session to restore previous pi sessions.

package/src/cli/shell/shell-command.mjs

@@ -0,0 +1,55 @@
+export function parseShellCommand(input) {
+  if (input === "/shell") return { type: "list" };
+  if (input === "/shell spawn") return { type: "spawn", name: "" };
+  if (input.startsWith("/shell spawn ")) {
+    const name = input.slice("/shell spawn ".length).trim();
+    return name ? { type: "spawn", name } : { type: "spawn", name: "" };
+  }
+  if (input.startsWith("/shell ")) {
+    const idOrName = input.slice("/shell ".length).trim();
+    return idOrName ? { type: "show", idOrName } : { type: "list" };
+  }
+  return { type: "none" };
+}
+
+export function handleShellCommand(command, { shellRuntime = null } = {}) {
+  if (!shellRuntime) {
+    return ["Shell runtime is disabled. Restart without --no-shell-runtime to use /shell."];
+  }
+  if (command.type === "spawn") {
+    const shell = shellRuntime.spawnShell({ name: command.name || undefined });
+    return [
+      `Spawned shell: ${shell.id}  ${shell.name}  ${shell.status}`,
+      "Open the right-side shell pane with Alt+S, then type directly to send input.",
+    ];
+  }
+  if (command.type === "list") {
+    const shells = shellRuntime.listShells();
+    if (!shells.length) return ["No shells."];
+    return [
+      "Shells:",
+      ...shells.map(formatShellListItem),
+      "Use /shell <id-or-name> to inspect recent output, or /shell spawn [name] to start one.",
+    ];
+  }
+  if (command.type === "show") {
+    const shell = findShell(shellRuntime.listShells(), command.idOrName);
+    if (!shell) return [`Error: shell not found: ${command.idOrName}`];
+    const snapshot = shellRuntime.snapshotShell(shell.id);
+    return [
+      formatShellListItem(shell),
+      "Recent output:",
+      snapshot.screen?.plain || snapshot.plain || "(no output)",
+    ];
+  }
+  return [];
+}
+
+function findShell(shells, idOrName) {
+  return shells.find((shell) => shell.id === idOrName || shell.name === idOrName) ?? null;
+}
+
+function formatShellListItem(shell) {
+  const args = shell.args?.length ? ` ${shell.args.join(" ")}` : "";
+  return `${shell.id}  ${shell.name}  ${shell.status}  ${shell.command}${args}  ${shell.lineCount ?? 0} lines`;
+}