@cryer/star-cli 0.2.1 → 0.2.2

package/dist/main.js

@@ -4,6 +4,7 @@ import {
   SKIP_DIRS,
   TodoStore,
   WORKING_DIFF_MAX_LINES,
+  appendUserMemory,
   bashTool,
   buildAllowRule,
   buildCommitPrompt,
@@ -12,6 +13,7 @@ import {
   collectWorkingDiff,
   compactMessages,
   createDefaultRegistry,
+  createIgnorePredicate,
   defaultTaskManager,
   discoverSkills,
   estimateTokens,
@@ -34,8 +36,9 @@ import {
   sessionsDir,
   starHome,
   summarizeMessages,
-  undoTurnSnapshots
-} from "./chunk-MJ2O7NWI.js";
+  undoTurnSnapshots,
+  userMemoryPath
+} from "./chunk-GN236FD4.js";
 
 // src/main.tsx
 import { Command } from "commander";
@@ -269,14 +272,17 @@ var UsageTracker = class {
 };
 
 // src/cli/repl.tsx
-import { Box as Box9, Text as Text10, render, useApp, useInput as useInput5 } from "ink";
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import { Box as Box10, Text as Text11, render, useApp, useInput as useInput6 } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState3 } from "react";
 
 // src/config/save.ts
 import fs from "fs";
 import path2 from "path";
 import { parse, stringify } from "smol-toml";
 async function addAllowRule(rule) {
+  return addPermissionRule("allow", rule);
+}
+async function addPermissionRule(kind, rule) {
   const filePath = globalConfigPath();
   let raw = {};
   try {
@@ -286,9 +292,9 @@ async function addAllowRule(rule) {
     if (error.code !== "ENOENT") throw error;
   }
   const permissions = typeof raw.permissions === "object" && raw.permissions !== null ? raw.permissions : {};
-  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
-  if (allow.includes(rule)) return false;
-  permissions.allow = [...allow, rule];
+  const rules = Array.isArray(permissions[kind]) ? permissions[kind] : [];
+  if (rules.includes(rule)) return false;
+  permissions[kind] = [...rules, rule];
   raw.permissions = permissions;
   await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
@@ -332,7 +338,8 @@ var ModelConfigSchema = z.object({
   completionPrice: z.number().nonnegative().optional()
 });
 var PermissionsConfigSchema = z.object({
-  allow: z.array(z.string()).default([])
+  allow: z.array(z.string()).default([]),
+  deny: z.array(z.string()).default([])
 });
 var HookConfigSchema = z.object({
   event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
@@ -370,7 +377,7 @@ var ConfigSchema = z.object({
   // STAR_NO_NOTIFY=1 disables without touching the config.
   notifyBell: z.boolean().default(true),
   notifyBellThresholdSec: z.number().positive().default(10),
-  permissions: PermissionsConfigSchema.default({ allow: [] }),
+  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
   hooks: z.array(HookConfigSchema).default([])
 });
 function contextWindowTokens(config, modelName) {
@@ -1253,6 +1260,61 @@ function stringifyPart(value) {
   return typeof value === "string" ? value : JSON.stringify(value, null, 2);
 }
 
+// src/cli/commands/builtin.ts
+import { readFileSync } from "fs";
+
+// src/session/search.ts
+var SNIPPET_LENGTH = 100;
+function flattenMessage(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      parts.push(part.text);
+    } else if (part.type === "tool-call") {
+      parts.push(JSON.stringify(part.args));
+    } else if (part.type === "tool-result") {
+      parts.push(typeof part.result === "string" ? part.result : JSON.stringify(part.result));
+    }
+  }
+  return parts.join("\n");
+}
+function makeSnippet(text, query) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  const index = flat.toLowerCase().indexOf(query.toLowerCase());
+  if (index === -1 || flat.length <= SNIPPET_LENGTH) return flat.slice(0, SNIPPET_LENGTH);
+  const side = Math.max(0, Math.floor((SNIPPET_LENGTH - query.length) / 2));
+  let start = Math.max(0, index - side);
+  const end = Math.min(flat.length, start + SNIPPET_LENGTH);
+  start = Math.max(0, end - SNIPPET_LENGTH);
+  return `${start > 0 ? "\u2026" : ""}${flat.slice(start, end)}${end < flat.length ? "\u2026" : ""}`;
+}
+async function searchSessions(query, limit = 10) {
+  const hits = [];
+  const needle = query.toLowerCase();
+  for (const meta of await SessionStore.list()) {
+    if (hits.length >= limit) break;
+    const store = await SessionStore.open(meta.id);
+    if (!store) continue;
+    const text = (await store.messages()).map(flattenMessage).filter((part) => part.length > 0).join("\n");
+    if (text.toLowerCase().includes(needle)) {
+      hits.push({ meta, snippet: makeSnippet(text, query) });
+    }
+  }
+  return hits;
+}
+function formatSearchResults(hits, query) {
+  if (hits.length === 0) return `No sessions matching "${query}".`;
+  const lines = hits.map(({ meta, snippet }) => {
+    const title = meta.title || "(untitled)";
+    return `${shortSessionId(meta.id)}  ${title}  (${relativeTime(meta.updatedAt)})
+    ${snippet}`;
+  });
+  return [...lines, "Resume with /resume <id>"].join("\n");
+}
+
 // src/cli/diff-preview.ts
 import { readFile as readFile3 } from "fs/promises";
 import path10 from "path";
@@ -1440,31 +1502,41 @@ async function generateDiffPreview(toolName, args, cwd) {
 
 // src/cli/commands/builtin.ts
 function registerBuiltinCommands(registry) {
-  registry.register({
+  const register = (command) => registry.register(command);
+  register({
     name: "help",
     description: "List available commands",
     usage: "/help",
+    category: "General",
     run(_args, ctx) {
-      const lines = registry.list().map((cmd) => {
+      const groups = /* @__PURE__ */ new Map();
+      for (const cmd of registry.list()) {
+        const category = cmd.category ?? "Other";
         const usage = cmd.usage ?? `/${cmd.name}`;
-        return `${usage} - ${cmd.description}`;
-      });
+        const lines = groups.get(category) ?? [];
+        lines.push(`  ${usage} - ${cmd.description}`);
+        groups.set(category, lines);
+      }
+      const sections = [...groups.entries()].map(([name, lines]) => [name, ...lines].join("\n"));
       ctx.addSystemMessage(`Available commands:
-${lines.join("\n")}`);
+
+${sections.join("\n\n")}`);
     }
   });
-  registry.register({
+  register({
     name: "clear",
     description: "Clear message history",
     usage: "/clear",
+    category: "General",
     run(_args, ctx) {
       ctx.clearMessages();
     }
   });
-  registry.register({
+  register({
     name: "new",
     description: "Start a new session with a clean context",
     usage: "/new",
+    category: "Sessions",
     async run(_args, ctx) {
       if (!ctx.newSession) {
         ctx.addSystemMessage("/new: this context cannot start a new session.");
@@ -1473,10 +1545,11 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(await ctx.newSession());
     }
   });
-  registry.register({
+  register({
     name: "clear-sessions",
     description: "Delete stored sessions: this directory by default, every session with --all (the current session is kept)",
     usage: "/clear-sessions [--all]",
+    category: "Sessions",
     async run(args, ctx) {
       const arg = args.trim();
       if (arg !== "" && arg !== "--all") {
@@ -1492,157 +1565,242 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage(await ctx.clearSessions(arg === "--all"));
     }
   });
-  registry.register({
+  register({
     name: "exit",
     description: "Exit the application",
     usage: "/exit",
+    category: "General",
     run(_args, ctx) {
       ctx.exit();
     }
   });
-  registry.register({
+  register({
     name: "q",
     description: "Exit the application (alias of /exit)",
     usage: "/q",
+    category: "General",
     run(_args, ctx) {
       ctx.exit();
     }
   });
-  registry.register({
+  register({
     name: "model",
-    description: "List available models or switch the current model",
+    description: "Switch the current model (opens a picker when no name is given)",
     usage: "/model [name]",
+    category: "Settings",
     async run(args, ctx) {
       if (!args) {
-        ctx.addSystemMessage(ctx.listModels());
+        ctx.addSystemMessage(await ctx.pickModel());
       } else {
         ctx.addSystemMessage(await ctx.switchModel(args));
       }
     }
   });
-  registry.register({
+  register({
     name: "resume",
-    description: "List sessions or resume a session by id",
+    description: "Resume a session by id, or pick one from a list (--all for every directory)",
     usage: "/resume [sessionId | --all]",
+    category: "Sessions",
     async run(args, ctx) {
       const arg = args.trim();
       if (arg === "--all") {
-        ctx.addSystemMessage(await ctx.listSessions(true));
+        ctx.addSystemMessage(await ctx.pickSession(true));
       } else if (!arg) {
-        ctx.addSystemMessage(await ctx.listSessions());
+        ctx.addSystemMessage(await ctx.pickSession(false));
       } else {
         ctx.addSystemMessage(await ctx.resumeSession(arg));
       }
     }
   });
-  registry.register({
+  register({
+    name: "fork",
+    description: "Fork the current session into a new one and switch to it",
+    usage: "/fork",
+    category: "Sessions",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.forkSession());
+    }
+  });
+  register({
+    name: "search",
+    description: "Full-text search across all stored sessions",
+    usage: "/search <query>",
+    category: "Sessions",
+    async run(args, ctx) {
+      const query = args.trim();
+      if (!query) {
+        ctx.addSystemMessage("Usage: /search <query>");
+        return;
+      }
+      ctx.addSystemMessage(formatSearchResults(await searchSessions(query), query));
+    }
+  });
+  register({
     name: "todo",
     description: "Show the current todo list",
     usage: "/todo",
+    category: "Info",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.showTodos());
     }
   });
-  registry.register({
+  register({
     name: "tasks",
     description: "List background shell tasks",
     usage: "/tasks",
+    category: "Info",
     run(_args, ctx) {
       ctx.addSystemMessage(ctx.listTasks());
     }
   });
-  registry.register({
+  register({
     name: "cost",
     description: "Show API token usage for this session",
     usage: "/cost",
+    category: "Info",
     run(_args, ctx) {
       ctx.addSystemMessage(ctx.showUsage());
     }
   });
-  registry.register({
+  register({
     name: "usage",
     description: "Show token usage aggregated across all sessions",
     usage: "/usage",
+    category: "Info",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.showGlobalUsage());
     }
   });
-  registry.register({
+  register({
     name: "config",
     description: "Show the current configuration",
     usage: "/config",
+    category: "Info",
     run(_args, ctx) {
       ctx.addSystemMessage(ctx.describeConfig());
     }
   });
-  registry.register({
+  register({
     name: "compact",
     description: "Compact the conversation history to free up context",
     usage: "/compact",
+    category: "Sessions",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.compactContext());
     }
   });
-  registry.register({
+  register({
     name: "export",
     description: "Export the current session to a Markdown file",
     usage: "/export [path]",
+    category: "Sessions",
     async run(args, ctx) {
       ctx.addSystemMessage(await ctx.exportSession(args));
     }
   });
-  registry.register({
+  register({
     name: "permission",
-    description: "Show or set the global permission mode (ask | auto | readonly | yolo)",
+    description: "Set the permission mode (opens a picker when no mode is given)",
     usage: "/permission [ask|auto|readonly|yolo]",
+    category: "Settings",
     async run(args, ctx) {
-      ctx.addSystemMessage(await ctx.permissionMode(args.trim()));
+      const arg = args.trim();
+      if (!arg) {
+        ctx.addSystemMessage(await ctx.pickPermissionMode());
+      } else {
+        ctx.addSystemMessage(await ctx.permissionMode(arg));
+      }
     }
   });
-  registry.register({
+  register({
     name: "plan",
     description: "Toggle plan mode: read-only research, then approve the plan before executing",
     usage: "/plan",
+    category: "Settings",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.planMode());
     }
   });
-  registry.register({
+  register({
+    name: "memory",
+    description: "Show user memory (MEMORY.md), or add an entry",
+    usage: "/memory [add <text>]",
+    category: "Settings",
+    run(args, ctx) {
+      const arg = args.trim();
+      if (arg === "add" || arg.startsWith("add ")) {
+        const text = arg.slice(3).trim();
+        if (!text) {
+          ctx.addSystemMessage("Usage: /memory add <text>");
+          return;
+        }
+        appendUserMemory(text);
+        ctx.addSystemMessage(`Saved to user memory: - ${text}`);
+        return;
+      }
+      if (arg) {
+        ctx.addSystemMessage(`Unknown argument "${arg}". Usage: /memory [add <text>]`);
+        return;
+      }
+      const file = userMemoryPath();
+      let content = "";
+      try {
+        content = readFileSync(file, "utf8").trim();
+      } catch {
+        content = "";
+      }
+      if (!content) {
+        ctx.addSystemMessage(
+          `No user memory yet (${file}).
+Add entries with /memory add <text> or ask the agent to remember something.`
+        );
+        return;
+      }
+      ctx.addSystemMessage(`User memory (${file}):
+${content}`);
+    }
+  });
+  register({
     name: "undo",
     description: "Undo the last conversation turn: revert its file changes (write_file/edit_file) and retract its messages",
     usage: "/undo",
+    category: "Changes",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.undo());
     }
   });
-  registry.register({
+  register({
     name: "rewind",
     description: "List file-change checkpoints, or rewind to just before one: restore files and retract the conversation",
     usage: "/rewind [n]",
+    category: "Changes",
     async run(args, ctx) {
       ctx.addSystemMessage(await ctx.rewind(args.trim()));
     }
   });
-  registry.register({
+  register({
     name: "init",
     description: "Generate an AGENTS.md for the current project",
     usage: "/init [force]",
+    category: "Settings",
     async run(args, ctx) {
       ctx.addSystemMessage(await ctx.initProject(args));
     }
   });
-  registry.register({
+  register({
     name: "doctor",
     description: "Run environment and configuration checks",
     usage: "/doctor",
+    category: "Info",
     async run(_args, ctx) {
       ctx.addSystemMessage(await ctx.runDoctor());
     }
   });
-  registry.register({
+  register({
     name: "skills",
     description: "List available skills (project scope overrides user scope)",
     usage: "/skills",
+    category: "Info",
     run(_args, ctx) {
       const skills = discoverSkills(ctx.cwd ?? process.cwd());
       if (skills.length === 0) {
@@ -1656,10 +1814,11 @@ ${lines.join("\n")}`);
 ${lines.join("\n")}`);
     }
   });
-  registry.register({
+  register({
     name: "commit",
     description: "Analyze uncommitted changes and create a git commit (Conventional Commits)",
     usage: "/commit [instructions]",
+    category: "Changes",
     async run(args, ctx) {
       const cwd = ctx.cwd ?? process.cwd();
       if (!isGitRepo(cwd)) {
@@ -1678,10 +1837,11 @@ ${lines.join("\n")}`);
       ctx.addSystemMessage("/commit: this context cannot submit prompts to the model.");
     }
   });
-  registry.register({
+  register({
     name: "copy",
     description: "Copy the last assistant reply to the clipboard (`all` for the whole conversation)",
     usage: "/copy [all]",
+    category: "Sessions",
     async run(args, ctx) {
       const arg = args.trim();
       if (arg !== "" && arg !== "all") {
@@ -1706,10 +1866,11 @@ ${lines.join("\n")}`);
       );
     }
   });
-  registry.register({
+  register({
     name: "diff",
     description: "Show uncommitted changes (git status + colored diff)",
     usage: "/diff",
+    category: "Changes",
     run(_args, ctx) {
       const cwd = ctx.cwd ?? process.cwd();
       if (!isGitRepo(cwd)) {
@@ -1745,7 +1906,7 @@ ${result.diff}${note ? `
 }
 
 // src/cli/commands/custom.ts
-import { readFileSync, readdirSync } from "fs";
+import { readFileSync as readFileSync2, readdirSync } from "fs";
 import path11 from "path";
 var NAME_PATTERN = /^[a-z0-9-]+$/;
 var DESCRIPTION_PATTERN = /^<!--\s*description:\s*(.+?)\s*-->\s*$/;
@@ -1753,7 +1914,7 @@ var DEFAULT_DESCRIPTION = "Custom prompt command";
 function parseCommandFile(filePath, name) {
   let raw;
   try {
-    raw = readFileSync(filePath, "utf8");
+    raw = readFileSync2(filePath, "utf8");
   } catch {
     return null;
   }
@@ -1799,6 +1960,7 @@ function registerCustomCommands(registry, cwd, home) {
       name: command.name,
       description: command.description,
       usage: `/${command.name} [args]`,
+      category: "Custom",
       run(args, ctx) {
         const prompt = command.template.split("$ARGUMENTS").join(args);
         if (ctx.submitPrompt) {
@@ -2215,6 +2377,33 @@ function formatCheckpointList(snapshots, cwd) {
   ].join("\n");
 }
 
+// src/cli/commands/suggest.ts
+var MAX_SUGGESTIONS = 5;
+function isSubsequence(query, target) {
+  let i = 0;
+  for (const ch of target) {
+    if (ch === query[i]) i += 1;
+    if (i === query.length) return true;
+  }
+  return query.length === 0;
+}
+function filterCommands(input, commands) {
+  if (!input.startsWith("/")) return [];
+  if (/\s/.test(input)) return [];
+  const prefix = input.slice(1).toLowerCase();
+  const byName = (a, b) => a.name.localeCompare(b.name);
+  const prefixed = commands.filter((cmd) => cmd.name.toLowerCase().startsWith(prefix)).sort(byName);
+  const fuzzy = commands.filter(
+    (cmd) => !cmd.name.toLowerCase().startsWith(prefix) && isSubsequence(prefix, cmd.name.toLowerCase())
+  ).sort(byName);
+  return [...prefixed, ...fuzzy].slice(0, MAX_SUGGESTIONS);
+}
+function didYouMeanSuffix(names) {
+  if (names.length === 0) return "";
+  const listed = names.slice(0, 3).map((name) => `/${name}`);
+  return ` Did you mean: ${listed.join(", ")}?`;
+}
+
 // src/cli/components/ExitPlanPrompt.tsx
 import { Box, Text, useInput } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -2235,15 +2424,6 @@ function ExitPlanPrompt({ onDecision }) {
 import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
 import { useEffect, useRef, useState } from "react";
 
-// src/cli/commands/suggest.ts
-var MAX_SUGGESTIONS = 5;
-function filterCommands(input, commands) {
-  if (!input.startsWith("/")) return [];
-  if (/\s/.test(input)) return [];
-  const prefix = input.slice(1).toLowerCase();
-  return commands.filter((cmd) => cmd.name.toLowerCase().startsWith(prefix)).sort((a, b) => a.name.localeCompare(b.name)).slice(0, MAX_SUGGESTIONS);
-}
-
 // src/cli/path-suggest.ts
 import { readdir } from "fs/promises";
 import path15 from "path";
@@ -2264,6 +2444,7 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
   const dirAbs = path15.resolve(cwd, dirPart === "" ? "." : dirPart);
   const entries = await readdir(dirAbs, { withFileTypes: true }).catch(() => null);
   if (!entries) return [];
+  const ignore = createIgnorePredicate(cwd);
   const lower = basePrefix.toLowerCase();
   const matches = [];
   let scanned = 0;
@@ -2275,6 +2456,7 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
     if (isDir && SKIP_DIRS.has(entry.name)) continue;
     if (entry.name.startsWith(".") && !basePrefix.startsWith(".")) continue;
     if (!entry.name.toLowerCase().startsWith(lower)) continue;
+    if (ignore?.(path15.join(dirAbs, entry.name), isDir)) continue;
     matches.push({ path: `${dirPart}${entry.name}${isDir ? "/" : ""}`, isDir });
   }
   matches.sort((a, b) => a.path.localeCompare(b.path));
@@ -2289,6 +2471,7 @@ function InputBox({
   commands,
   cwd,
   refill,
+  initialHistory,
   onSubmit,
   onInterrupt,
   onExit,
@@ -2296,7 +2479,7 @@ function InputBox({
 }) {
   const [value, setValue] = useState("");
   const [cursor, setCursor] = useState(0);
-  const [history, setHistory] = useState([]);
+  const [history, setHistory] = useState(() => initialHistory ?? []);
   const [highlight, setHighlight] = useState(0);
   const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
   const [pathSuggestions, setPathSuggestions] = useState([]);
@@ -2478,12 +2661,13 @@ function InputBox({
       /* @__PURE__ */ jsx2(Text2, { inverse: true, children: at }),
       /* @__PURE__ */ jsx2(Text2, { children: after })
     ] }),
-    suggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: suggestions.map(
-      (cmd, index) => index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `/${cmd.name} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs2(Text2, { children: [
-        /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: `/${cmd.name}` }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: suggestions.map((cmd, index) => {
+      const label = cmd.usage ?? `/${cmd.name}`;
+      return index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `${label} - ${cmd.description}` }, cmd.name) : /* @__PURE__ */ jsxs2(Text2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: label }),
         /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: ` - ${cmd.description}` })
-      ] }, cmd.name)
-    ) }),
+      ] }, cmd.name);
+    }) }),
     showPathSuggestions && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", paddingLeft: 2, children: pathSuggestions.map(
       (sugg, index) => index === activeIndex ? /* @__PURE__ */ jsx2(Text2, { bold: true, inverse: true, children: `@${sugg.path}` }, sugg.path) : /* @__PURE__ */ jsxs2(Text2, { children: [
         /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: `@${sugg.path}` }),
@@ -2591,10 +2775,72 @@ function RewindConfirmPrompt({ summary, onDecision }) {
   ] });
 }
 
+// src/cli/components/SelectPrompt.tsx
+import { Box as Box6, Text as Text7, useInput as useInput5 } from "ink";
+import { useState as useState2 } from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var SELECT_PROMPT_MAX_VISIBLE = 9;
+function SelectPrompt({ title, options, onSelect, onCancel }) {
+  const [index, setIndex] = useState2(0);
+  useInput5((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const option = options[index];
+      if (option) onSelect(option.value);
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      setIndex((i) => Math.min(i + 1, options.length - 1));
+    } else if (key.upArrow || input === "k") {
+      setIndex((i) => Math.max(i - 1, 0));
+    }
+  });
+  const maxStart = Math.max(0, options.length - SELECT_PROMPT_MAX_VISIBLE);
+  const start = Math.min(Math.max(0, index - Math.floor(SELECT_PROMPT_MAX_VISIBLE / 2)), maxStart);
+  const visible = options.slice(start, start + SELECT_PROMPT_MAX_VISIBLE);
+  const above = start;
+  const below = options.length - start - visible.length;
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: title }),
+    above > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "\u2026 ",
+      above,
+      " more above"
+    ] }),
+    visible.map((option, i) => {
+      const active = start + i === index;
+      return /* @__PURE__ */ jsxs7(Text7, { children: [
+        /* @__PURE__ */ jsxs7(Text7, { bold: active, inverse: active, children: [
+          active ? "\u276F " : "  ",
+          option.label
+        ] }),
+        option.hint && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " (",
+          option.hint,
+          ")"
+        ] }),
+        option.description && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " \u2014 ",
+          option.description
+        ] })
+      ] }, option.value);
+    }),
+    below > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "\u2026 ",
+      below,
+      " more below"
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "[\u2191/\u2193 or j/k] move [Enter] select [Esc] cancel" })
+  ] });
+}
+
 // src/cli/components/StatusBar.tsx
-import { Box as Box6, Text as Text7, useStdout } from "ink";
+import { Box as Box7, Text as Text8, useStdout } from "ink";
 import { memo as memo2 } from "react";
-import { jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsxs as jsxs8 } from "react/jsx-runtime";
 var BG_LABEL_MAX = 40;
 var WIDE_COLUMNS = 120;
 function cwdLabel(cwd, wide) {
@@ -2616,36 +2862,36 @@ var StatusBar = memo2(function StatusBar2({
   const wide = (stdout?.columns ?? 80) >= WIDE_COLUMNS;
   const joined = backgroundTasks.join(", ");
   const labels = joined.length > BG_LABEL_MAX ? `${joined.slice(0, BG_LABEL_MAX)}\u2026` : joined;
-  return /* @__PURE__ */ jsxs7(Box6, { justifyContent: "space-between", children: [
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs8(Box7, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       cwdLabel(cwd, wide),
       gitBranch ? ` [${gitBranch}]` : ""
     ] }),
-    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
+    backgroundTasks.length > 0 && /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
       "bg: ",
       backgroundTasks.length,
       " (",
       labels,
       ")"
     ] }),
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       "model: ",
       model
     ] }),
-    contextPercent != null && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    contextPercent != null && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       "ctx: ",
       contextPercent,
       "%"
     ] }),
-    sessionCostUsd != null && sessionCostUsd > 0 && /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    sessionCostUsd != null && sessionCostUsd > 0 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       "$",
       formatDollars(sessionCostUsd)
     ] }),
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       tokens2,
       " tokens"
     ] }),
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       "mode: ",
       permissionMode
     ] })
@@ -2653,22 +2899,22 @@ var StatusBar = memo2(function StatusBar2({
 });
 
 // src/cli/components/StreamingMessage.tsx
-import { Box as Box7, Text as Text8 } from "ink";
+import { Box as Box8, Text as Text9 } from "ink";
 import { memo as memo3 } from "react";
-import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
 var StreamingMessage = memo3(function StreamingMessage2({
   text,
   continuation
 }) {
-  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", marginBottom: 1, children: [
-    !continuation && /* @__PURE__ */ jsx7(Text8, { bold: true, color: "green", children: "star" }),
-    /* @__PURE__ */ jsx7(Text8, { color: "green", children: text })
+  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", marginBottom: 1, children: [
+    !continuation && /* @__PURE__ */ jsx8(Text9, { bold: true, color: "green", children: "star" }),
+    /* @__PURE__ */ jsx8(Text9, { color: "green", children: text })
   ] });
 });
 
 // src/cli/components/ThinkingIndicator.tsx
-import { Box as Box8, Text as Text9 } from "ink";
-import { jsxs as jsxs9 } from "react/jsx-runtime";
+import { Box as Box9, Text as Text10 } from "ink";
+import { jsxs as jsxs10 } from "react/jsx-runtime";
 var SPINNER_FRAMES = ["-", "\\", "|", "/"];
 var REASONING_TAIL_LENGTH = 200;
 var THOUGHT_SUMMARY_LENGTH = 100;
@@ -2684,13 +2930,13 @@ function ThinkingIndicator({
 }) {
   const tail = reasoning ? truncateTail(reasoning, REASONING_TAIL_LENGTH) : "";
   const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       spinner,
       " ",
       activity ?? "star is thinking\u2026"
     ] }),
-    tail !== "" && /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+    tail !== "" && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       " ",
       tail
     ] })
@@ -2712,6 +2958,51 @@ function isDoubleEscape(previous, now, windowMs = DOUBLE_ESC_WINDOW_MS) {
   return previous !== null && now - previous <= windowMs;
 }
 
+// src/cli/history.ts
+import fs10 from "fs";
+import path16 from "path";
+var DEFAULT_LIMIT = 500;
+var MAX_FILE_LINES = 1e3;
+var TRIM_TO_LINES = 500;
+function historyPath() {
+  return path16.join(starHome(), "history");
+}
+function readLines(file) {
+  const raw = fs10.readFileSync(file, "utf8");
+  return raw.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line.trim().length > 0);
+}
+function loadHistory(limit = DEFAULT_LIMIT) {
+  try {
+    return readLines(historyPath()).slice(-limit);
+  } catch {
+    return [];
+  }
+}
+function appendHistory(entry) {
+  const line = entry.replace(/[\r\n]+/g, " ").trim();
+  if (line.length === 0) return;
+  try {
+    const file = historyPath();
+    let existing = [];
+    try {
+      existing = readLines(file);
+    } catch {
+    }
+    if (existing[existing.length - 1] === line) return;
+    if (existing.length >= MAX_FILE_LINES) {
+      const kept = [...existing.slice(-(TRIM_TO_LINES - 1)), line];
+      fs10.mkdirSync(path16.dirname(file), { recursive: true });
+      fs10.writeFileSync(file, `${kept.join("\n")}
+`);
+      return;
+    }
+    fs10.mkdirSync(path16.dirname(file), { recursive: true });
+    fs10.appendFileSync(file, `${line}
+`);
+  } catch {
+  }
+}
+
 // src/cli/notify.ts
 var BELL = "\x07";
 function shouldNotifyBell(input, isTTY) {
@@ -2827,7 +3118,7 @@ async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx8, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx9, jsxs as jsxs11 } from "react/jsx-runtime";
 var CLEAR_TERMINAL = process.platform === "win32" ? "\x1B[2J\x1B[0f" : "\x1B[2J\x1B[3J\x1B[H";
 function emptyUsage() {
   return { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -2839,6 +3130,16 @@ var SESSION_MODE_CYCLE = ["ask", "auto", "readonly", "plan"];
 function formatUsage(usage) {
   return `API usage this session: ${usage.requests} requests, ${usage.promptTokens} prompt + ${usage.completionTokens} completion = ${usage.totalTokens} tokens`;
 }
+var SESSION_PICKER_CAP = 20;
+async function sessionPreview(id) {
+  const store = await SessionStore.open(id);
+  if (!store) return null;
+  const first = (await store.messages()).find((m) => m.role === "user");
+  if (!first) return null;
+  const text = coreMessageText(first).replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  return text.length > 60 ? `${text.slice(0, 60)}\u2026` : text;
+}
 function Repl({
   backend,
   model,
@@ -2850,23 +3151,24 @@ function Repl({
   initialUsage
 }) {
   const { exit } = useApp();
-  const [initialDisplay] = useState2(() => buildDisplayMessages(initialMessages ?? []));
-  const [messages, setMessages] = useState2(initialDisplay);
-  const [epoch, setEpoch] = useState2(0);
-  const [streamingText, setStreamingText] = useState2(null);
-  const [isStreaming, setIsStreaming] = useState2(false);
-  const [thinking, setThinking] = useState2(false);
-  const [thinkingText, setThinkingText] = useState2("");
-  const [thoughtSummary, setThoughtSummary] = useState2(null);
-  const [, setUsageVersion] = useState2(0);
-  const [modelName, setModelName] = useState2(model);
-  const [pending, setPending] = useState2(null);
-  const [spinnerTick, setSpinnerTick] = useState2(0);
-  const [activity, setActivity] = useState2(null);
-  const [bgLabels, setBgLabels] = useState2(() => runningTaskLabels());
-  const [permissionModeState, setPermissionModeState] = useState2(permissionMode);
-  const [planApproval, setPlanApprovalState] = useState2(false);
-  const [pendingRewind, setPendingRewindState] = useState2(null);
+  const [initialDisplay] = useState3(() => buildDisplayMessages(initialMessages ?? []));
+  const [messages, setMessages] = useState3(initialDisplay);
+  const [epoch, setEpoch] = useState3(0);
+  const [streamingText, setStreamingText] = useState3(null);
+  const [isStreaming, setIsStreaming] = useState3(false);
+  const [thinking, setThinking] = useState3(false);
+  const [thinkingText, setThinkingText] = useState3("");
+  const [thoughtSummary, setThoughtSummary] = useState3(null);
+  const [, setUsageVersion] = useState3(0);
+  const [modelName, setModelName] = useState3(model);
+  const [pending, setPending] = useState3(null);
+  const [spinnerTick, setSpinnerTick] = useState3(0);
+  const [activity, setActivity] = useState3(null);
+  const [bgLabels, setBgLabels] = useState3(() => runningTaskLabels());
+  const [permissionModeState, setPermissionModeState] = useState3(permissionMode);
+  const [planApproval, setPlanApprovalState] = useState3(false);
+  const [pendingRewind, setPendingRewindState] = useState3(null);
+  const [picker, setPickerState] = useState3(null);
   const backendRef = useRef2(backend);
   const nextIdRef = useRef2(initialDisplay.length);
   const abortRef = useRef2(null);
@@ -2881,21 +3183,23 @@ function Repl({
   const prevModeRef = useRef2(null);
   const planApprovalRef = useRef2(false);
   const pendingRewindRef = useRef2(null);
+  const pickerRef = useRef2(null);
   const modelNameRef = useRef2(model);
   const sessionStoreRef = useRef2(sessionStore);
   const usageRef = useRef2(initialUsage ? { ...initialUsage } : emptyUsage());
   const turnChunksRef = useRef2(0);
   const messagesRef = useRef2(initialDisplay);
-  const [queueItems, setQueueItems] = useState2([]);
+  const [queueItems, setQueueItems] = useState3([]);
   const queueRef = useRef2(new PromptQueue());
-  const [pendingImages, setPendingImages] = useState2([]);
+  const [pendingImages, setPendingImages] = useState3([]);
   const pendingImagesRef = useRef2([]);
   const imageSeqRef = useRef2(1);
-  const [inputRefill, setInputRefill] = useState2();
+  const [inputRefill, setInputRefill] = useState3();
   const refillSeqRef = useRef2(0);
   const lastEscRef = useRef2(null);
-  const [gitBranch, setGitBranch] = useState2(null);
-  const [contextPercent, setContextPercent] = useState2(null);
+  const [gitBranch, setGitBranch] = useState3(null);
+  const [contextPercent, setContextPercent] = useState3(null);
+  const [initialHistory] = useState3(() => loadHistory());
   const budgetWarnedRef = useRef2(false);
   const budgetExceededRef = useRef2(false);
   const runStreamRef = useRef2(
@@ -2945,6 +3249,34 @@ function Repl({
     pendingRewindRef.current = p;
     setPendingRewindState(p);
   }, []);
+  const setPicker = useCallback((p) => {
+    pickerRef.current = p;
+    setPickerState(p);
+  }, []);
+  const showPicker = useCallback(
+    (title, options) => {
+      if (pickerRef.current) return Promise.resolve(null);
+      return new Promise((resolve) => {
+        setPicker({ title, options, resolve });
+      });
+    },
+    [setPicker]
+  );
+  const handlePickerSelect = useCallback(
+    (value) => {
+      const p = pickerRef.current;
+      if (!p) return;
+      setPicker(null);
+      p.resolve(value);
+    },
+    [setPicker]
+  );
+  const handlePickerCancel = useCallback(() => {
+    const p = pickerRef.current;
+    if (!p) return;
+    setPicker(null);
+    p.resolve(null);
+  }, [setPicker]);
   const stageClipboardImage = useCallback((img) => {
     pendingImagesRef.current = [
       ...pendingImagesRef.current,
@@ -3085,9 +3417,9 @@ function Repl({
     }
     exit();
   }, [exit, pushMessage]);
-  useInput5((_input, key) => {
+  useInput6((_input, key) => {
     if (key.escape) {
-      const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null;
+      const busy = abortRef.current !== null || pendingRef.current !== null || planApprovalRef.current || pendingRewindRef.current !== null || pickerRef.current !== null;
       if (busy) {
         lastEscRef.current = null;
         interrupt();
@@ -3104,7 +3436,7 @@ function Repl({
     }
     lastEscRef.current = null;
     if (key.shift && key.tab) {
-      if (abortRef.current || pendingRef.current || planApprovalRef.current || pendingRewindRef.current)
+      if (abortRef.current || pendingRef.current || planApprovalRef.current || pendingRewindRef.current || pickerRef.current)
         return;
       const current = config.permissionMode;
       const index = SESSION_MODE_CYCLE.indexOf(current);
@@ -3461,6 +3793,97 @@ ${lines.join("\n")}`;
         return formatSessionEntries(entries, { showCwd: all });
       },
       resumeSession: resume,
+      pickModel: async () => {
+        const models = listModels(config);
+        if (models.length === 0) return "No models configured.";
+        const options = models.map((m) => {
+          const parts = [`${m.provider}/${m.model}`, `${contextWindowTokens(config, m.name)} ctx`];
+          if (m.promptPrice !== void 0 && m.completionPrice !== void 0) {
+            parts.push(`$${m.promptPrice}/$${m.completionPrice} per 1M tokens`);
+          }
+          return {
+            value: m.name,
+            label: m.name,
+            description: parts.join(" \xB7 "),
+            hint: m.name === modelNameRef.current ? "current" : void 0
+          };
+        });
+        const picked = await showPicker("Select a model", options);
+        if (!picked || picked === modelNameRef.current) {
+          return `Model unchanged \u2014 still "${modelNameRef.current}".`;
+        }
+        return switchModel(picked);
+      },
+      pickPermissionMode: async () => {
+        const current = config.permissionMode;
+        const descriptions = {
+          ask: "reads allowed; writes/exec ask for confirmation",
+          auto: "everything allowed except hard-denied dangerous commands/paths",
+          readonly: "read-only; all writes/exec denied",
+          yolo: "allow everything, never ask (disables ALL safety checks)",
+          plan: "read-only research, then approve a plan before executing (this session only)"
+        };
+        const options = ["ask", "auto", "readonly", "yolo", "plan"].map((m) => ({
+          value: m,
+          label: m,
+          description: descriptions[m],
+          hint: m === current ? "current" : void 0
+        }));
+        const picked = await showPicker("Select a permission mode", options);
+        if (!picked || picked === current) {
+          return `Permission mode unchanged \u2014 still ${current}.`;
+        }
+        if (picked === "plan") return ctx.planMode();
+        return ctx.permissionMode(picked);
+      },
+      pickSession: async (all) => {
+        const entries = (await listSessionEntries(all ? void 0 : cwd)).slice(
+          0,
+          SESSION_PICKER_CAP
+        );
+        if (entries.length === 0) {
+          return all ? "No sessions found." : "No sessions found for this directory.";
+        }
+        const options = await Promise.all(
+          entries.map(async ({ meta, messageCount }) => {
+            const parts = [`${messageCount} messages \xB7 ${relativeTime(meta.updatedAt)}`];
+            const preview = await sessionPreview(meta.id);
+            if (preview) parts.push(preview);
+            if (all) parts.push(`[${meta.cwd}]`);
+            return {
+              value: meta.id,
+              label: meta.title || shortSessionId(meta.id),
+              description: parts.join(" \xB7 "),
+              hint: meta.id === sessionStoreRef.current?.id ? "current" : void 0
+            };
+          })
+        );
+        const picked = await showPicker(
+          all ? "Resume a session (all directories)" : "Resume a session",
+          options
+        );
+        if (!picked) return "Session unchanged \u2014 picker cancelled.";
+        return resume(picked);
+      },
+      forkSession: async () => {
+        const current = backendRef.current;
+        const store = sessionStoreRef.current;
+        if (!(current instanceof AgentLoop) || !store) {
+          return "Nothing to fork \u2014 no active session.";
+        }
+        const messages2 = await store.messages();
+        if (messages2.length === 0) {
+          return "Nothing to fork \u2014 the current session has no messages yet.";
+        }
+        const fork = await SessionStore.create(cwd, modelNameRef.current);
+        await fork.replaceMessages(messages2);
+        const oldMeta = await store.meta();
+        const title = `Fork of ${oldMeta.title || shortSessionId(oldMeta.id)}`;
+        await fork.setTitle(title);
+        current.setSessionStore(fork);
+        sessionStoreRef.current = fork;
+        return `Forked into new session ${fork.id} ("${title}") and switched to it. Checkpoints and rewind history do not carry over.`;
+      },
       newSession: async () => {
         const current = backendRef.current;
         if (!(current instanceof AgentLoop)) {
@@ -3664,7 +4087,8 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     applyMessages,
     redrawMessages,
     applySessionMode,
-    setPendingRewind
+    setPendingRewind,
+    showPicker
   ]);
   const runShellBang = useCallback(
     async (raw) => {
@@ -3704,6 +4128,7 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
   );
   const handleSubmit = useCallback(
     (text) => {
+      appendHistory(text);
       if (text.startsWith("!")) {
         if (abortRef.current) {
           queueRef.current.enqueue({ text, images: [] });
@@ -3718,7 +4143,11 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         if (!parsed) return;
         const command = registry.get(parsed.name);
         if (!command) {
-          pushMessage("system", `Unknown command: /${parsed.name} (try /help)`);
+          const suggestions = registry.complete(parsed.name).map((cmd) => cmd.name);
+          pushMessage(
+            "system",
+            `Unknown command: /${parsed.name} (try /help)${didYouMeanSuffix(suggestions)}`
+          );
           return;
         }
         void command.run(parsed.args, registry.ctx);
@@ -3744,7 +4173,11 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     [registry, pushMessage, runStream, runShellBang, config, clearPendingImages, sessionCostUsd]
   );
   const commandHints = useMemo(
-    () => registry.list().map((cmd) => ({ name: cmd.name, description: cmd.description })),
+    () => registry.list().map((cmd) => ({
+      name: cmd.name,
+      description: cmd.description,
+      usage: cmd.usage ?? `/${cmd.name}`
+    })),
     [registry]
   );
   useEffect2(() => {
@@ -3759,9 +4192,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
     }
   }, [cwd, config, isStreaming, epoch]);
   const sessionCost = sessionCostUsd();
-  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx8(MessageList, { messages }, `messages-${epoch}`),
-    (thinking || activity !== null) && /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(MessageList, { messages }, `messages-${epoch}`),
+    (thinking || activity !== null) && /* @__PURE__ */ jsx9(
       ThinkingIndicator,
       {
         reasoning: thinkingText,
@@ -3769,9 +4202,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         activity: activity ?? void 0
       }
     ),
-    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx8(Text10, { dimColor: true, children: thoughtSummary }),
-    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx8(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
-    pending && /* @__PURE__ */ jsx8(
+    !thinking && activity === null && thoughtSummary !== null && /* @__PURE__ */ jsx9(Text11, { dimColor: true, children: thoughtSummary }),
+    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx9(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
+    pending && /* @__PURE__ */ jsx9(
       PermissionPrompt,
       {
         request: pending.request,
@@ -3779,32 +4212,42 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         onDecision: handleDecision
       }
     ),
-    planApproval && /* @__PURE__ */ jsx8(ExitPlanPrompt, { onDecision: handlePlanDecision }),
-    pendingRewind && /* @__PURE__ */ jsx8(RewindConfirmPrompt, { summary: pendingRewind.summary, onDecision: handleRewindDecision }),
-    queueItems.map((item) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    planApproval && /* @__PURE__ */ jsx9(ExitPlanPrompt, { onDecision: handlePlanDecision }),
+    pendingRewind && /* @__PURE__ */ jsx9(RewindConfirmPrompt, { summary: pendingRewind.summary, onDecision: handleRewindDecision }),
+    picker && /* @__PURE__ */ jsx9(
+      SelectPrompt,
+      {
+        title: picker.title,
+        options: picker.options,
+        onSelect: handlePickerSelect,
+        onCancel: handlePickerCancel
+      }
+    ),
+    queueItems.map((item) => /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
       "queued: ",
       item.text.length > 80 ? `${item.text.slice(0, 80)}\u2026` : item.text
     ] }, item.id)),
-    pendingImages.map((staged) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+    pendingImages.map((staged) => /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
       "[image attached: ",
       staged.image.path,
       "]"
     ] }, staged.id)),
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx9(
       InputBox,
       {
         isStreaming,
-        disabled: pending !== null || planApproval || pendingRewind !== null,
+        disabled: pending !== null || planApproval || pendingRewind !== null || picker !== null,
         commands: commandHints,
         cwd,
         refill: inputRefill,
+        initialHistory,
         onSubmit: handleSubmit,
         onInterrupt: interrupt,
         onExit: handleExit,
         onPasteImage: handlePasteImage
       }
     ),
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx9(
       StatusBar,
       {
         cwd,
@@ -3824,7 +4267,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx9(
       Repl,
       {
         backend,
@@ -3841,7 +4284,7 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import { parse as parse2 } from "smol-toml";
 var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
@@ -3869,8 +4312,8 @@ function applyOverrides(config, overrides) {
   return merged;
 }
 function readTomlFileSync(filePath) {
-  if (!fs10.existsSync(filePath)) return {};
-  const content = fs10.readFileSync(filePath, "utf8");
+  if (!fs11.existsSync(filePath)) return {};
+  const content = fs11.readFileSync(filePath, "utf8");
   return parseTomlFile(content, filePath);
 }
 function loadConfigSync(cwd, overrides) {