@cryer/star-cli 0.2.1 → 0.3.0

package/dist/{chunk-MJ2O7NWI.js → chunk-DZWTIMJ2.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/agent/loop.ts
-import { tool as aiTool } from "ai";
+import { tool as aiTool, generateText as generateText3 } from "ai";
 
 // src/context/compaction.ts
 import { generateText } from "ai";
@@ -433,6 +433,12 @@ function matchAllowRule(rule, req) {
   return target !== void 0 && globMatch(rule.pattern, target);
 }
 function isAllowedByRules(rules, req) {
+  return matchesAnyRule(rules, req);
+}
+function isDeniedByRules(rules, req) {
+  return matchesAnyRule(rules, req);
+}
+function matchesAnyRule(rules, req) {
   return rules.some((raw) => {
     const rule = parseAllowRule(raw);
     return rule !== null && matchAllowRule(rule, req);
@@ -484,7 +490,7 @@ function isSensitivePath(p) {
   }
   return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
 }
-function checkPermission(mode, req, ctx, allowRules = []) {
+function checkPermission(mode, req, ctx, allowRules = [], denyRules = []) {
   if (mode === "yolo") {
     return "allow";
   }
@@ -504,6 +510,9 @@ function checkPermission(mode, req, ctx, allowRules = []) {
       return "deny";
     }
   }
+  if (isDeniedByRules(denyRules, req)) {
+    return "deny";
+  }
   if (mode === "auto") {
     return "allow";
   }
@@ -693,14 +702,211 @@ async function rewindToSnapshot(id) {
   return { reverted, messageIndex };
 }
 
+// src/tools/todo.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+import { z } from "zod";
+var todoItemSchema = z.object({
+  id: z.number().int(),
+  title: z.string(),
+  status: z.enum(["pending", "in_progress", "done"])
+});
+var writeSchema = z.object({
+  todos: z.array(todoItemSchema).describe("The full todo list, replacing the current one")
+});
+var readSchema = z.object({});
+function fileFor(cwd) {
+  return path3.join(cwd, ".star", "todos.json");
+}
+var TodoStore = class {
+  items = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.items.values()];
+  }
+  replace(items) {
+    this.items.clear();
+    for (const item of items) {
+      this.items.set(item.id, item);
+    }
+  }
+  async load(cwd) {
+    let raw;
+    try {
+      raw = await readFile2(fileFor(cwd), "utf8");
+    } catch {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
+      }
+    } catch {
+    }
+  }
+  async save(cwd) {
+    await mkdir2(path3.join(cwd, ".star"), { recursive: true });
+    await writeFile2(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
+`);
+  }
+};
+var SYMBOLS = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  done: "[x]"
+};
+function formatTodos(items) {
+  if (items.length === 0) {
+    return "No todos.";
+  }
+  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
+  const width = Math.max(...lines.map((l) => l.length));
+  return lines.map((line, i) => {
+    const status = items[i]?.status;
+    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
+  }).join("\n");
+}
+var defaultStore = new TodoStore();
+function parseTodoArgs(args) {
+  const parsed = writeSchema.safeParse(args);
+  return parsed.success ? parsed.data.todos : null;
+}
+function pendingTodoTitles(args) {
+  return (parseTodoArgs(args) ?? []).filter((t) => t.status !== "done").map((t) => t.title);
+}
+async function loadTodos(cwd) {
+  await defaultStore.load(cwd);
+  return defaultStore.list();
+}
+function createTodoTools(store = defaultStore) {
+  const todoWrite = {
+    name: "todo_write",
+    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
+    permission: "read",
+    parameters: writeSchema,
+    async execute(args, ctx) {
+      const parsed = writeSchema.safeParse(args);
+      if (!parsed.success) {
+        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
+      }
+      await store.load(ctx.cwd);
+      store.replace(parsed.data.todos);
+      await store.save(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  const todoRead = {
+    name: "todo_read",
+    description: "Read the current todo list.",
+    permission: "read",
+    parameters: readSchema,
+    async execute(_args, ctx) {
+      await store.load(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  return [todoWrite, todoRead];
+}
+
+// src/agent/agent-tasks.ts
+import { EventEmitter } from "events";
+var AgentTaskManager = class extends EventEmitter {
+  records = /* @__PURE__ */ new Map();
+  counter = 0;
+  start(run, meta) {
+    const id = `agent-${++this.counter}`;
+    const rec = {
+      id,
+      prompt: meta.prompt,
+      description: meta.description,
+      status: "running",
+      startedAt: Date.now(),
+      result: "",
+      controller: new AbortController(),
+      notified: false
+    };
+    this.records.set(id, rec);
+    void run(rec.controller.signal).then((result) => this.finish(rec, "completed", result)).catch(
+      (error) => this.finish(rec, "failed", error instanceof Error ? error.message : String(error))
+    );
+    this.emitUpdate(rec);
+    return this.snapshot(rec);
+  }
+  get(id) {
+    const rec = this.records.get(id);
+    return rec ? this.snapshot(rec) : void 0;
+  }
+  list() {
+    return [...this.records.values()].map((rec) => this.snapshot(rec));
+  }
+  runningCount() {
+    let count = 0;
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") count += 1;
+    }
+    return count;
+  }
+  kill(id) {
+    const rec = this.records.get(id);
+    if (!rec || rec.status !== "running") return void 0;
+    rec.controller.abort();
+    this.finish(rec, "stopped", rec.result || "Stopped by user.");
+    return this.snapshot(rec);
+  }
+  cleanup() {
+    const killed = [];
+    for (const rec of this.records.values()) {
+      if (rec.status === "running") {
+        rec.controller.abort();
+        this.finish(rec, "stopped", rec.result || "Stopped on shutdown.");
+        killed.push(this.snapshot(rec));
+      }
+    }
+    return killed;
+  }
+  // Finished tasks whose result has not yet been handed to the parent loop.
+  drainNotifications() {
+    const drained = [];
+    for (const rec of this.records.values()) {
+      if (rec.status !== "running" && !rec.notified) {
+        rec.notified = true;
+        drained.push(this.snapshot(rec));
+      }
+    }
+    return drained;
+  }
+  finish(rec, status, result) {
+    if (rec.status !== "running") return;
+    rec.status = status;
+    rec.result = result;
+    rec.endedAt = Date.now();
+    this.emitUpdate(rec);
+  }
+  emitUpdate(rec) {
+    this.emit("update", this.snapshot(rec));
+  }
+  snapshot(rec) {
+    return {
+      id: rec.id,
+      prompt: rec.prompt,
+      description: rec.description,
+      status: rec.status,
+      startedAt: rec.startedAt,
+      endedAt: rec.endedAt,
+      result: rec.result
+    };
+  }
+};
+var defaultAgentTasks = new AgentTaskManager();
+
 // src/agent/project-memory.ts
 import { readFileSync, statSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 var PROJECT_MEMORY_FILE = "AGENTS.md";
 var PROJECT_MEMORY_MAX_CHARS = 32 * 1024;
 var cache = /* @__PURE__ */ new Map();
 function readProjectMemory(cwd) {
-  const file = path3.join(cwd, PROJECT_MEMORY_FILE);
+  const file = path4.join(cwd, PROJECT_MEMORY_FILE);
   let mtimeMs;
   try {
     mtimeMs = statSync(file).mtimeMs;
@@ -730,23 +936,26 @@ ${body}`;
 
 // src/agent/skills.ts
 import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
-import path5 from "path";
-import { z } from "zod";
+import path6 from "path";
+import { z as z2 } from "zod";
 
 // src/config/paths.ts
 import os from "os";
-import path4 from "path";
+import path5 from "path";
 function starHome() {
-  return process.env.STAR_HOME ?? path4.join(os.homedir(), ".star-cli");
+  return process.env.STAR_HOME ?? path5.join(os.homedir(), ".star-cli");
 }
 function globalConfigPath() {
-  return path4.join(starHome(), "config.toml");
+  return path5.join(starHome(), "config.toml");
 }
 function sessionsDir() {
-  return path4.join(starHome(), "sessions");
+  return path5.join(starHome(), "sessions");
+}
+function userMemoryPath() {
+  return path5.join(starHome(), "MEMORY.md");
 }
 function projectConfigPath(cwd) {
-  return path4.join(cwd, ".star", "config.toml");
+  return path5.join(cwd, ".star", "config.toml");
 }
 
 // src/agent/skills.ts
@@ -779,7 +988,7 @@ function parseSkillFile(filePath, dirName, scope) {
     const name = parsed?.meta.name || dirName;
     const description = parsed?.meta.description;
     if (parsed && NAME_PATTERN.test(name) && description) {
-      skill = { name, description, filePath, dir: path5.dirname(filePath), scope };
+      skill = { name, description, filePath, dir: path6.dirname(filePath), scope };
     }
   } catch {
     skill = null;
@@ -796,14 +1005,14 @@ function scanDir(base, scope, into) {
   }
   for (const entry of entries.sort()) {
     if (!NAME_PATTERN.test(entry)) continue;
-    const parsed = parseSkillFile(path5.join(base, entry, SKILL_FILE), entry, scope);
+    const parsed = parseSkillFile(path6.join(base, entry, SKILL_FILE), entry, scope);
     if (parsed) into.set(parsed.name, parsed);
   }
 }
 function discoverSkills(cwd, home = starHome()) {
   const byName = /* @__PURE__ */ new Map();
-  scanDir(path5.join(home, "skills"), "user", byName);
-  scanDir(path5.join(cwd, ".star", "skills"), "project", byName);
+  scanDir(path6.join(home, "skills"), "user", byName);
+  scanDir(path6.join(cwd, ".star", "skills"), "project", byName);
   return [...byName.values()];
 }
 function formatSkillsBlock(skills) {
@@ -834,8 +1043,8 @@ function createSkillTool(deps) {
     name: "skill",
     description: "Load the full instructions of a skill by name. Available skills are listed in the system prompt when present; call this before starting work that matches one of them.",
     permission: "read",
-    parameters: z.object({
-      name: z.string().describe("Name of the skill to load, as listed in the system prompt.")
+    parameters: z2.object({
+      name: z2.string().describe("Name of the skill to load, as listed in the system prompt.")
     }),
     async execute(args) {
       const skills = discoverSkills(deps.cwd, deps.home);
@@ -870,16 +1079,16 @@ import { z as z12 } from "zod";
 // src/tools/bash.ts
 import { spawn as spawn3 } from "child_process";
 import { existsSync } from "fs";
-import path6 from "path";
-import { z as z2 } from "zod";
+import path7 from "path";
+import { z as z3 } from "zod";
 
 // src/tasks/manager.ts
 import { spawn as spawn2 } from "child_process";
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 var MAX_TASK_OUTPUT = 1e5;
 var DEFAULT_TASK_TIMEOUT = 3600;
 var TRUNCATED_PREFIX = "[... earlier output truncated ...]\n";
-var TaskManager = class extends EventEmitter {
+var TaskManager = class extends EventEmitter2 {
   records = /* @__PURE__ */ new Map();
   seq = 0;
   start(opts) {
@@ -990,11 +1199,11 @@ var MAX_OUTPUT = 3e4;
 var DEFAULT_TIMEOUT = 120;
 var MAX_TIMEOUT = 600;
 function findOnPath(exe, exclude) {
-  for (const dir of (process.env.PATH ?? "").split(path6.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path7.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path6.join(dir, exe);
+    const full = path7.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -1012,7 +1221,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path6.join(path6.dirname(path6.dirname(gitExe)), "bin", "bash.exe");
+    const sibling = path7.join(path7.dirname(path7.dirname(gitExe)), "bin", "bash.exe");
     if (existsSync(sibling)) {
       return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
     }
@@ -1029,11 +1238,11 @@ function resolveShell() {
   const comspec = process.env.ComSpec ?? "cmd.exe";
   return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
 }
-var schema = z2.object({
-  command: z2.string().describe("Shell command to execute"),
-  timeout: z2.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
-  description: z2.string().optional().describe("Short description of what the command does"),
-  run_in_background: z2.boolean().optional().describe(
+var schema = z3.object({
+  command: z3.string().describe("Shell command to execute"),
+  timeout: z3.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
+  description: z3.string().optional().describe("Short description of what the command does"),
+  run_in_background: z3.boolean().optional().describe(
     "Run the command in the background and return a task id immediately (default false). Use task_output/task_kill to inspect or stop it."
   )
 });
@@ -1135,14 +1344,14 @@ Command timed out after ${timeoutSeconds}s`,
 };
 
 // src/tools/fs/edit.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
-import { z as z3 } from "zod";
-var schema2 = z3.object({
-  path: z3.string().describe("File path, absolute or relative to the working directory"),
-  old_string: z3.string().min(1).describe("Exact text to replace"),
-  new_string: z3.string().describe("Replacement text"),
-  replace_all: z3.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path8 from "path";
+import { z as z4 } from "zod";
+var schema2 = z4.object({
+  path: z4.string().describe("File path, absolute or relative to the working directory"),
+  old_string: z4.string().min(1).describe("Exact text to replace"),
+  new_string: z4.string().describe("Replacement text"),
+  replace_all: z4.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
 });
 var editFileTool = {
   name: "edit_file",
@@ -1150,10 +1359,10 @@ var editFileTool = {
   permission: "write",
   parameters: schema2,
   async execute(args, ctx) {
-    const filePath = path7.resolve(ctx.cwd, args.path);
+    const filePath = path8.resolve(ctx.cwd, args.path);
     let content;
     try {
-      content = await readFile2(filePath, "utf8");
+      content = await readFile3(filePath, "utf8");
     } catch (err) {
       return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
     }
@@ -1174,7 +1383,7 @@ var editFileTool = {
     }
     const updated = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
     try {
-      await writeFile2(filePath, updated, "utf8");
+      await writeFile3(filePath, updated, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
     }
@@ -1193,14 +1402,15 @@ var editFileTool = {
 };
 
 // src/tools/fs/glob.ts
-import path9 from "path";
-import { z as z4 } from "zod";
+import path10 from "path";
+import { z as z5 } from "zod";
 
 // src/tools/fs/util.ts
+import { readFileSync as readFileSync3, statSync as statSync3 } from "fs";
 import { readdir, stat } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
-async function walkFiles(root, skipDirs = SKIP_DIRS) {
+async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
   const out = [];
   async function walk(dir, relBase) {
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
@@ -1208,13 +1418,17 @@ async function walkFiles(root, skipDirs = SKIP_DIRS) {
       return;
     }
     for (const entry of entries) {
-      const abs = path8.join(dir, entry.name);
+      const abs = path9.join(dir, entry.name);
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
-          await walk(abs, rel);
+        if (skipDirs.has(entry.name) || options.ignore?.(abs, true)) {
+          continue;
         }
+        await walk(abs, rel);
       } else if (entry.isFile()) {
+        if (options.ignore?.(abs, false)) {
+          continue;
+        }
         try {
           const st = await stat(abs);
           out.push({ abs, rel, mtimeMs: st.mtimeMs });
@@ -1263,8 +1477,71 @@ function matchesGlob(pattern, relPath) {
   }
   return globToRegExp(normalized).test(relPath);
 }
+var IGNORE_FILE = ".starignore";
+var ignoreCache = /* @__PURE__ */ new Map();
+function parseIgnorePatterns(body) {
+  const out = [];
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (line.endsWith("/")) {
+      const pattern = line.slice(0, -1);
+      if (pattern) {
+        out.push({ pattern, dirOnly: true });
+      }
+    } else {
+      out.push({ pattern: line, dirOnly: false });
+    }
+  }
+  return out;
+}
+function loadIgnorePatterns(dir) {
+  const file = path9.join(dir, IGNORE_FILE);
+  let mtimeMs;
+  try {
+    mtimeMs = statSync3(file).mtimeMs;
+  } catch {
+    return [];
+  }
+  const hit = ignoreCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) {
+    return hit.patterns;
+  }
+  let patterns = [];
+  try {
+    patterns = parseIgnorePatterns(readFileSync3(file, "utf8"));
+  } catch {
+    patterns = [];
+  }
+  ignoreCache.set(file, { mtimeMs, patterns });
+  return patterns;
+}
+function createIgnorePredicate(cwd) {
+  const patterns = loadIgnorePatterns(cwd);
+  if (patterns.length === 0) {
+    return void 0;
+  }
+  const root = path9.resolve(cwd);
+  return (absPath, isDir) => {
+    const rel = path9.relative(root, absPath).split(path9.sep).join("/");
+    if (!rel || rel.startsWith("..")) {
+      return false;
+    }
+    for (const { pattern, dirOnly } of patterns) {
+      if (dirOnly && !isDir) {
+        continue;
+      }
+      if (matchesGlob(pattern, rel)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
 function isSensitivePath2(filePath) {
-  const base = path8.basename(filePath);
+  const base = path9.basename(filePath);
   if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
     return false;
   }
@@ -1279,11 +1556,11 @@ function isSensitivePath2(filePath) {
 
 // src/tools/fs/glob.ts
 var MAX_RESULTS = 100;
-var schema3 = z4.object({
-  pattern: z4.string().describe(
+var schema3 = z5.object({
+  pattern: z5.string().describe(
     "Glob pattern, e.g. 'src/**/*.ts'. Supports **, * and ?. A bare pattern like '*.ts' matches basenames recursively."
   ),
-  path: z4.string().optional().describe("Directory to search, defaults to the working directory")
+  path: z5.string().optional().describe("Directory to search, defaults to the working directory")
 });
 var globTool = {
   name: "glob",
@@ -1291,8 +1568,8 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path9.resolve(ctx.cwd, args.path ?? ".");
-    const files = await walkFiles(root);
+    const root = path10.resolve(ctx.cwd, args.path ?? ".");
+    const files = await walkFiles(root, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
     const matched = files.filter((f) => matchesGlob(args.pattern, f.rel)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
     if (matched.length === 0) {
       return { content: `No files matched pattern: ${args.pattern}` };
@@ -1302,15 +1579,15 @@ var globTool = {
 };
 
 // src/tools/fs/grep.ts
-import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import path10 from "path";
-import { z as z5 } from "zod";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import path11 from "path";
+import { z as z6 } from "zod";
 var MAX_MATCHES = 250;
-var schema4 = z5.object({
-  pattern: z5.string().describe("Regular expression to search for"),
-  path: z5.string().optional().describe("File or directory to search, defaults to the working directory"),
-  glob: z5.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
-  ignoreCase: z5.boolean().optional().describe("Case-insensitive matching")
+var schema4 = z6.object({
+  pattern: z6.string().describe("Regular expression to search for"),
+  path: z6.string().optional().describe("File or directory to search, defaults to the working directory"),
+  glob: z6.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
+  ignoreCase: z6.boolean().optional().describe("Case-insensitive matching")
 });
 var grepTool = {
   name: "grep",
@@ -1324,14 +1601,14 @@ var grepTool = {
     } catch (err) {
       return { content: `Invalid regular expression: ${err.message}`, isError: true };
     }
-    const root = path10.resolve(ctx.cwd, args.path ?? ".");
+    const root = path11.resolve(ctx.cwd, args.path ?? ".");
     let files;
     try {
       const st = await stat2(root);
       if (st.isFile()) {
-        files = [{ abs: root, rel: path10.basename(root), mtimeMs: st.mtimeMs }];
+        files = [{ abs: root, rel: path11.basename(root), mtimeMs: st.mtimeMs }];
       } else {
-        files = await walkFiles(root);
+        files = await walkFiles(root, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
       }
     } catch {
       return { content: `Path not found: ${args.path ?? "."}`, isError: true };
@@ -1345,7 +1622,7 @@ var grepTool = {
     outer: for (const file of files) {
       let buf;
       try {
-        buf = await readFile3(file.abs);
+        buf = await readFile4(file.abs);
       } catch {
         continue;
       }
@@ -1375,15 +1652,15 @@ var grepTool = {
 };
 
 // src/tools/fs/read.ts
-import { readFile as readFile4, stat as stat3 } from "fs/promises";
-import path11 from "path";
-import { z as z6 } from "zod";
+import { readFile as readFile5, stat as stat3 } from "fs/promises";
+import path12 from "path";
+import { z as z7 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var MAX_CHARS = 100 * 1024;
-var schema5 = z6.object({
-  path: z6.string().describe("File path, absolute or relative to the working directory"),
-  offset: z6.number().int().positive().optional().describe("1-based line number to start reading from"),
-  limit: z6.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+var schema5 = z7.object({
+  path: z7.string().describe("File path, absolute or relative to the working directory"),
+  offset: z7.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z7.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
 });
 var readFileTool = {
   name: "read_file",
@@ -1391,7 +1668,7 @@ var readFileTool = {
   permission: "read",
   parameters: schema5,
   async execute(args, ctx) {
-    const filePath = path11.resolve(ctx.cwd, args.path);
+    const filePath = path12.resolve(ctx.cwd, args.path);
     if (isSensitivePath2(filePath)) {
       return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
     }
@@ -1402,7 +1679,7 @@ var readFileTool = {
     if (st.isDirectory()) {
       return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
     }
-    const raw = await readFile4(filePath, "utf8");
+    const raw = await readFile5(filePath, "utf8");
     const lines = raw.split("\n");
     const start = args.offset ?? 1;
     const limit = args.limit ?? DEFAULT_LIMIT;
@@ -1436,12 +1713,12 @@ var readFileTool = {
 };
 
 // src/tools/fs/write.ts
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import path12 from "path";
-import { z as z7 } from "zod";
-var schema6 = z7.object({
-  path: z7.string().describe("File path, absolute or relative to the working directory"),
-  content: z7.string().describe("Full content to write to the file")
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import path13 from "path";
+import { z as z8 } from "zod";
+var schema6 = z8.object({
+  path: z8.string().describe("File path, absolute or relative to the working directory"),
+  content: z8.string().describe("Full content to write to the file")
 });
 var writeFileTool = {
   name: "write_file",
@@ -1449,11 +1726,11 @@ var writeFileTool = {
   permission: "write",
   parameters: schema6,
   async execute(args, ctx) {
-    const filePath = path12.resolve(ctx.cwd, args.path);
+    const filePath = path13.resolve(ctx.cwd, args.path);
     const snapshot = await captureSnapshot(filePath, "write_file");
     try {
-      await mkdir2(path12.dirname(filePath), { recursive: true });
-      await writeFile3(filePath, args.content, "utf8");
+      await mkdir3(path13.dirname(filePath), { recursive: true });
+      await writeFile4(filePath, args.content, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
     }
@@ -1463,7 +1740,7 @@ var writeFileTool = {
 };
 
 // src/tools/tasks.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/tasks/format.ts
 function formatDuration(startedAt, endedAt) {
@@ -1509,40 +1786,59 @@ function formatTaskFinished(task) {
 }
 
 // src/tools/tasks.ts
-var idSchema = z8.object({
-  id: z8.string().describe("Task id, e.g. task-1")
+var idSchema = z9.object({
+  id: z9.string().describe("Task id, e.g. task-1 or agent-1")
 });
+function formatAgentTaskLine(task) {
+  const duration = formatDuration(task.startedAt, task.endedAt);
+  const label = task.description ?? task.prompt.slice(0, 60);
+  const status = task.status === "running" ? `running ${duration}` : `${task.status} after ${duration}`;
+  return `${task.id} [${status}] ${label}`;
+}
 var taskListTool = {
   name: "task_list",
-  description: "List background shell tasks with status, runtime, and exit code.",
+  description: "List background tasks (shell commands and subagents) with status and runtime.",
   permission: "read",
-  parameters: z8.object({}),
+  parameters: z9.object({}),
   execute() {
-    return Promise.resolve({ content: formatTaskList(defaultTaskManager.list()) });
+    const shell = formatTaskList(defaultTaskManager.list());
+    const agents = defaultAgentTasks.list();
+    const agentLines = agents.length === 0 ? "No background subagents." : `Background subagents:
+${agents.map(formatAgentTaskLine).join("\n")}`;
+    return Promise.resolve({ content: `${shell}
+${agentLines}` });
   }
 };
 var taskOutputTool = {
   name: "task_output",
-  description: "Read the current output of a background shell task (works while still running).",
+  description: "Read the current output of a background task (shell command or subagent; works while still running).",
   permission: "read",
   parameters: idSchema,
   execute(args) {
-    const task = defaultTaskManager.get(args.id);
-    if (!task) {
-      return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
+    const shell = defaultTaskManager.get(args.id);
+    if (shell) {
+      const body = shell.output.replace(/\s+$/, "") || "(no output yet)";
+      return Promise.resolve({ content: `${formatTaskLine(shell)}
+${body}` });
     }
-    const body = task.output.replace(/\s+$/, "") || "(no output yet)";
-    return Promise.resolve({ content: `${formatTaskLine(task)}
+    const agent = defaultAgentTasks.get(args.id);
+    if (agent) {
+      const body = agent.status === "running" ? "(still running)" : agent.result.replace(/\s+$/, "") || "(no report)";
+      return Promise.resolve({ content: `${formatAgentTaskLine(agent)}
 ${body}` });
+    }
+    return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
   }
 };
 var taskKillTool = {
   name: "task_kill",
-  description: "Stop a running background shell task (kills the whole process tree).",
+  description: "Stop a running background task (shell command process tree or subagent).",
   permission: "exec",
   parameters: idSchema,
   execute(args) {
-    const task = defaultTaskManager.get(args.id);
+    const shell = defaultTaskManager.get(args.id);
+    const agent = shell ? void 0 : defaultAgentTasks.get(args.id);
+    const task = shell ?? agent;
     if (!task) {
       return Promise.resolve({ content: `Unknown task: ${args.id}`, isError: true });
     }
@@ -1552,106 +1848,15 @@ var taskKillTool = {
         isError: true
       });
     }
-    defaultTaskManager.kill(args.id);
+    if (shell) {
+      defaultTaskManager.kill(args.id);
+    } else {
+      defaultAgentTasks.kill(args.id);
+    }
     return Promise.resolve({ content: `Task ${args.id} stopped.` });
   }
 };
 
-// src/tools/todo.ts
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import path13 from "path";
-import { z as z9 } from "zod";
-var todoItemSchema = z9.object({
-  id: z9.number().int(),
-  title: z9.string(),
-  status: z9.enum(["pending", "in_progress", "done"])
-});
-var writeSchema = z9.object({
-  todos: z9.array(todoItemSchema).describe("The full todo list, replacing the current one")
-});
-var readSchema = z9.object({});
-function fileFor(cwd) {
-  return path13.join(cwd, ".star", "todos.json");
-}
-var TodoStore = class {
-  items = /* @__PURE__ */ new Map();
-  list() {
-    return [...this.items.values()];
-  }
-  replace(items) {
-    this.items.clear();
-    for (const item of items) {
-      this.items.set(item.id, item);
-    }
-  }
-  async load(cwd) {
-    let raw;
-    try {
-      raw = await readFile5(fileFor(cwd), "utf8");
-    } catch {
-      return;
-    }
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
-      }
-    } catch {
-    }
-  }
-  async save(cwd) {
-    await mkdir3(path13.join(cwd, ".star"), { recursive: true });
-    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
-`);
-  }
-};
-var SYMBOLS = {
-  pending: "[ ]",
-  in_progress: "[~]",
-  done: "[x]"
-};
-function formatTodos(items) {
-  if (items.length === 0) {
-    return "No todos.";
-  }
-  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
-  const width = Math.max(...lines.map((l) => l.length));
-  return lines.map((line, i) => {
-    const status = items[i]?.status;
-    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
-  }).join("\n");
-}
-var defaultStore = new TodoStore();
-function createTodoTools(store = defaultStore) {
-  const todoWrite = {
-    name: "todo_write",
-    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
-    permission: "read",
-    parameters: writeSchema,
-    async execute(args, ctx) {
-      const parsed = writeSchema.safeParse(args);
-      if (!parsed.success) {
-        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
-      }
-      await store.load(ctx.cwd);
-      store.replace(parsed.data.todos);
-      await store.save(ctx.cwd);
-      return { content: formatTodos(store.list()) };
-    }
-  };
-  const todoRead = {
-    name: "todo_read",
-    description: "Read the current todo list.",
-    permission: "read",
-    parameters: readSchema,
-    async execute(_args, ctx) {
-      await store.load(ctx.cwd);
-      return { content: formatTodos(store.list()) };
-    }
-  };
-  return [todoWrite, todoRead];
-}
-
 // src/tools/web/fetch.ts
 import { z as z10 } from "zod";
 var DEFAULT_MAX_CHARS = 2e4;
@@ -1949,75 +2154,216 @@ function createDefaultRegistry() {
 var MAX_SUBAGENT_DEPTH = 1;
 var MAX_REPORT_CHARS = 2e4;
 var SUBAGENT_PROMPT = "You are a subagent spawned to handle a focused subtask on behalf of the main agent. Work autonomously with the tools available to you, then finish with a concise report of what you found or did. Your final text is returned to the main agent as the tool result \u2014 make it self-contained.";
+async function runSubagent(deps, args, cwd, signal) {
+  const { AgentLoop: AgentLoop2 } = await import("./loop-EIODKYPT.js");
+  const child = new AgentLoop2({
+    model: deps.model,
+    registry: createDefaultRegistry(),
+    config: deps.config,
+    cwd,
+    system: deps.system ? `${deps.system}
+
+${SUBAGENT_PROMPT}` : SUBAGENT_PROMPT,
+    subagentDepth: deps.depth + 1
+  });
+  const confirmHandler = deps.getConfirmHandler?.();
+  if (confirmHandler) child.confirmHandler = confirmHandler;
+  let toolCalls = 0;
+  let error = null;
+  try {
+    for await (const event of child.stream(args.prompt, signal)) {
+      if (event.type === "tool-result") {
+        toolCalls++;
+      } else if (event.type === "error") {
+        error = event.error.message;
+        break;
+      }
+    }
+  } catch (e) {
+    error = e instanceof Error ? e.message : String(e);
+  }
+  let report = "";
+  const messages = child.getMessages();
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+    const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+    if (text) {
+      report = text;
+      break;
+    }
+  }
+  if (report.length > MAX_REPORT_CHARS) {
+    report = `${report.slice(0, MAX_REPORT_CHARS)}
+... (truncated)`;
+  }
+  const label = args.description ? ` "${args.description}"` : "";
+  const stats = `[subagent${label}: ${toolCalls} tool call(s)]`;
+  if (error) {
+    throw new Error([`Subagent failed: ${error}`, stats, report].filter(Boolean).join("\n"));
+  }
+  return `${stats}
+${report || "(subagent produced no text output)"}`;
+}
 function createSubagentTool(deps) {
   return {
     name: "subagent",
-    description: "Spawn a subagent with its own agent loop to handle a focused subtask (research, exploration, or an isolated change). The subagent has the same tools but cannot spawn further subagents. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation.",
+    description: "Spawn a subagent with its own agent loop to handle a focused subtask (research, exploration, or an isolated change). The subagent has the same tools but cannot spawn further subagents. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation. Set run_in_background to start it without blocking: independent subtasks then run concurrently and their reports are delivered to you automatically when they finish (also inspectable via task_list/task_output/task_kill).",
     permission: "exec",
     parameters: z12.object({
       prompt: z12.string().describe("Complete, self-contained instructions for the subagent."),
-      description: z12.string().optional().describe("Short label for the subtask, shown in the result header.")
+      description: z12.string().optional().describe("Short label for the subtask, shown in the result header."),
+      run_in_background: z12.boolean().optional().describe(
+        "Run concurrently in the background and return a task id immediately (default false). Use for independent subtasks that can run in parallel."
+      )
     }),
     async execute(args, ctx) {
-      const { AgentLoop: AgentLoop2 } = await import("./loop-R3RQCNFT.js");
-      const child = new AgentLoop2({
-        model: deps.model,
-        registry: createDefaultRegistry(),
-        config: deps.config,
-        cwd: ctx.cwd,
-        system: deps.system ? `${deps.system}
-
-${SUBAGENT_PROMPT}` : SUBAGENT_PROMPT,
-        subagentDepth: deps.depth + 1
-      });
-      const confirmHandler = deps.getConfirmHandler?.();
-      if (confirmHandler) child.confirmHandler = confirmHandler;
+      if (args.run_in_background) {
+        const task = defaultAgentTasks.start((signal2) => runSubagent(deps, args, ctx.cwd, signal2), {
+          prompt: args.prompt,
+          description: args.description
+        });
+        const label = args.description ? ` "${args.description}"` : "";
+        return {
+          content: `Background subagent ${task.id}${label} started. Its report will be delivered as a message when it finishes; use task_list/task_output to check progress.`
+        };
+      }
       const signal = ctx.abortSignal ?? new AbortController().signal;
-      let toolCalls = 0;
-      let error = null;
       try {
-        for await (const event of child.stream(args.prompt, signal)) {
-          if (event.type === "tool-result") {
-            toolCalls++;
-          } else if (event.type === "error") {
-            error = event.error.message;
-            break;
-          }
-        }
+        return { content: await runSubagent(deps, args, ctx.cwd, signal) };
       } catch (e) {
-        error = e instanceof Error ? e.message : String(e);
+        return { content: e instanceof Error ? e.message : String(e), isError: true };
       }
-      let report = "";
-      const messages = child.getMessages();
-      for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
-        const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-        if (text) {
-          report = text;
-          break;
-        }
-      }
-      if (report.length > MAX_REPORT_CHARS) {
-        report = `${report.slice(0, MAX_REPORT_CHARS)}
-... (truncated)`;
-      }
-      const label = args.description ? ` "${args.description}"` : "";
-      const stats = `[subagent${label}: ${toolCalls} tool call(s)]`;
-      if (error) {
-        return {
-          content: [`Subagent failed: ${error}`, stats, report].filter(Boolean).join("\n"),
-          isError: true
-        };
+    }
+  };
+}
+
+// src/agent/user-memory.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import path14 from "path";
+import { z as z13 } from "zod";
+var USER_MEMORY_MAX_CHARS = 32 * 1024;
+var REMEMBER_TEXT_MAX_CHARS = 500;
+var cache3 = /* @__PURE__ */ new Map();
+function readUserMemory(home = starHome()) {
+  const file = path14.join(home, "MEMORY.md");
+  let mtimeMs;
+  try {
+    mtimeMs = statSync4(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache3.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.block;
+  let block = null;
+  try {
+    let body = readFileSync4(file, "utf8").trim();
+    if (body) {
+      if (body.length > USER_MEMORY_MAX_CHARS) {
+        body = `${body.slice(0, USER_MEMORY_MAX_CHARS)}
+
+[MEMORY.md truncated to ${USER_MEMORY_MAX_CHARS} characters]`;
       }
-      return { content: `${stats}
-${report || "(subagent produced no text output)"}` };
+      block = [
+        "# User memory (MEMORY.md)",
+        "The following notes were saved by the user across sessions. Respect them unless they conflict with the current request.",
+        body
+      ].join("\n");
+    }
+  } catch {
+    block = null;
+  }
+  cache3.set(file, { mtimeMs, block });
+  return block;
+}
+function appendUserMemory(text, home = starHome()) {
+  mkdirSync(home, { recursive: true });
+  appendFileSync(path14.join(home, "MEMORY.md"), `- ${text}
+`, "utf8");
+}
+function createRememberTool(deps = {}) {
+  return {
+    name: "remember",
+    description: `Save a note to the user's long-term memory (${userMemoryPath()}), injected into every future session. ONLY use when the user explicitly asks to remember or save something. Never use autonomously.`,
+    permission: "write",
+    parameters: z13.object({
+      text: z13.string().max(REMEMBER_TEXT_MAX_CHARS).describe("The note to save, as a single concise sentence.")
+    }),
+    async execute(args) {
+      appendUserMemory(args.text, deps.home);
+      return { content: `Saved to user memory: ${args.text}` };
     }
   };
 }
 
 // src/agent/loop.ts
 var PLAN_MODE_PROMPT = "\n\nYou are currently in PLAN MODE. Research the task using only the read-only tools available to you, then present a concrete, step-by-step implementation plan as your final answer. You must not modify files, run shell commands, or otherwise change the system \u2014 write/exec tools are unavailable in this mode. Do not ask the user to run commands for you; note manual steps in the plan instead. The user will review your plan and approve it before any execution begins.";
+var PENDING_WORK_PATTERN = /(?:我将|我会|我现在|接下来|下一步|下面(?:我|将)|稍后|随后|准备开始|现在开始|马上|即将|这就|待会|开始(?:执行|进行|处理|转换|动手|生成|写入|运行|创建)|(?:完成后|然后|接着)会|让我(?:们)?(?:来)?|I will|I'll|I am going to|I'm going to|I shall|let me|next,? I|I will now)/i;
+var AUTO_CONTINUE_NUDGE = "[auto-continue] You ended your turn with words instead of actions. Do not describe or restate the plan \u2014 continue the task NOW by calling tools. Reply with text only if the task is already fully complete.";
+var COMPLETION_CHECK_TIMEOUT_MS = 3e4;
+async function checkTaskComplete(model, request, finalReply, signal) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), COMPLETION_CHECK_TIMEOUT_MS);
+  const onAbort = () => controller.abort();
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const { text } = await generateText3({
+      model,
+      maxTokens: 8,
+      abortSignal: controller.signal,
+      prompt: [
+        "An AI coding agent was given this task by the user:",
+        `<task>
+${request.slice(0, 2e3)}
+</task>`,
+        "The agent has stopped calling tools and ended with this reply:",
+        `<reply>
+${finalReply.slice(0, 2e3)}
+</reply>`,
+        "Has the agent fully completed the task \u2014 every requested action actually performed, and the result verified by running a check (tests, build, or inspecting the produced output) rather than assumed? Or is it only describing, planning, or reporting progress with work still left? Answer with exactly one word: DONE or NOT_DONE."
+      ].join("\n")
+    });
+    const verdict = text.trim().toUpperCase();
+    if (verdict.startsWith("NOT_DONE")) return false;
+    if (verdict.startsWith("DONE")) return true;
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+var STREAM_RETRY_BASE_DELAY_MS = 1e3;
+var NON_RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "AI_NoSuchToolError",
+  "AI_InvalidToolArgumentsError",
+  "AI_InvalidPromptError",
+  "AI_NoSuchModelError",
+  "AI_LoadAPIKeyError"
+]);
+function isRetryableStreamError(error) {
+  if (NON_RETRYABLE_ERROR_NAMES.has(error.name)) return false;
+  const status = error.statusCode;
+  if (typeof status === "number") {
+    return status === 408 || status === 429 || status >= 500;
+  }
+  return true;
+}
+function sleep(ms, signal) {
+  if (signal.aborted) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve(false);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 var AgentLoop = class {
   messages = [];
   opts;
@@ -2041,6 +2387,7 @@ var AgentLoop = class {
       this.bindSnapshotHooks(opts.sessionStore);
     }
     opts.registry?.register(createSkillTool({ cwd: opts.cwd }));
+    opts.registry?.register(createRememberTool());
     const depth = opts.subagentDepth ?? 0;
     if (opts.registry && depth < MAX_SUBAGENT_DEPTH) {
       opts.registry.register(
@@ -2152,7 +2499,7 @@ var AgentLoop = class {
   }
   async *stream(input, signal, opts) {
     this.syncSystemMessage();
-    const text = typeof input === "string" ? input : input.text;
+    const inputText = typeof input === "string" ? input : input.text;
     const images = typeof input === "string" ? [] : input.images;
     const userMessage = images.length > 0 ? {
       role: "user",
@@ -2162,9 +2509,9 @@ var AgentLoop = class {
           image: img.data,
           mimeType: img.mimeType
         })),
-        { type: "text", text }
+        { type: "text", text: inputText }
       ]
-    } : { role: "user", content: text };
+    } : { role: "user", content: inputText };
     this.messages.push(userMessage);
     const seq = (this.opts.subagentDepth ?? 0) === 0 ? beginTurn(this.messages.length - 1) : currentTurnSeq();
     this.turnMarkers.push({ seq, userIndex: this.messages.length - 1 });
@@ -2173,42 +2520,89 @@ var AgentLoop = class {
     );
     const { config, registry, cwd } = this.opts;
     const aiTools = this.buildAiTools();
+    let autoContinues = 0;
+    let lastWasNudge = false;
+    let usedToolsThisTurn = false;
+    let openTodos = [];
     for (let step = 0; step < config.maxSteps; step++) {
+      if ((this.opts.subagentDepth ?? 0) === 0) {
+        for (const finished of defaultAgentTasks.drainNotifications()) {
+          const label = finished.description ? ` "${finished.description}"` : "";
+          const note = {
+            role: "user",
+            content: `[background subagent ${finished.id}${label} ${finished.status}]
+${finished.result}`
+          };
+          this.messages.push(note);
+          await this.persist(note);
+        }
+      }
       const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
       const compacted = compactMessages([...this.messages], maxTokens);
       if (compacted.compacted) {
         this.messages = await this.applyCompactionSummary(compacted);
       }
-      let text2 = "";
+      const maxRetries = Math.max(0, config.streamMaxRetries);
+      const baseDelay = this.opts.retryDelayMs ?? STREAM_RETRY_BASE_DELAY_MS;
+      let text = "";
       const toolCalls = [];
-      let failed = false;
-      try {
-        for await (const event of this.streamOnce(aiTools, signal)) {
-          if (event.type === "text-delta") {
-            text2 += event.text;
-            yield event;
-          } else if (event.type === "reasoning") {
-            yield event;
-          } else if (event.type === "tool-call") {
-            toolCalls.push({ id: event.id, name: event.name, args: event.args });
-            yield event;
-          } else if (event.type === "error") {
-            failed = true;
-            yield event;
-          } else {
-            yield event;
+      let failure = null;
+      for (let attempt = 0; ; attempt++) {
+        text = "";
+        toolCalls.length = 0;
+        failure = null;
+        let finishReason;
+        const timeoutScale = Math.min(attempt + 1, 3);
+        try {
+          for await (const event of this.streamOnce(aiTools, signal, timeoutScale)) {
+            if (event.type === "text-delta") {
+              text += event.text;
+              yield event;
+            } else if (event.type === "reasoning") {
+              yield event;
+            } else if (event.type === "tool-call") {
+              toolCalls.push({ id: event.id, name: event.name, args: event.args });
+              yield event;
+            } else if (event.type === "finish") {
+              finishReason = event.finishReason;
+              yield event;
+            } else if (event.type === "error") {
+              failure = event.error;
+            } else {
+              yield event;
+            }
           }
+        } catch (error) {
+          if (signal.aborted) return;
+          failure = error instanceof Error ? error : new Error(String(error));
         }
-      } catch (error) {
         if (signal.aborted) return;
-        yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
+        if (!failure && (text.length > 0 || toolCalls.length > 0)) break;
+        if (failure && !isRetryableStreamError(failure)) break;
+        if (attempt >= maxRetries) break;
+        yield {
+          type: "retry",
+          attempt: attempt + 2,
+          maxAttempts: maxRetries + 1,
+          reason: failure ? failure.message : `empty response (finish: ${finishReason ?? "none"})`
+        };
+        if (!await sleep(baseDelay * 2 ** attempt, signal)) return;
+      }
+      if (failure) {
+        yield { type: "error", error: failure };
+        return;
+      }
+      if (text.length === 0 && toolCalls.length === 0) {
+        yield {
+          type: "error",
+          error: new Error("The model returned an empty response after retries; ending the turn.")
+        };
         return;
       }
-      if (failed) return;
       const assistantMessage = {
         role: "assistant",
         content: [
-          ...text2 ? [{ type: "text", text: text2 }] : [],
+          ...text ? [{ type: "text", text }] : [],
           ...toolCalls.map((call) => ({
             type: "tool-call",
             toolCallId: call.id,
@@ -2219,11 +2613,40 @@ var AgentLoop = class {
       };
       this.messages.push(assistantMessage);
       await this.persist(assistantMessage);
-      this.maybeScheduleTitle(text2);
+      this.maybeScheduleTitle(text);
       if (toolCalls.length === 0) {
+        let reason = null;
+        let nudgeText = AUTO_CONTINUE_NUDGE;
+        if (openTodos.length > 0) {
+          reason = `${openTodos.length} todo item(s) still open`;
+          nudgeText = `[auto-continue] You ended your turn with unfinished todo item(s): ${openTodos.map((t) => `"${t}"`).join(
+            ", "
+          )}. Complete them now with tool calls, or update the list with todo_write if they are no longer needed.`;
+        } else if (lastWasNudge) {
+          reason = "reply still had no tool calls";
+        } else if (PENDING_WORK_PATTERN.test(text)) {
+          reason = "reply announced unfinished work";
+        } else if (usedToolsThisTurn && !signal.aborted) {
+          const complete = await checkTaskComplete(this.opts.model, inputText, text, signal);
+          if (complete === false) reason = "completion check reports the task unfinished";
+        }
+        if (reason !== null && config.permissionMode !== "plan" && autoContinues < config.maxAutoContinues) {
+          autoContinues++;
+          lastWasNudge = true;
+          yield {
+            type: "notice",
+            message: `${reason}; asking the model to continue (${autoContinues}/${config.maxAutoContinues}).`
+          };
+          const nudge = { role: "user", content: nudgeText };
+          this.messages.push(nudge);
+          await this.persist(nudge);
+          continue;
+        }
         await this.runEventHooks("Stop");
         return;
       }
+      lastWasNudge = false;
+      usedToolsThisTurn = true;
       const answered = /* @__PURE__ */ new Set();
       try {
         for (const call of toolCalls) {
@@ -2243,6 +2666,9 @@ var AgentLoop = class {
           this.messages.push(toolMessage);
           await this.persist(toolMessage);
           answered.add(call.id);
+          if (call.name === "todo_write" && !result.isError) {
+            openTodos = pendingTodoTitles(call.args);
+          }
           yield {
             type: "tool-result",
             id: call.id,
@@ -2285,8 +2711,9 @@ var AgentLoop = class {
   // /model switch) replaced the history with one that has none. Git context
   // (branch, dirty count, recent commits) is refreshed here too, so the model
   // always sees the current repo state; any git failure is silently skipped.
-  // Project memory (AGENTS.md in the cwd) is appended as a delimited block;
-  // readProjectMemory caches by mtime, so this stays cheap per turn. The
+  // Project memory (AGENTS.md in the cwd) and user memory (~/.star-cli/
+  // MEMORY.md) are appended as delimited blocks; both cache by mtime, so this
+  // stays cheap per turn. The
   // skills listing is refreshed here as well, so skills added mid-session
   // show up in the next turn's system prompt.
   syncSystemMessage() {
@@ -2297,6 +2724,8 @@ var AgentLoop = class {
     if (plan) parts.push(PLAN_MODE_PROMPT.trim());
     const memory = readProjectMemory(this.opts.cwd);
     if (memory) parts.push(memory);
+    const userMemory = readUserMemory();
+    if (userMemory) parts.push(userMemory);
     const skills = discoverSkills(this.opts.cwd);
     if (skills.length > 0) parts.push(formatSkillsBlock(skills));
     const git = getGitSummary(this.opts.cwd);
@@ -2330,14 +2759,15 @@ ${summary}`
       return compacted.messages;
     }
   }
-  async *streamOnce(aiTools, signal) {
+  async *streamOnce(aiTools, signal, timeoutScale = 1) {
     const { streamChat } = await import("./stream-Y55NRF2S.js");
     yield* streamChat({
       model: this.opts.model,
       messages: this.messages,
       tools: aiTools,
       abortSignal: signal,
-      idleTimeoutMs: this.opts.config.streamIdleTimeoutSec * 1e3
+      idleTimeoutMs: this.opts.config.streamIdleTimeoutSec * 1e3 * timeoutScale,
+      firstPartTimeoutMs: this.opts.config.streamFirstChunkTimeoutSec * 1e3 * timeoutScale
     });
   }
   buildAiTools() {
@@ -2378,7 +2808,8 @@ ${summary}`
       config.permissionMode,
       { toolName: call.name, args: call.args, level: tool.permission },
       { cwd },
-      config.permissions.allow
+      config.permissions.allow,
+      config.permissions.deny
     );
     if (decision === "deny") {
       return { content: `Permission denied for tool "${call.name}".`, isError: true };
@@ -2429,6 +2860,7 @@ ${summary}`
 };
 
 export {
+  defaultAgentTasks,
   estimateTokens,
   summarizeMessages,
   compactMessages,
@@ -2447,23 +2879,28 @@ export {
   hydrateSnapshots,
   undoTurnSnapshots,
   rewindToSnapshot,
+  TodoStore,
+  formatTodos,
+  parseTodoArgs,
+  loadTodos,
   starHome,
   globalConfigPath,
   sessionsDir,
+  userMemoryPath,
   projectConfigPath,
   discoverSkills,
   defaultTaskManager,
   resolveShell,
   bashTool,
   SKIP_DIRS,
+  createIgnorePredicate,
   isSensitivePath2 as isSensitivePath,
   formatTaskList,
   formatTaskStarted,
   formatTaskFinished,
-  TodoStore,
-  formatTodos,
   createDefaultRegistry,
+  appendUserMemory,
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-MJ2O7NWI.js.map
+//# sourceMappingURL=chunk-DZWTIMJ2.js.map