@cryer/star-cli 0.2.1 → 0.3.0

package/dist/main.js

@@ -4,6 +4,7 @@ import {
   SKIP_DIRS,
   TodoStore,
   WORKING_DIFF_MAX_LINES,
+  appendUserMemory,
   bashTool,
   buildAllowRule,
   buildCommitPrompt,
@@ -12,6 +13,8 @@ import {
   collectWorkingDiff,
   compactMessages,
   createDefaultRegistry,
+  createIgnorePredicate,
+  defaultAgentTasks,
   defaultTaskManager,
   discoverSkills,
   estimateTokens,
@@ -27,6 +30,8 @@ import {
   isGitRepo,
   isSensitivePath,
   listSnapshots,
+  loadTodos,
+  parseTodoArgs,
   projectConfigPath,
   reconcileToolCalls,
   resolveShell,
@@ -34,8 +39,9 @@ import {
   sessionsDir,
   starHome,
   summarizeMessages,
-  undoTurnSnapshots
-} from "./chunk-MJ2O7NWI.js";
+  undoTurnSnapshots,
+  userMemoryPath
+} from "./chunk-DZWTIMJ2.js";
 
 // src/main.tsx
 import { Command } from "commander";
@@ -269,14 +275,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 Box11, Text as Text12, render, useApp, useInput as useInput6 } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef3, 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 +295,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 +341,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"]),
@@ -361,6 +371,20 @@ var ConfigSchema = z.object({
   // gracefully (some relays never send the terminal chunks). Applies once
   // streaming has started; the first part gets a longer, fixed allowance.
   streamIdleTimeoutSec: z.number().positive().default(20),
+  // Seconds to wait for the very first stream part before giving up; slow
+  // thinking-model relays can buffer for minutes before sending anything.
+  streamFirstChunkTimeoutSec: z.number().positive().default(300),
+  // Extra attempts per model request when a stream fails transiently
+  // (network error, 429/5xx, idle watchdog cutoff) or comes back empty, so a
+  // relay hiccup does not silently end a half-finished turn. 0 disables.
+  // Retries after a timeout/empty failure scale both stream timeouts up
+  // (attempt number ×, capped at 3x) since the relay is likely overloaded.
+  streamMaxRetries: z.number().int().min(0).default(3),
+  // How many times a turn may be nudged to continue when the model ends it
+  // with a text-only reply that announces pending work ("我将…", "I will…")
+  // instead of tool calls — a common premature-stop failure of weaker
+  // agentic models. Never fires in plan mode. 0 disables.
+  maxAutoContinues: z.number().int().min(0).default(2),
   contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
   // Optional per-session dollar budget; when set, the REPL stops the session
   // once the estimated cost for the session reaches this amount.
@@ -370,7 +394,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 +1277,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 +1519,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 +1562,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 +1582,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 +1831,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 +1854,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 +1883,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 +1923,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 +1931,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 +1977,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 +2394,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 +2441,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 +2461,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 +2473,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 +2488,7 @@ function InputBox({
   commands,
   cwd,
   refill,
+  initialHistory,
   onSubmit,
   onInterrupt,
   onExit,
@@ -2296,7 +2496,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([]);
@@ -2379,6 +2579,16 @@ function InputBox({
       return;
     }
     if (key.return) {
+      if (key.shift) {
+        edit(`${value.slice(0, cursor)}
+${value.slice(cursor)}`, cursor + 1);
+        return;
+      }
+      if (value[cursor - 1] === "\\") {
+        edit(`${value.slice(0, cursor - 1)}
+${value.slice(cursor)}`, cursor);
+        return;
+      }
       const text = value.trim();
       if (text.length > 0) {
         setHistory((prev) => [...prev, text]);
@@ -2389,6 +2599,11 @@ function InputBox({
       draftRef.current = "";
       return;
     }
+    if (input === "\n" || input === "\r" || /^\[13;\d+u$/.test(input)) {
+      edit(`${value.slice(0, cursor)}
+${value.slice(cursor)}`, cursor + 1);
+      return;
+    }
     if (key.tab) {
       if (key.shift) return;
       if (suggestionCount > 0) {
@@ -2465,25 +2680,25 @@ function InputBox({
       return;
     }
     if (input && !key.ctrl && !key.meta) {
-      edit(value.slice(0, cursor) + input + value.slice(cursor), cursor + input.length);
+      const text = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      edit(value.slice(0, cursor) + text + value.slice(cursor), cursor + text.length);
     }
   });
   const before = value.slice(0, cursor);
-  const at = value[cursor] ?? " ";
+  const at = value[cursor];
   const after = value.slice(cursor + 1);
+  const cursorChar = at === "\n" || at === void 0 ? " " : at;
+  const tail = (at === "\n" ? "\n" : "") + after;
+  const styled = `\x1B[36m> \x1B[39m${before}\x1B[7m${cursorChar}\x1B[27m${tail}`;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "> " }),
-      /* @__PURE__ */ jsx2(Text2, { children: before }),
-      /* @__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}` }),
+    /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsx2(Text2, { children: styled }) }),
+    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 +2806,77 @@ function RewindConfirmPrompt({ summary, onDecision }) {
   ] });
 }
 
+// src/cli/components/SelectPrompt.tsx
+import { Box as Box6, Text as Text7, useInput as useInput5 } from "ink";
+import { useRef as useRef2, 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);
+  const indexRef = useRef2(0);
+  const move = (delta) => {
+    indexRef.current = Math.max(0, Math.min(indexRef.current + delta, options.length - 1));
+    setIndex(indexRef.current);
+  };
+  useInput5((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const option = options[indexRef.current];
+      if (option) onSelect(option.value);
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      move(1);
+    } else if (key.upArrow || input === "k") {
+      move(-1);
+    }
+  });
+  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 +2898,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 +2935,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,19 +2966,44 @@ 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
     ] })
   ] });
 }
 
+// src/cli/components/TodoPanel.tsx
+import { Box as Box10, Text as Text11 } from "ink";
+import { jsx as jsx9, jsxs as jsxs11 } from "react/jsx-runtime";
+var SYMBOLS = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  done: "[x]"
+};
+function TodoPanel({ todos }) {
+  if (todos.length === 0) return null;
+  return /* @__PURE__ */ jsx9(Box10, { flexDirection: "column", children: todos.map((todo) => /* @__PURE__ */ jsxs11(
+    Text11,
+    {
+      dimColor: todo.status === "done",
+      color: todo.status === "in_progress" ? "cyan" : void 0,
+      children: [
+        SYMBOLS[todo.status],
+        " ",
+        todo.title
+      ]
+    },
+    todo.id
+  )) });
+}
+
 // src/cli/components/ToolCallCard.tsx
 function formatToolCard(card) {
   const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
@@ -2712,6 +3019,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,18 +3179,30 @@ async function checkForUpdate(currentVersion, fetcher = defaultFetcher2) {
 }
 
 // src/cli/repl.tsx
-import { jsx as jsx8, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs12 } 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 };
 }
 function runningTaskLabels() {
-  return defaultTaskManager.list().filter((t) => t.status === "running").map((t) => t.description ?? t.command);
+  const shells = defaultTaskManager.list().filter((t) => t.status === "running").map((t) => t.description ?? t.command);
+  const agents = defaultAgentTasks.list().filter((t) => t.status === "running").map((t) => t.description ?? t.id);
+  return [...shells, ...agents];
 }
 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,55 +3214,59 @@ 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 backendRef = useRef2(backend);
-  const nextIdRef = useRef2(initialDisplay.length);
-  const abortRef = useRef2(null);
-  const streamedRef = useRef2("");
-  const thinkingRef = useRef2(false);
-  const reasoningRef = useRef2("");
-  const tickerStopRef = useRef2(null);
-  const flushedRef = useRef2({ streamed: "", reasoning: "" });
-  const toolCardsRef = useRef2(/* @__PURE__ */ new Map());
-  const pendingRef = useRef2(null);
-  const alwaysAllowedRef = useRef2(/* @__PURE__ */ new Set());
-  const prevModeRef = useRef2(null);
-  const planApprovalRef = useRef2(false);
-  const pendingRewindRef = 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 queueRef = useRef2(new PromptQueue());
-  const [pendingImages, setPendingImages] = useState2([]);
-  const pendingImagesRef = useRef2([]);
-  const imageSeqRef = useRef2(1);
-  const [inputRefill, setInputRefill] = useState2();
-  const refillSeqRef = useRef2(0);
-  const lastEscRef = useRef2(null);
-  const [gitBranch, setGitBranch] = useState2(null);
-  const [contextPercent, setContextPercent] = useState2(null);
-  const budgetWarnedRef = useRef2(false);
-  const budgetExceededRef = useRef2(false);
-  const runStreamRef = useRef2(
+  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 [todos, setTodos] = useState3([]);
+  const [permissionModeState, setPermissionModeState] = useState3(permissionMode);
+  const [planApproval, setPlanApprovalState] = useState3(false);
+  const [pendingRewind, setPendingRewindState] = useState3(null);
+  const [picker, setPickerState] = useState3(null);
+  const backendRef = useRef3(backend);
+  const nextIdRef = useRef3(initialDisplay.length);
+  const abortRef = useRef3(null);
+  const streamedRef = useRef3("");
+  const thinkingRef = useRef3(false);
+  const reasoningRef = useRef3("");
+  const tickerStopRef = useRef3(null);
+  const flushedRef = useRef3({ streamed: "", reasoning: "" });
+  const toolCardsRef = useRef3(/* @__PURE__ */ new Map());
+  const pendingRef = useRef3(null);
+  const alwaysAllowedRef = useRef3(/* @__PURE__ */ new Set());
+  const prevModeRef = useRef3(null);
+  const planApprovalRef = useRef3(false);
+  const pendingRewindRef = useRef3(null);
+  const pickerRef = useRef3(null);
+  const modelNameRef = useRef3(model);
+  const sessionStoreRef = useRef3(sessionStore);
+  const usageRef = useRef3(initialUsage ? { ...initialUsage } : emptyUsage());
+  const turnChunksRef = useRef3(0);
+  const messagesRef = useRef3(initialDisplay);
+  const [queueItems, setQueueItems] = useState3([]);
+  const queueRef = useRef3(new PromptQueue());
+  const [pendingImages, setPendingImages] = useState3([]);
+  const pendingImagesRef = useRef3([]);
+  const imageSeqRef = useRef3(1);
+  const [inputRefill, setInputRefill] = useState3();
+  const refillSeqRef = useRef3(0);
+  const lastEscRef = useRef3(null);
+  const [gitBranch, setGitBranch] = useState3(null);
+  const [contextPercent, setContextPercent] = useState3(null);
+  const [initialHistory] = useState3(() => loadHistory());
+  const budgetWarnedRef = useRef3(false);
+  const budgetExceededRef = useRef3(false);
+  const runStreamRef = useRef3(
     null
   );
   const pushMessage = useCallback(
@@ -2945,6 +3313,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,
@@ -3019,6 +3415,10 @@ function Repl({
       if (message) pushMessage("system", message);
     });
   }, [pushMessage]);
+  useEffect2(() => {
+    loadTodos(cwd).then(setTodos).catch(() => {
+    });
+  }, [cwd]);
   useEffect2(() => {
     const onUpdate = (task) => {
       setBgLabels(runningTaskLabels());
@@ -3034,10 +3434,28 @@ function Repl({
         });
       }
     };
+    const onAgentUpdate = (task) => {
+      setBgLabels(runningTaskLabels());
+      const label = task.description ? `: ${task.description}` : "";
+      pushMessage(
+        "system",
+        task.status === "running" ? `Background subagent ${task.id} started${label}` : `Background subagent ${task.id} ${task.status}${label}`
+      );
+      if (task.status !== "running") {
+        notifyBell({
+          enabled: config.notifyBell,
+          thresholdSec: config.notifyBellThresholdSec,
+          noNotifyEnv: process.env.STAR_NO_NOTIFY === "1"
+        });
+      }
+    };
     defaultTaskManager.on("update", onUpdate);
+    defaultAgentTasks.on("update", onAgentUpdate);
     return () => {
       defaultTaskManager.off("update", onUpdate);
+      defaultAgentTasks.off("update", onAgentUpdate);
       defaultTaskManager.cleanup();
+      defaultAgentTasks.cleanup();
     };
   }, [pushMessage, config]);
   const interrupt = useCallback(() => {
@@ -3077,17 +3495,16 @@ function Repl({
   }, [pushMessage, redrawMessages]);
   const handleExit = useCallback(() => {
     const killed = defaultTaskManager.cleanup();
-    if (killed.length > 0) {
-      pushMessage(
-        "system",
-        `Stopped ${killed.length} background task(s): ${killed.map((t) => t.id).join(", ")}`
-      );
+    const killedAgents = defaultAgentTasks.cleanup();
+    const stopped = [...killed.map((t) => t.id), ...killedAgents.map((t) => t.id)];
+    if (stopped.length > 0) {
+      pushMessage("system", `Stopped ${stopped.length} background task(s): ${stopped.join(", ")}`);
     }
     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 +3521,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);
@@ -3266,6 +3683,10 @@ function Repl({
               name: event.name,
               argsSummary: summarizeArgs(event.args)
             });
+            if (event.name === "todo_write") {
+              const list = parseTodoArgs(event.args);
+              if (list) setTodos(list);
+            }
             setActivity(`running ${event.name}: ${summarizeArgs(event.args, 60)}`);
           } else if (event.type === "tool-result") {
             const card = toolCardsRef.current.get(event.id) ?? {
@@ -3298,6 +3719,13 @@ function Repl({
               sessionStoreRef.current?.addUsage(event.usage).catch(() => {
               });
             }
+          } else if (event.type === "retry") {
+            pushMessage(
+              "system",
+              `Request failed, retrying (${event.attempt}/${event.maxAttempts}): ${event.reason}`
+            );
+          } else if (event.type === "notice") {
+            pushMessage("system", event.message);
           } else if (event.type === "error") {
             pushMessage("system", `Error: ${formatStreamError(event.error)}`);
           }
@@ -3461,6 +3889,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)) {
@@ -3645,6 +4164,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         `maxSteps: ${config.maxSteps}`,
         `contextMaxTokens: ${config.contextMaxTokens}`,
         `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
+        `streamFirstChunkTimeoutSec: ${config.streamFirstChunkTimeoutSec}`,
+        `streamMaxRetries: ${config.streamMaxRetries}`,
+        `maxAutoContinues: ${config.maxAutoContinues}`,
         `permissions.allow (${config.permissions.allow.length}): ${config.permissions.allow.join(", ") || "(none)"}`,
         `hooks (${config.hooks.length}): ${config.hooks.map((h) => h.event).join(", ") || "(none)"}`
       ].join("\n")
@@ -3664,7 +4186,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 +4227,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 +4242,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 +4272,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 +4291,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__ */ jsxs12(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(MessageList, { messages }, `messages-${epoch}`),
+    (thinking || activity !== null) && /* @__PURE__ */ jsx10(
       ThinkingIndicator,
       {
         reasoning: thinkingText,
@@ -3769,9 +4301,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__ */ jsx10(Text12, { dimColor: true, children: thoughtSummary }),
+    streamingText !== null && (streamingText !== "" || turnChunksRef.current === 0) && /* @__PURE__ */ jsx10(StreamingMessage, { text: streamingText, continuation: turnChunksRef.current > 0 }),
+    pending && /* @__PURE__ */ jsx10(
       PermissionPrompt,
       {
         request: pending.request,
@@ -3779,32 +4311,43 @@ ${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__ */ jsx10(ExitPlanPrompt, { onDecision: handlePlanDecision }),
+    pendingRewind && /* @__PURE__ */ jsx10(RewindConfirmPrompt, { summary: pendingRewind.summary, onDecision: handleRewindDecision }),
+    picker && /* @__PURE__ */ jsx10(
+      SelectPrompt,
+      {
+        title: picker.title,
+        options: picker.options,
+        onSelect: handlePickerSelect,
+        onCancel: handlePickerCancel
+      }
+    ),
+    queueItems.map((item) => /* @__PURE__ */ jsxs12(Text12, { 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__ */ jsxs12(Text12, { dimColor: true, children: [
       "[image attached: ",
       staged.image.path,
       "]"
     ] }, staged.id)),
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx10(TodoPanel, { todos }),
+    /* @__PURE__ */ jsx10(
       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__ */ jsx10(
       StatusBar,
       {
         cwd,
@@ -3824,7 +4367,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx10(
       Repl,
       {
         backend,
@@ -3841,7 +4384,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 +4412,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) {
@@ -3884,7 +4427,13 @@ function loadConfigSync(cwd, overrides) {
 var SYSTEM_PROMPT = `You are Star CLI, an AI coding agent running in the user's terminal.
 You help with software engineering tasks: reading, writing and editing code, running shell commands, and managing todos.
 Be concise and direct. Use tools when they help accomplish the task.
-The working directory is the user's project root; never touch files outside it without explicit instruction.`;
+For any task with two or more steps, start by creating a todo list with todo_write and keep it updated as you progress; only mark an item completed after you have verified its result.
+The working directory is the user's project root; never touch files outside it without explicit instruction.
+For conversion, batch-processing, or other scriptable tasks, write a script file into the working directory and run it instead of pasting long inline code into the shell; once the script's output is verified, delete the script unless the user asked to keep it.
+When a tool call or command fails, read the error output, work out the cause, and try again with a corrected or alternative approach \u2014 never repeat an identical failing call without changing something.
+Never consider the task finished until you have verified the result yourself: run the tests, the build, or a check command that proves the output is correct, and if verification fails or reveals gaps, keep fixing until it passes.
+Do not end your turn while the task is still incomplete; keep going until it is done or you are genuinely blocked, and if you are blocked, state exactly what is missing.
+Never end a reply by announcing what you will do next \u2014 either do it now with tool calls, or do not mention it. Narrating future actions is not progress.`;
 async function createLoop(config, modelName, cwd, sessionStore) {
   const model = createModel(config, modelName);
   const registry = createDefaultRegistry();
@@ -3968,6 +4517,19 @@ async function printMode(loop, prompt, cwd, json, imagePaths) {
         case "finish":
           usage.add(event.usage);
           break;
+        case "retry":
+          if (!json)
+            process.stderr.write(
+              `
+[retry ${event.attempt}/${event.maxAttempts}] ${event.reason}
+`
+            );
+          break;
+        case "notice":
+          if (!json) process.stderr.write(`
+[notice] ${event.message}
+`);
+          break;
         case "error":
           if (!json) process.stderr.write(`
 [error] ${formatStreamError(event.error)}
@@ -4001,6 +4563,7 @@ async function printMode(loop, prompt, cwd, json, imagePaths) {
   }
   if (!json) process.stdout.write("\n");
   defaultTaskManager.cleanup();
+  defaultAgentTasks.cleanup();
   return exitCode;
 }
 var program = new Command();