@cryer/star-cli 0.2.0 → 0.2.2

package/dist/main.js

@@ -4,6 +4,7 @@ import {
   SKIP_DIRS,
   TodoStore,
   WORKING_DIFF_MAX_LINES,
+  appendUserMemory,
   bashTool,
   buildAllowRule,
   buildCommitPrompt,
@@ -12,25 +13,32 @@ import {
   collectWorkingDiff,
   compactMessages,
   createDefaultRegistry,
+  createIgnorePredicate,
   defaultTaskManager,
+  discoverSkills,
   estimateTokens,
   formatTaskFinished,
   formatTaskList,
   formatTaskStarted,
   formatTodos,
   getGitSummary,
+  globalConfigPath,
   hydrateSnapshots,
   isAllowedByRules,
   isDangerousCommand,
   isGitRepo,
   isSensitivePath,
   listSnapshots,
+  projectConfigPath,
   reconcileToolCalls,
   resolveShell,
   rewindToSnapshot,
+  sessionsDir,
+  starHome,
   summarizeMessages,
-  undoTurnSnapshots
-} from "./chunk-RLQXGX3N.js";
+  undoTurnSnapshots,
+  userMemoryPath
+} from "./chunk-GN236FD4.js";
 
 // src/main.tsx
 import { Command } from "commander";
@@ -264,32 +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 path3 from "path";
-import { parse, stringify } from "smol-toml";
-
-// src/config/paths.ts
-import os from "os";
 import path2 from "path";
-function starHome() {
-  return process.env.STAR_HOME ?? path2.join(os.homedir(), ".star-cli");
-}
-function globalConfigPath() {
-  return path2.join(starHome(), "config.toml");
-}
-function sessionsDir() {
-  return path2.join(starHome(), "sessions");
-}
-function projectConfigPath(cwd) {
-  return path2.join(cwd, ".star", "config.toml");
-}
-
-// src/config/save.ts
+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 {
@@ -299,11 +292,11 @@ 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(path3.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
   return true;
 }
@@ -317,10 +310,80 @@ async function savePermissionMode(mode) {
     if (error.code !== "ENOENT") throw error;
   }
   raw.permissionMode = mode;
-  await fs.promises.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(filePath), { recursive: true });
   await fs.promises.writeFile(filePath, stringify(raw), "utf8");
 }
 
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z.string(),
+  apiKeyEnv: z.string().optional(),
+  apiKey: z.string().optional(),
+  headers: z.record(z.string()).optional()
+});
+var ModelConfigSchema = z.object({
+  name: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  maxTokens: z.number().int().positive().optional(),
+  // Per-model context window; overrides the top-level contextMaxTokens for
+  // compaction and the status bar when set.
+  contextMaxTokens: z.number().int().positive().optional(),
+  // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
+  // the model is treated as unpriced.
+  promptPrice: z.number().nonnegative().optional(),
+  completionPrice: z.number().nonnegative().optional()
+});
+var PermissionsConfigSchema = z.object({
+  allow: z.array(z.string()).default([]),
+  deny: z.array(z.string()).default([])
+});
+var HookConfigSchema = z.object({
+  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
+  matcher: z.string().refine(
+    (pattern) => {
+      try {
+        new RegExp(pattern);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "invalid regular expression" }
+  ).optional(),
+  command: z.string().min(1),
+  timeoutSec: z.number().positive().default(30)
+});
+var ConfigSchema = z.object({
+  defaultModel: z.string().default(""),
+  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
+  providers: z.array(ProviderConfigSchema).default([]),
+  models: z.array(ModelConfigSchema).default([]),
+  maxSteps: z.number().int().positive().default(50),
+  contextMaxTokens: z.number().int().positive().default(1e5),
+  // Seconds without any stream part before a stalled response is ended
+  // 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),
+  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.
+  sessionBudgetUsd: z.number().positive().optional(),
+  // Terminal bell (REPL only): ring when a turn takes longer than
+  // notifyBellThresholdSec, and when a background task finishes.
+  // STAR_NO_NOTIFY=1 disables without touching the config.
+  notifyBell: z.boolean().default(true),
+  notifyBellThresholdSec: z.number().positive().default(10),
+  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
+  hooks: z.array(HookConfigSchema).default([])
+});
+function contextWindowTokens(config, modelName) {
+  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
+}
+
 // src/llm/provider.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -385,15 +448,15 @@ function createModel(config, modelName) {
 
 // src/session/checkpoints.ts
 import fs2 from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 function checkpointsDir(sessionDir) {
-  return path4.join(sessionDir, "checkpoints");
+  return path3.join(sessionDir, "checkpoints");
 }
 function indexPath(sessionDir) {
-  return path4.join(checkpointsDir(sessionDir), "index.json");
+  return path3.join(checkpointsDir(sessionDir), "index.json");
 }
 function checkpointContentPath(sessionDir, id) {
-  return path4.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+  return path3.join(checkpointsDir(sessionDir), `${id}.snapshot`);
 }
 async function listCheckpointRecords(sessionDir) {
   let raw;
@@ -441,11 +504,11 @@ async function loadSessionSnapshots(sessionDir) {
 
 // src/session/clear.ts
 import fs4 from "fs/promises";
-import path6 from "path";
+import path5 from "path";
 
 // src/session/store.ts
 import fs3 from "fs/promises";
-import path5 from "path";
+import path4 from "path";
 function generateId(now) {
   const pad = (n) => String(n).padStart(2, "0");
   const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
@@ -467,13 +530,13 @@ var SessionStore = class _SessionStore {
   initialized = false;
   constructor(id) {
     this.id = id;
-    this.dir = path5.join(sessionsDir(), id);
+    this.dir = path4.join(sessionsDir(), id);
   }
   metaPath() {
-    return path5.join(this.dir, "meta.json");
+    return path4.join(this.dir, "meta.json");
   }
   messagesPath() {
-    return path5.join(this.dir, "messages.jsonl");
+    return path4.join(this.dir, "messages.jsonl");
   }
   static async create(cwd, model) {
     const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
@@ -507,7 +570,7 @@ var SessionStore = class _SessionStore {
     const metas = [];
     for (const entry of entries) {
       try {
-        const raw = await fs3.readFile(path5.join(sessionsDir(), entry, "meta.json"), "utf8");
+        const raw = await fs3.readFile(path4.join(sessionsDir(), entry, "meta.json"), "utf8");
         const meta = JSON.parse(raw);
         if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
       } catch {
@@ -634,7 +697,7 @@ async function clearSessions(cwd, excludeId) {
     let removed2 = 0;
     for (const meta of metas) {
       if (meta.id === excludeId) continue;
-      await fs4.rm(path6.join(sessionsDir(), meta.id), { recursive: true, force: true });
+      await fs4.rm(path5.join(sessionsDir(), meta.id), { recursive: true, force: true });
       removed2 += 1;
     }
     return removed2;
@@ -648,7 +711,7 @@ async function clearSessions(cwd, excludeId) {
   let removed = 0;
   for (const entry of entries) {
     if (entry === excludeId) continue;
-    await fs4.rm(path6.join(sessionsDir(), entry), { recursive: true, force: true });
+    await fs4.rm(path5.join(sessionsDir(), entry), { recursive: true, force: true });
     removed += 1;
   }
   return removed;
@@ -656,11 +719,11 @@ async function clearSessions(cwd, excludeId) {
 
 // src/session/list.ts
 import fs5 from "fs/promises";
-import path7 from "path";
+import path6 from "path";
 async function countMessages(id) {
   let raw;
   try {
-    raw = await fs5.readFile(path7.join(sessionsDir(), id, "messages.jsonl"), "utf8");
+    raw = await fs5.readFile(path6.join(sessionsDir(), id, "messages.jsonl"), "utf8");
   } catch {
     return 0;
   }
@@ -744,10 +807,19 @@ function computeCostUsd(usage, model) {
 }
 function estimateCost(usage, modelName, model) {
   const cost = computeCostUsd(usage, model);
-  if (cost === null || model === void 0) {
+  if (cost === null) {
+    if (model !== void 0) {
+      const missing = [
+        model.promptPrice === void 0 ? "promptPrice" : null,
+        model.completionPrice === void 0 ? "completionPrice" : null
+      ].filter((f) => f !== null);
+      if (missing.length === 1) {
+        return `Estimated cost: unknown (${model.name} is missing ${missing[0]} \u2014 both prices are needed)`;
+      }
+    }
     return `Estimated cost: unknown (no price configured for ${modelName})`;
   }
-  return `Estimated cost: $${formatDollars(cost)} (${model.name} @ $${model.promptPrice}/M prompt, $${model.completionPrice}/M completion)`;
+  return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion)`;
 }
 
 // src/session/usage.ts
@@ -909,11 +981,11 @@ function formatUsageDashboard(stats, models, options = {}) {
 
 // src/version.ts
 import fs6 from "fs";
-import path8 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 function readPackageVersion() {
   try {
-    const pkgPath = path8.join(path8.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = path7.join(path7.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
     if (typeof pkg === "object" && pkg !== null) {
       const version = pkg.version;
@@ -938,8 +1010,8 @@ function budgetState(costUsd, budgetUsd) {
 import { execFile } from "child_process";
 import { randomUUID } from "crypto";
 import { readFile as readFile2, unlink } from "fs/promises";
-import os2 from "os";
-import path9 from "path";
+import os from "os";
+import path8 from "path";
 import { promisify } from "util";
 var CLIPBOARD_TIMEOUT_MS = 5e3;
 var MAX_CLIPBOARD_IMAGE_BYTES = 10 * 1024 * 1024;
@@ -1013,7 +1085,7 @@ async function commandExists(command) {
   }
 }
 async function readClipboardImage() {
-  const tempFile = path9.join(os2.tmpdir(), `star-clipboard-${randomUUID()}.png`);
+  const tempFile = path8.join(os.tmpdir(), `star-clipboard-${randomUUID()}.png`);
   const hasPngpaste = process.platform === "darwin" ? await commandExists("pngpaste") : false;
   const plan = clipboardImagePlan(process.platform, tempFile, hasPngpaste);
   if (!plan) return null;
@@ -1059,7 +1131,7 @@ async function copyText(text) {
 
 // src/cli/commands/actions.ts
 import fs7 from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 var MIN_COMPACT_MESSAGES = 4;
 async function compactSession(opts) {
   const { backend, sessionStore, config, model } = opts;
@@ -1120,9 +1192,9 @@ async function exportSession(opts) {
     return "Nothing to export: the session has no messages.";
   }
   const sessionId = sessionStore?.id ?? `unknown-${Date.now()}`;
-  const target = arg ? path10.resolve(cwd, arg) : path10.resolve(cwd, `star-session-${sessionId}.md`);
+  const target = arg ? path9.resolve(cwd, arg) : path9.resolve(cwd, `star-session-${sessionId}.md`);
   const existed = await fileExists(target);
-  await fs7.mkdir(path10.dirname(target), { recursive: true });
+  await fs7.mkdir(path9.dirname(target), { recursive: true });
   await fs7.writeFile(target, renderSessionMarkdown(sessionId, messages));
   return existed ? `Exported ${messages.length} messages to ${target} (overwrote existing file).` : `Exported ${messages.length} messages to ${target}.`;
 }
@@ -1188,9 +1260,64 @@ 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 path11 from "path";
+import path10 from "path";
 var CONTEXT_LINES = 2;
 var MAX_HUNK_LINES = 15;
 var MAX_TOTAL_LINES = 12;
@@ -1351,7 +1478,7 @@ async function generateDiffPreview(toolName, args, cwd) {
   if (toolName !== "edit_file" && toolName !== "write_file") return null;
   const filePath = getStringArg(args, "path");
   if (filePath === void 0) return null;
-  const absolute = path11.resolve(cwd, filePath);
+  const absolute = path10.resolve(cwd, filePath);
   let existing;
   try {
     existing = await readFile3(absolute, "utf8");
@@ -1375,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.");
@@ -1408,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") {
@@ -1427,157 +1565,260 @@ ${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) {
+        ctx.addSystemMessage(
+          "No skills found. Add a SKILL.md under .star/skills/<name>/ (project) or ~/.star-cli/skills/<name>/ (user)."
+        );
+        return;
+      }
+      const lines = skills.map((s) => `${s.name} [${s.scope}] \u2014 ${s.description}`);
+      ctx.addSystemMessage(`Available skills:
+${lines.join("\n")}`);
+    }
+  });
+  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)) {
@@ -1596,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") {
@@ -1624,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)) {
@@ -1663,15 +1906,15 @@ ${result.diff}${note ? `
 }
 
 // src/cli/commands/custom.ts
-import { readFileSync, readdirSync } from "fs";
-import path12 from "path";
+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*$/;
 var DEFAULT_DESCRIPTION = "Custom prompt command";
 function parseCommandFile(filePath, name) {
   let raw;
   try {
-    raw = readFileSync(filePath, "utf8");
+    raw = readFileSync2(filePath, "utf8");
   } catch {
     return null;
   }
@@ -1699,14 +1942,14 @@ function scanDir(dir, into) {
     if (!entry.endsWith(".md")) continue;
     const name = entry.slice(0, -".md".length);
     if (!NAME_PATTERN.test(name)) continue;
-    const parsed = parseCommandFile(path12.join(dir, entry), name);
+    const parsed = parseCommandFile(path11.join(dir, entry), name);
     if (parsed) into.set(name, parsed);
   }
 }
 function loadCustomCommands(cwd, home = starHome()) {
   const byName = /* @__PURE__ */ new Map();
-  scanDir(path12.join(home, "commands"), byName);
-  scanDir(path12.join(cwd, ".star", "commands"), byName);
+  scanDir(path11.join(home, "commands"), byName);
+  scanDir(path11.join(cwd, ".star", "commands"), byName);
   return [...byName.values()];
 }
 function registerCustomCommands(registry, cwd, home) {
@@ -1717,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) {
@@ -1732,7 +1976,7 @@ function registerCustomCommands(registry, cwd, home) {
 
 // src/cli/commands/doctor.ts
 import fs8 from "fs/promises";
-import path13 from "path";
+import path12 from "path";
 var MIN_NODE_MAJOR = 20;
 var REGISTRY_URL = "https://registry.npmjs.org/";
 var REGISTRY_TIMEOUT_MS = 5e3;
@@ -1784,7 +2028,7 @@ async function runDoctor(opts) {
       detail: `${spec.label} (${spec.shell})`
     });
   }
-  const configPath = path13.join(home, "config.toml");
+  const configPath = path12.join(home, "config.toml");
   const configExists = await pathExists(configPath);
   checks.push({
     name: "STAR_HOME / config",
@@ -1821,12 +2065,12 @@ async function runDoctor(opts) {
       });
     }
   }
-  const sessions = path13.join(home, "sessions");
+  const sessions = path12.join(home, "sessions");
   let writable = false;
   let writeError = "";
   try {
     await fs8.mkdir(sessions, { recursive: true });
-    const probe = path13.join(sessions, `.doctor-probe-${process.pid}`);
+    const probe = path12.join(sessions, `.doctor-probe-${process.pid}`);
     await fs8.writeFile(probe, "ok");
     await fs8.unlink(probe);
     writable = true;
@@ -1864,7 +2108,7 @@ function formatDoctorReport(report) {
 
 // src/cli/commands/init-project.ts
 import fs9 from "fs/promises";
-import path14 from "path";
+import path13 from "path";
 import { generateText } from "ai";
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", "coverage"]);
 var MAX_ENTRIES = 20;
@@ -1879,7 +2123,7 @@ async function fileExists2(target) {
 }
 async function readPackageJson(cwd) {
   try {
-    const raw = await fs9.readFile(path14.join(cwd, "package.json"), "utf8");
+    const raw = await fs9.readFile(path13.join(cwd, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return null;
     return parsed;
@@ -1896,10 +2140,10 @@ function stringRecord(value) {
   return out;
 }
 async function detectPackageManager(cwd) {
-  if (await fileExists2(path14.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (await fileExists2(path14.join(cwd, "yarn.lock"))) return "yarn";
-  if (await fileExists2(path14.join(cwd, "package-lock.json"))) return "npm";
-  if (await fileExists2(path14.join(cwd, "bun.lockb"))) return "bun";
+  if (await fileExists2(path13.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists2(path13.join(cwd, "yarn.lock"))) return "yarn";
+  if (await fileExists2(path13.join(cwd, "package-lock.json"))) return "npm";
+  if (await fileExists2(path13.join(cwd, "bun.lockb"))) return "bun";
   return null;
 }
 function inferCommands(pm, scripts) {
@@ -1933,7 +2177,7 @@ async function listEntries(cwd) {
 async function readReadmeHead(cwd) {
   for (const name of ["README.md", "readme.md", "README"]) {
     try {
-      const raw = await fs9.readFile(path14.join(cwd, name), "utf8");
+      const raw = await fs9.readFile(path13.join(cwd, name), "utf8");
       return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, README_HEAD_LINES);
     } catch {
     }
@@ -1946,14 +2190,14 @@ async function scanProject(cwd) {
   const scripts = stringRecord(pkg?.scripts);
   return {
     name: typeof pkg?.name === "string" ? pkg.name : null,
-    dirName: path14.basename(cwd),
+    dirName: path13.basename(cwd),
     packageManager,
     scripts,
     dependencies: Object.keys(stringRecord(pkg?.dependencies)),
     devDependencies: Object.keys(stringRecord(pkg?.devDependencies)),
     commands: inferCommands(packageManager, scripts),
-    hasTsconfig: await fileExists2(path14.join(cwd, "tsconfig.json")),
-    isGitRepo: await fileExists2(path14.join(cwd, ".git")),
+    hasTsconfig: await fileExists2(path13.join(cwd, "tsconfig.json")),
+    isGitRepo: await fileExists2(path13.join(cwd, ".git")),
     readmeHead: await readReadmeHead(cwd),
     entries: await listEntries(cwd)
   };
@@ -2020,7 +2264,7 @@ Write the AGENTS.md.`
 }
 async function initProject(opts) {
   const { cwd, args, model } = opts;
-  const target = path14.join(cwd, "AGENTS.md");
+  const target = path13.join(cwd, "AGENTS.md");
   const force = args.split(/\s+/).includes("force");
   if (!force && await fileExists2(target)) {
     return {
@@ -2096,7 +2340,7 @@ function parseSlashCommand(input) {
 }
 
 // src/cli/commands/rewind.ts
-import path15 from "path";
+import path14 from "path";
 function planRewind(snapshots, id) {
   const target = snapshots.find((snapshot) => snapshot.id === id);
   if (!target) return null;
@@ -2110,7 +2354,7 @@ function planRewind(snapshots, id) {
   return { target, affected, messageIndex };
 }
 function displayPath(filePath, cwd) {
-  const relative = path15.relative(cwd, filePath);
+  const relative = path14.relative(cwd, filePath);
   return relative !== "" && !relative.startsWith("..") ? relative : filePath;
 }
 function formatTime(timestamp) {
@@ -2133,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";
@@ -2153,18 +2424,9 @@ 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 path16 from "path";
+import path15 from "path";
 var MAX_SCAN_ENTRIES = 2e3;
 function extractAtToken(value, cursor) {
   const before = value.slice(0, cursor);
@@ -2179,9 +2441,10 @@ async function suggestPaths(token, cwd, maxScanEntries = MAX_SCAN_ENTRIES, maxSu
   const dirPart = slash >= 0 ? normalized.slice(0, slash + 1) : "";
   const basePrefix = slash >= 0 ? normalized.slice(slash + 1) : normalized;
   if (dirPart.split("/").some((segment) => SKIP_DIRS.has(segment))) return [];
-  const dirAbs = path16.resolve(cwd, dirPart === "" ? "." : dirPart);
+  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;
@@ -2193,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));
@@ -2207,6 +2471,7 @@ function InputBox({
   commands,
   cwd,
   refill,
+  initialHistory,
   onSubmit,
   onInterrupt,
   onExit,
@@ -2214,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([]);
@@ -2396,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}` }),
@@ -2509,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) {
@@ -2534,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
     ] })
@@ -2571,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;
@@ -2602,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
     ] })
@@ -2630,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) {
@@ -2745,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 };
@@ -2757,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,
@@ -2768,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);
@@ -2799,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(
@@ -2863,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,
@@ -3003,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();
@@ -3022,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);
@@ -3060,7 +3474,8 @@ function Repl({
           registry: createDefaultRegistry(),
           config,
           cwd,
-          sessionStore: sessionStoreRef.current
+          sessionStore: sessionStoreRef.current,
+          contextMaxTokens: contextWindowTokens(config, name)
         });
         const prev = backendRef.current;
         if (prev instanceof AgentLoop) {
@@ -3378,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)) {
@@ -3581,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) => {
@@ -3621,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: [] });
@@ -3635,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);
@@ -3661,24 +4173,28 @@ ${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(() => {
     setGitBranch(getGitSummary(cwd)?.branch ?? null);
     const current = backendRef.current;
     if (current instanceof AgentLoop) {
-      setContextPercent(
-        Math.round(estimateTokens([...current.getMessages()]) / config.contextMaxTokens * 100)
-      );
+      const window_ = contextWindowTokens(config, modelNameRef.current);
+      const pct = estimateTokens([...current.getMessages()]) / window_ * 100;
+      setContextPercent(pct < 10 ? Math.round(pct * 10) / 10 : Math.round(pct));
     } else {
       setContextPercent(null);
     }
   }, [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,
@@ -3686,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,
@@ -3696,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,
@@ -3741,7 +4267,7 @@ function renderRepl(backend, opts) {
     defaultTaskManager.cleanup();
   });
   return render(
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx9(
       Repl,
       {
         backend,
@@ -3758,71 +4284,8 @@ function renderRepl(backend, opts) {
 }
 
 // src/config/loader.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import { parse as parse2 } from "smol-toml";
-
-// src/config/schema.ts
-import { z } from "zod";
-var ProviderConfigSchema = z.object({
-  name: z.string(),
-  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z.string(),
-  apiKeyEnv: z.string().optional(),
-  apiKey: z.string().optional(),
-  headers: z.record(z.string()).optional()
-});
-var ModelConfigSchema = z.object({
-  name: z.string(),
-  provider: z.string(),
-  model: z.string(),
-  maxTokens: z.number().int().positive().optional(),
-  promptPrice: z.number().nonnegative().optional(),
-  completionPrice: z.number().nonnegative().optional()
-});
-var PermissionsConfigSchema = z.object({
-  allow: z.array(z.string()).default([])
-});
-var HookConfigSchema = z.object({
-  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
-  matcher: z.string().refine(
-    (pattern) => {
-      try {
-        new RegExp(pattern);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    { message: "invalid regular expression" }
-  ).optional(),
-  command: z.string().min(1),
-  timeoutSec: z.number().positive().default(30)
-});
-var ConfigSchema = z.object({
-  defaultModel: z.string().default(""),
-  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
-  providers: z.array(ProviderConfigSchema).default([]),
-  models: z.array(ModelConfigSchema).default([]),
-  maxSteps: z.number().int().positive().default(50),
-  contextMaxTokens: z.number().int().positive().default(1e5),
-  // Seconds without any stream part before a stalled response is ended
-  // 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),
-  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.
-  sessionBudgetUsd: z.number().positive().optional(),
-  // Terminal bell (REPL only): ring when a turn takes longer than
-  // notifyBellThresholdSec, and when a background task finishes.
-  // STAR_NO_NOTIFY=1 disables without touching the config.
-  notifyBell: z.boolean().default(true),
-  notifyBellThresholdSec: z.number().positive().default(10),
-  permissions: PermissionsConfigSchema.default({ allow: [] }),
-  hooks: z.array(HookConfigSchema).default([])
-});
-
-// src/config/loader.ts
 var PartialConfigSchema = ConfigSchema.partial();
 function parseTomlFile(content, filePath) {
   let raw;
@@ -3849,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) {
@@ -3874,7 +4337,8 @@ async function createLoop(config, modelName, cwd, sessionStore) {
     config,
     cwd,
     system: SYSTEM_PROMPT,
-    sessionStore
+    sessionStore,
+    contextMaxTokens: contextWindowTokens(config, modelName)
   });
 }
 async function printMode(loop, prompt, cwd, json, imagePaths) {