@cryer/star-cli 0.2.2 → 0.3.1

package/dist/{chunk-GN236FD4.js → chunk-K4SIXWCI.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";
@@ -235,6 +235,133 @@ ${unstaged}`);
   return { status, diff: text, truncated };
 }
 
+// src/core/image.ts
+var MAX_IMAGE_DIMENSION = 2e3;
+var OVERSIZED_IMAGE_FALLBACK_BYTES = 5 * 1024 * 1024;
+var IMAGE_REMOVED_PLACEHOLDER = "[image removed: too large for the model]";
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function probePng(buf) {
+  if (buf.length < 24) return null;
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (buf[i] !== PNG_SIGNATURE[i]) return null;
+  }
+  if (buf.toString("ascii", 12, 16) !== "IHDR") return null;
+  return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+}
+var JPEG_SOF_MARKERS = /* @__PURE__ */ new Set([
+  192,
+  193,
+  194,
+  195,
+  197,
+  198,
+  199,
+  201,
+  202,
+  203,
+  205,
+  206,
+  207
+]);
+function probeJpeg(buf) {
+  if (buf.length < 4 || buf[0] !== 255 || buf[1] !== 216) return null;
+  let offset = 2;
+  while (offset + 3 < buf.length) {
+    if (buf[offset] !== 255) return null;
+    const marker = buf[offset + 1];
+    if (marker === void 0) return null;
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    const length = buf.readUInt16BE(offset + 2);
+    if (length < 2) return null;
+    if (JPEG_SOF_MARKERS.has(marker)) {
+      if (offset + 9 > buf.length) return null;
+      return { height: buf.readUInt16BE(offset + 5), width: buf.readUInt16BE(offset + 7) };
+    }
+    offset += 2 + length;
+  }
+  return null;
+}
+function probeGif(buf) {
+  if (buf.length < 10) return null;
+  const signature = buf.toString("ascii", 0, 6);
+  if (signature !== "GIF87a" && signature !== "GIF89a") return null;
+  return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+}
+function probeWebp(buf) {
+  if (buf.length < 30) return null;
+  if (buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WEBP") {
+    return null;
+  }
+  const chunk = buf.toString("ascii", 12, 16);
+  if (chunk === "VP8X") {
+    return { width: 1 + buf.readUIntLE(24, 3), height: 1 + buf.readUIntLE(27, 3) };
+  }
+  if (chunk === "VP8 ") {
+    return {
+      width: buf.readUInt16LE(26) & 16383,
+      height: buf.readUInt16LE(28) & 16383
+    };
+  }
+  if (chunk === "VP8L") {
+    if (buf[20] !== 47) return null;
+    const b1 = buf[21];
+    const b2 = buf[22];
+    const b3 = buf[23];
+    const b4 = buf[24];
+    return {
+      width: 1 + ((b2 & 63) << 8 | b1),
+      height: 1 + ((b4 & 15) << 10 | b3 << 2 | (b2 & 192) >> 6)
+    };
+  }
+  return null;
+}
+function probeImageDimensions(buf) {
+  return probePng(buf) ?? probeJpeg(buf) ?? probeGif(buf) ?? probeWebp(buf);
+}
+var IMAGE_SIZE_KEYWORDS = /too[\s-]*(large|big)|exceeds?|dimensions?|resolution|size\s*limit|max(?:imum)?[\s-]*size/i;
+function isOversizedImageError(error) {
+  const status = error.statusCode;
+  if (typeof status !== "number" || status < 400 || status >= 500) return false;
+  return /image/i.test(error.message) && IMAGE_SIZE_KEYWORDS.test(error.message);
+}
+function imagePartBytes(image) {
+  if (typeof image === "string") {
+    const base64 = image.startsWith("data:") ? image.slice(image.indexOf(",") + 1) : image;
+    try {
+      return Buffer.from(base64, "base64");
+    } catch {
+      return null;
+    }
+  }
+  if (image instanceof Uint8Array) return Buffer.from(image);
+  return null;
+}
+function isOversizedImageData(buf) {
+  const dims = probeImageDimensions(buf);
+  if (dims) return Math.max(dims.width, dims.height) > MAX_IMAGE_DIMENSION;
+  return buf.length > OVERSIZED_IMAGE_FALLBACK_BYTES;
+}
+function stripOversizedImages(messages) {
+  let removed = 0;
+  const result = messages.map((message) => {
+    if (!Array.isArray(message.content)) return message;
+    let changed = false;
+    const content = message.content.map((part) => {
+      if (part.type !== "image") return part;
+      const bytes = imagePartBytes(part.image);
+      if (!bytes || !isOversizedImageData(bytes)) return part;
+      changed = true;
+      removed++;
+      return { type: "text", text: IMAGE_REMOVED_PLACEHOLDER };
+    });
+    return changed ? { ...message, content } : message;
+  });
+  return { messages: removed > 0 ? result : messages, removed };
+}
+
 // src/core/messages.ts
 var MISSING_TOOL_RESULT_TEXT = "tool result missing (session was interrupted)";
 function reconcileToolCalls(messages) {
@@ -664,6 +791,12 @@ async function revert(snapshot) {
   await rm(snapshot.path, { force: true });
   return `Deleted ${snapshot.path} (it did not exist before ${snapshot.toolName}).`;
 }
+function listTurnSnapshots(turn) {
+  return stack.filter((snapshot) => snapshot.turn === turn).reverse();
+}
+function resolveSnapshotContent(snapshot) {
+  return resolveContent(snapshot);
+}
 async function undoTurnSnapshots(turn) {
   const matches = [];
   for (let i = stack.length - 1; i >= 0; i--) {
@@ -702,14 +835,214 @@ 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 resetTodos() {
+  defaultStore.replace([]);
+}
+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 };
+      }
+      store.replace(parsed.data.todos);
+      await store.save(ctx.cwd);
+      const items = store.list();
+      const done = items.filter((it) => it.status === "done").length;
+      return { content: `Todo list updated (${done}/${items.length} done).` };
+    }
+  };
+  const todoRead = {
+    name: "todo_read",
+    description: "Read the current todo list.",
+    permission: "read",
+    parameters: readSchema,
+    async execute() {
+      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;
@@ -739,26 +1072,29 @@ ${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 path4.join(starHome(), "MEMORY.md");
+  return path5.join(starHome(), "MEMORY.md");
+}
+function envFilePath() {
+  return path5.join(starHome(), ".env");
 }
 function projectConfigPath(cwd) {
-  return path4.join(cwd, ".star", "config.toml");
+  return path5.join(cwd, ".star", "config.toml");
 }
 
 // src/agent/skills.ts
@@ -791,7 +1127,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;
@@ -808,14 +1144,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) {
@@ -846,8 +1182,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);
@@ -882,16 +1218,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) {
@@ -1002,11 +1338,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;
     }
@@ -1024,7 +1360,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" };
     }
@@ -1041,11 +1377,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."
   )
 });
@@ -1147,14 +1483,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",
@@ -1162,10 +1498,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 };
     }
@@ -1186,7 +1522,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 };
     }
@@ -1205,13 +1541,13 @@ 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, options = {}) {
   const out = [];
@@ -1221,7 +1557,7 @@ async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
       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) || options.ignore?.(abs, true)) {
@@ -1301,7 +1637,7 @@ function parseIgnorePatterns(body) {
   return out;
 }
 function loadIgnorePatterns(dir) {
-  const file = path8.join(dir, IGNORE_FILE);
+  const file = path9.join(dir, IGNORE_FILE);
   let mtimeMs;
   try {
     mtimeMs = statSync3(file).mtimeMs;
@@ -1326,9 +1662,9 @@ function createIgnorePredicate(cwd) {
   if (patterns.length === 0) {
     return void 0;
   }
-  const root = path8.resolve(cwd);
+  const root = path9.resolve(cwd);
   return (absPath, isDir) => {
-    const rel = path8.relative(root, absPath).split(path8.sep).join("/");
+    const rel = path9.relative(root, absPath).split(path9.sep).join("/");
     if (!rel || rel.startsWith("..")) {
       return false;
     }
@@ -1344,7 +1680,7 @@ function createIgnorePredicate(cwd) {
   };
 }
 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;
   }
@@ -1359,11 +1695,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",
@@ -1371,7 +1707,7 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path9.resolve(ctx.cwd, args.path ?? ".");
+    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) {
@@ -1382,15 +1718,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",
@@ -1404,12 +1740,12 @@ 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, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
       }
@@ -1425,7 +1761,7 @@ var grepTool = {
     outer: for (const file of files) {
       let buf;
       try {
-        buf = await readFile3(file.abs);
+        buf = await readFile4(file.abs);
       } catch {
         continue;
       }
@@ -1455,15 +1791,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",
@@ -1471,7 +1807,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 };
     }
@@ -1482,7 +1818,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;
@@ -1516,12 +1852,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",
@@ -1529,11 +1865,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 };
     }
@@ -1543,7 +1879,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) {
@@ -1589,40 +1925,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 });
     }
@@ -1632,105 +1987,14 @@ var taskKillTool = {
         isError: true
       });
     }
-    defaultTaskManager.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 {
+    if (shell) {
+      defaultTaskManager.kill(args.id);
+    } else {
+      defaultAgentTasks.kill(args.id);
     }
-  }
-  async save(cwd) {
-    await mkdir3(path13.join(cwd, ".star"), { recursive: true });
-    await writeFile4(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
-`);
+    return Promise.resolve({ content: `Task ${args.id} stopped.` });
   }
 };
-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";
@@ -2029,69 +2293,86 @@ 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-ED6AAMWV.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-ADVWZA62.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);
-      }
-      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)`;
+        return { content: e instanceof Error ? e.message : String(e), isError: true };
       }
-      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
-        };
-      }
-      return { content: `${stats}
-${report || "(subagent produced no text output)"}` };
     }
   };
 }
@@ -2156,6 +2437,79 @@ function createRememberTool(deps = {}) {
 
 // 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 EMPTY_REPLY_NUDGE = "[auto-continue] Your previous reply was empty \u2014 no text and no tool calls. If the task is fully complete, reply with one short confirmation; otherwise continue NOW by calling tools.";
+function isSteerableEmptyFinish(finishReason) {
+  return finishReason === "stop" || finishReason === "content-filter";
+}
+function finalNudgeWarning(autoContinues, maxAutoContinues) {
+  return autoContinues >= maxAutoContinues ? " This is the final automatic continuation \u2014 if your next reply again has no tool calls, nudging stops and the turn is handed back to the user. Finish the work now or summarize what remains." : "";
+}
+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;
@@ -2226,6 +2580,18 @@ var AgentLoop = class {
     this.messages = reconcileToolCalls(messages);
     this.turnMarkers = [];
   }
+  // Read-only counterpart of retractLastTurn: how many messages /undo would
+  // drop and which snapshot turn's file changes it would revert (undefined =
+  // no verified turn, so no file snapshots may be reverted). Mutates nothing,
+  // so the REPL can show the preview before the user confirms.
+  previewLastTurnRetraction() {
+    const result = retractLastTurn([...this.messages]);
+    if (result.removed === 0) return { removed: 0 };
+    const userIndex = result.messages.length;
+    const last = this.turnMarkers[this.turnMarkers.length - 1];
+    const turn = last && last.userIndex === userIndex ? last.seq : void 0;
+    return { removed: result.removed, turn };
+  }
   // Drops the final user message and everything after it, and persists the
   // trimmed history so a later /resume does not bring the turn back.
   // `turn` is the retracted turn's snapshot seq when it could be verified
@@ -2279,6 +2645,16 @@ var AgentLoop = class {
   async persist(message) {
     await this.opts.sessionStore?.append(message);
   }
+  // Replaces oversized image parts in the in-memory history with text
+  // placeholders and rewrites the persisted session, so the failed request
+  // can be resent and a later resume never carries the offending images.
+  async stripOversizedImages() {
+    const { messages, removed } = stripOversizedImages(this.messages);
+    if (removed === 0) return 0;
+    this.messages = messages;
+    await this.opts.sessionStore?.replaceMessages([...this.messages]);
+    return removed;
+  }
   // After the first assistant reply, kick off background title generation
   // for the session. Runs once per loop; the store-level title check makes
   // resumed sessions that already have a title a no-op.
@@ -2289,9 +2665,50 @@ var AgentLoop = class {
     this.titleScheduled = true;
     scheduleSessionTitle(store, input, this.opts.model);
   }
+  // A user interrupt (Esc) ends the turn mid-stream, before the normal
+  // assistant-message persistence runs. Whatever text and tool calls already
+  // arrived are still persisted — the text marked with "[interrupted]" so the
+  // cut-off stays visible after a resume and the model can tell its reply was
+  // cut short — and streamed tool calls are closed with synthetic results so
+  // the stored history stays valid for the API.
+  async *persistInterrupted(text, toolCalls) {
+    if (text.length === 0 && toolCalls.length === 0) return;
+    const assistantMessage = {
+      role: "assistant",
+      content: [
+        ...text ? [{ type: "text", text: `${text} [interrupted]` }] : [],
+        ...toolCalls.map((call) => ({
+          type: "tool-call",
+          toolCallId: call.id,
+          toolName: call.name,
+          args: call.args
+        }))
+      ]
+    };
+    this.messages.push(assistantMessage);
+    await this.persist(assistantMessage);
+    for (const call of toolCalls) {
+      const content = "Tool execution interrupted by user.";
+      const synthetic = {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: call.id,
+            toolName: call.name,
+            result: content
+          }
+        ]
+      };
+      this.messages.push(synthetic);
+      await this.persist(synthetic).catch(() => {
+      });
+      yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
+    }
+  }
   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",
@@ -2301,9 +2718,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 });
@@ -2312,42 +2729,123 @@ 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;
+      let lastFinishReason;
+      let oversizedImagesStripped = false;
+      for (let attempt = 0; ; attempt++) {
+        text = "";
+        toolCalls.length = 0;
+        failure = null;
+        lastFinishReason = void 0;
+        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") {
+              lastFinishReason = event.finishReason;
+              yield event;
+            } else if (event.type === "error") {
+              failure = event.error;
+            } else {
+              yield event;
+            }
+          }
+        } catch (error) {
+          if (!signal.aborted) {
+            failure = error instanceof Error ? error : new Error(String(error));
+          }
+        }
+        if (signal.aborted) {
+          yield* this.persistInterrupted(text, toolCalls);
+          return;
+        }
+        if (!failure && (text.length > 0 || toolCalls.length > 0)) break;
+        if (failure && !oversizedImagesStripped && isOversizedImageError(failure)) {
+          oversizedImagesStripped = true;
+          const removed = await this.stripOversizedImages();
+          if (removed > 0) {
+            yield {
+              type: "notice",
+              message: `Removed ${removed} oversized image(s) the model rejected; retrying the request.`
+            };
+            continue;
           }
         }
-      } catch (error) {
-        if (signal.aborted) return;
-        yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
+        if (failure && !isRetryableStreamError(failure)) break;
+        if (attempt >= maxRetries) break;
+        if (!failure && text.length === 0 && toolCalls.length === 0 && attempt >= 1 && isSteerableEmptyFinish(lastFinishReason))
+          break;
+        yield {
+          type: "retry",
+          attempt: attempt + 2,
+          maxAttempts: maxRetries + 1,
+          reason: failure ? failure.message : `empty response (finish: ${lastFinishReason ?? "none"})`
+        };
+        if (!await sleep(baseDelay * 2 ** attempt, signal)) return;
+      }
+      if (failure) {
+        yield { type: "error", error: failure };
+        return;
+      }
+      if (text.length === 0 && toolCalls.length === 0) {
+        if (isSteerableEmptyFinish(lastFinishReason) && config.permissionMode !== "plan" && autoContinues < config.maxAutoContinues) {
+          autoContinues++;
+          lastWasNudge = true;
+          yield {
+            type: "notice",
+            message: `the model returned an empty reply; asking the model to continue (${autoContinues}/${config.maxAutoContinues}).`
+          };
+          const nudge = {
+            role: "user",
+            content: EMPTY_REPLY_NUDGE + finalNudgeWarning(autoContinues, config.maxAutoContinues)
+          };
+          this.messages.push(nudge);
+          await this.persist(nudge);
+          continue;
+        }
+        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,
@@ -2358,11 +2856,50 @@ 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 + finalNudgeWarning(autoContinues, config.maxAutoContinues)
+          };
+          this.messages.push(nudge);
+          await this.persist(nudge);
+          continue;
+        }
+        if (reason !== null && config.permissionMode !== "plan") {
+          yield {
+            type: "notice",
+            message: `${reason}; auto-continue limit reached, handing the turn back \u2014 reply "continue" to keep going.`
+          };
+        }
         await this.runEventHooks("Stop");
         return;
       }
+      lastWasNudge = false;
+      usedToolsThisTurn = true;
+      autoContinues = 0;
       const answered = /* @__PURE__ */ new Set();
       try {
         for (const call of toolCalls) {
@@ -2382,6 +2919,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,
@@ -2472,14 +3012,15 @@ ${summary}`
       return compacted.messages;
     }
   }
-  async *streamOnce(aiTools, signal) {
-    const { streamChat } = await import("./stream-Y55NRF2S.js");
+  async *streamOnce(aiTools, signal, timeoutScale = 1) {
+    const { streamChat } = await import("./stream-YQCRUBO3.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() {
@@ -2572,6 +3113,7 @@ ${summary}`
 };
 
 export {
+  defaultAgentTasks,
   estimateTokens,
   summarizeMessages,
   compactMessages,
@@ -2581,6 +3123,8 @@ export {
   collectCommitContext,
   buildCommitPrompt,
   collectWorkingDiff,
+  MAX_IMAGE_DIMENSION,
+  probeImageDimensions,
   reconcileToolCalls,
   isAllowedByRules,
   buildAllowRule,
@@ -2588,12 +3132,20 @@ export {
   listSnapshots,
   clearSnapshots,
   hydrateSnapshots,
+  listTurnSnapshots,
+  resolveSnapshotContent,
   undoTurnSnapshots,
   rewindToSnapshot,
+  TodoStore,
+  formatTodos,
+  parseTodoArgs,
+  loadTodos,
+  resetTodos,
   starHome,
   globalConfigPath,
   sessionsDir,
   userMemoryPath,
+  envFilePath,
   projectConfigPath,
   discoverSkills,
   defaultTaskManager,
@@ -2605,11 +3157,9 @@ export {
   formatTaskList,
   formatTaskStarted,
   formatTaskFinished,
-  TodoStore,
-  formatTodos,
   createDefaultRegistry,
   appendUserMemory,
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-GN236FD4.js.map
+//# sourceMappingURL=chunk-K4SIXWCI.js.map