@cryer/star-cli 0.3.0 → 0.3.2

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

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+import {
+  computeRetryDelayMs,
+  isRetryableStreamError,
+  starHome,
+  summarizeStreamError,
+  userMemoryPath
+} from "./chunk-LADQCYKL.js";
 
 // src/agent/loop.ts
 import { tool as aiTool, generateText as generateText3 } from "ai";
@@ -235,6 +242,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 +798,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--) {
@@ -778,6 +918,9 @@ async function loadTodos(cwd) {
   await defaultStore.load(cwd);
   return defaultStore.list();
 }
+function resetTodos() {
+  defaultStore.replace([]);
+}
 function createTodoTools(store = defaultStore) {
   const todoWrite = {
     name: "todo_write",
@@ -789,10 +932,11 @@ function createTodoTools(store = defaultStore) {
       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 items = store.list();
+      const done = items.filter((it) => it.status === "done").length;
+      return { content: `Todo list updated (${done}/${items.length} done).` };
     }
   };
   const todoRead = {
@@ -800,8 +944,7 @@ function createTodoTools(store = defaultStore) {
     description: "Read the current todo list.",
     permission: "read",
     parameters: readSchema,
-    async execute(_args, ctx) {
-      await store.load(ctx.cwd);
+    async execute() {
       return { content: formatTodos(store.list()) };
     }
   };
@@ -936,29 +1079,8 @@ ${body}`;
 
 // src/agent/skills.ts
 import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
-import path6 from "path";
-import { z as z2 } from "zod";
-
-// src/config/paths.ts
-import os from "os";
 import path5 from "path";
-function starHome() {
-  return process.env.STAR_HOME ?? path5.join(os.homedir(), ".star-cli");
-}
-function globalConfigPath() {
-  return path5.join(starHome(), "config.toml");
-}
-function sessionsDir() {
-  return path5.join(starHome(), "sessions");
-}
-function userMemoryPath() {
-  return path5.join(starHome(), "MEMORY.md");
-}
-function projectConfigPath(cwd) {
-  return path5.join(cwd, ".star", "config.toml");
-}
-
-// src/agent/skills.ts
+import { z as z2 } from "zod";
 var SKILL_FILE = "SKILL.md";
 var SKILL_MAX_CHARS = 32 * 1024;
 var NAME_PATTERN = /^[a-z0-9-]+$/;
@@ -988,7 +1110,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: path6.dirname(filePath), scope };
+      skill = { name, description, filePath, dir: path5.dirname(filePath), scope };
     }
   } catch {
     skill = null;
@@ -1005,14 +1127,14 @@ function scanDir(base, scope, into) {
   }
   for (const entry of entries.sort()) {
     if (!NAME_PATTERN.test(entry)) continue;
-    const parsed = parseSkillFile(path6.join(base, entry, SKILL_FILE), entry, scope);
+    const parsed = parseSkillFile(path5.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(path6.join(home, "skills"), "user", byName);
-  scanDir(path6.join(cwd, ".star", "skills"), "project", byName);
+  scanDir(path5.join(home, "skills"), "user", byName);
+  scanDir(path5.join(cwd, ".star", "skills"), "project", byName);
   return [...byName.values()];
 }
 function formatSkillsBlock(skills) {
@@ -1079,7 +1201,7 @@ import { z as z12 } from "zod";
 // src/tools/bash.ts
 import { spawn as spawn3 } from "child_process";
 import { existsSync } from "fs";
-import path7 from "path";
+import path6 from "path";
 import { z as z3 } from "zod";
 
 // src/tasks/manager.ts
@@ -1199,11 +1321,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(path7.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path6.delimiter)) {
     if (!dir || exclude?.(dir)) {
       continue;
     }
-    const full = path7.join(dir, exe);
+    const full = path6.join(dir, exe);
     if (existsSync(full)) {
       return full;
     }
@@ -1221,7 +1343,7 @@ function resolveShell() {
   }
   const gitExe = findOnPath("git.exe");
   if (gitExe) {
-    const sibling = path7.join(path7.dirname(path7.dirname(gitExe)), "bin", "bash.exe");
+    const sibling = path6.join(path6.dirname(path6.dirname(gitExe)), "bin", "bash.exe");
     if (existsSync(sibling)) {
       return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
     }
@@ -1345,7 +1467,7 @@ Command timed out after ${timeoutSeconds}s`,
 
 // src/tools/fs/edit.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+import path7 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"),
@@ -1359,7 +1481,7 @@ var editFileTool = {
   permission: "write",
   parameters: schema2,
   async execute(args, ctx) {
-    const filePath = path8.resolve(ctx.cwd, args.path);
+    const filePath = path7.resolve(ctx.cwd, args.path);
     let content;
     try {
       content = await readFile3(filePath, "utf8");
@@ -1402,13 +1524,13 @@ var editFileTool = {
 };
 
 // src/tools/fs/glob.ts
-import path10 from "path";
+import path9 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 path9 from "path";
+import path8 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
 async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
   const out = [];
@@ -1418,7 +1540,7 @@ async function walkFiles(root, skipDirs = SKIP_DIRS, options = {}) {
       return;
     }
     for (const entry of entries) {
-      const abs = path9.join(dir, entry.name);
+      const abs = path8.join(dir, entry.name);
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name) || options.ignore?.(abs, true)) {
@@ -1498,7 +1620,7 @@ function parseIgnorePatterns(body) {
   return out;
 }
 function loadIgnorePatterns(dir) {
-  const file = path9.join(dir, IGNORE_FILE);
+  const file = path8.join(dir, IGNORE_FILE);
   let mtimeMs;
   try {
     mtimeMs = statSync3(file).mtimeMs;
@@ -1523,9 +1645,9 @@ function createIgnorePredicate(cwd) {
   if (patterns.length === 0) {
     return void 0;
   }
-  const root = path9.resolve(cwd);
+  const root = path8.resolve(cwd);
   return (absPath, isDir) => {
-    const rel = path9.relative(root, absPath).split(path9.sep).join("/");
+    const rel = path8.relative(root, absPath).split(path8.sep).join("/");
     if (!rel || rel.startsWith("..")) {
       return false;
     }
@@ -1541,7 +1663,7 @@ function createIgnorePredicate(cwd) {
   };
 }
 function isSensitivePath2(filePath) {
-  const base = path9.basename(filePath);
+  const base = path8.basename(filePath);
   if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
     return false;
   }
@@ -1568,7 +1690,7 @@ var globTool = {
   permission: "read",
   parameters: schema3,
   async execute(args, ctx) {
-    const root = path10.resolve(ctx.cwd, args.path ?? ".");
+    const root = path9.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) {
@@ -1580,7 +1702,7 @@ var globTool = {
 
 // src/tools/fs/grep.ts
 import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import path11 from "path";
+import path10 from "path";
 import { z as z6 } from "zod";
 var MAX_MATCHES = 250;
 var schema4 = z6.object({
@@ -1601,12 +1723,12 @@ var grepTool = {
     } catch (err) {
       return { content: `Invalid regular expression: ${err.message}`, isError: true };
     }
-    const root = path11.resolve(ctx.cwd, args.path ?? ".");
+    const root = path10.resolve(ctx.cwd, args.path ?? ".");
     let files;
     try {
       const st = await stat2(root);
       if (st.isFile()) {
-        files = [{ abs: root, rel: path11.basename(root), mtimeMs: st.mtimeMs }];
+        files = [{ abs: root, rel: path10.basename(root), mtimeMs: st.mtimeMs }];
       } else {
         files = await walkFiles(root, void 0, { ignore: createIgnorePredicate(ctx.cwd) });
       }
@@ -1653,7 +1775,7 @@ var grepTool = {
 
 // src/tools/fs/read.ts
 import { readFile as readFile5, stat as stat3 } from "fs/promises";
-import path12 from "path";
+import path11 from "path";
 import { z as z7 } from "zod";
 var DEFAULT_LIMIT = 2e3;
 var MAX_CHARS = 100 * 1024;
@@ -1668,7 +1790,7 @@ var readFileTool = {
   permission: "read",
   parameters: schema5,
   async execute(args, ctx) {
-    const filePath = path12.resolve(ctx.cwd, args.path);
+    const filePath = path11.resolve(ctx.cwd, args.path);
     if (isSensitivePath2(filePath)) {
       return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
     }
@@ -1714,7 +1836,7 @@ var readFileTool = {
 
 // src/tools/fs/write.ts
 import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
-import path13 from "path";
+import path12 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"),
@@ -1726,10 +1848,10 @@ var writeFileTool = {
   permission: "write",
   parameters: schema6,
   async execute(args, ctx) {
-    const filePath = path13.resolve(ctx.cwd, args.path);
+    const filePath = path12.resolve(ctx.cwd, args.path);
     const snapshot = await captureSnapshot(filePath, "write_file");
     try {
-      await mkdir3(path13.dirname(filePath), { recursive: true });
+      await mkdir3(path12.dirname(filePath), { recursive: true });
       await writeFile4(filePath, args.content, "utf8");
     } catch (err) {
       return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
@@ -2155,7 +2277,7 @@ 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 { AgentLoop: AgentLoop2 } = await import("./loop-XKC5HQBT.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -2240,13 +2362,13 @@ function createSubagentTool(deps) {
 
 // src/agent/user-memory.ts
 import { appendFileSync, mkdirSync, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
-import path14 from "path";
+import path13 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");
+  const file = path13.join(home, "MEMORY.md");
   let mtimeMs;
   try {
     mtimeMs = statSync4(file).mtimeMs;
@@ -2278,7 +2400,7 @@ function readUserMemory(home = starHome()) {
 }
 function appendUserMemory(text, home = starHome()) {
   mkdirSync(home, { recursive: true });
-  appendFileSync(path14.join(home, "MEMORY.md"), `- ${text}
+  appendFileSync(path13.join(home, "MEMORY.md"), `- ${text}
 `, "utf8");
 }
 function createRememberTool(deps = {}) {
@@ -2300,6 +2422,16 @@ function createRememberTool(deps = {}) {
 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 isFilteredEmptyFinish(finishReason) {
+  return finishReason === "content-filter";
+}
+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();
@@ -2335,21 +2467,6 @@ ${finalReply.slice(0, 2e3)}
   }
 }
 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) => {
@@ -2434,6 +2551,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
@@ -2487,6 +2616,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.
@@ -2497,6 +2636,47 @@ 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 inputText = typeof input === "string" ? input : input.text;
@@ -2547,11 +2727,17 @@ ${finished.result}`
       let text = "";
       const toolCalls = [];
       let failure = null;
+      let lastFinishReason;
+      let lastUsage;
+      let sawReasoning = false;
+      let oversizedImagesStripped = false;
       for (let attempt = 0; ; attempt++) {
         text = "";
         toolCalls.length = 0;
         failure = null;
-        let finishReason;
+        lastFinishReason = void 0;
+        lastUsage = void 0;
+        sawReasoning = false;
         const timeoutScale = Math.min(attempt + 1, 3);
         try {
           for await (const event of this.streamOnce(aiTools, signal, timeoutScale)) {
@@ -2559,12 +2745,14 @@ ${finished.result}`
               text += event.text;
               yield event;
             } else if (event.type === "reasoning") {
+              sawReasoning = true;
               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;
+              lastFinishReason = event.finishReason;
+              lastUsage = event.usage;
               yield event;
             } else if (event.type === "error") {
               failure = event.error;
@@ -2573,26 +2761,60 @@ ${finished.result}`
             }
           }
         } catch (error) {
-          if (signal.aborted) return;
-          failure = error instanceof Error ? error : new Error(String(error));
+          if (!signal.aborted) {
+            failure = error instanceof Error ? error : new Error(String(error));
+          }
+        }
+        if (signal.aborted) {
+          yield* this.persistInterrupted(text, toolCalls);
+          return;
         }
-        if (signal.aborted) 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;
+          }
+        }
         if (failure && !isRetryableStreamError(failure)) break;
         if (attempt >= maxRetries) break;
+        if (!failure && text.length === 0 && toolCalls.length === 0 && attempt >= 1 && (isFilteredEmptyFinish(lastFinishReason) || sawReasoning || lastUsage !== void 0 && lastUsage.completionTokens > 0))
+          break;
+        const delayMs = computeRetryDelayMs(attempt, baseDelay, failure);
         yield {
           type: "retry",
           attempt: attempt + 2,
           maxAttempts: maxRetries + 1,
-          reason: failure ? failure.message : `empty response (finish: ${finishReason ?? "none"})`
+          delayMs,
+          reason: failure ? summarizeStreamError(failure) : `empty response (finish: ${lastFinishReason ?? "none"})`
         };
-        if (!await sleep(baseDelay * 2 ** attempt, signal)) return;
+        if (!await sleep(delayMs, 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.")
@@ -2637,16 +2859,26 @@ ${finished.result}`
             type: "notice",
             message: `${reason}; asking the model to continue (${autoContinues}/${config.maxAutoContinues}).`
           };
-          const nudge = { role: "user", content: nudgeText };
+          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) {
@@ -2760,7 +2992,7 @@ ${summary}`
     }
   }
   async *streamOnce(aiTools, signal, timeoutScale = 1) {
-    const { streamChat } = await import("./stream-Y55NRF2S.js");
+    const { streamChat } = await import("./stream-OY2MKWYE.js");
     yield* streamChat({
       model: this.opts.model,
       messages: this.messages,
@@ -2870,6 +3102,8 @@ export {
   collectCommitContext,
   buildCommitPrompt,
   collectWorkingDiff,
+  MAX_IMAGE_DIMENSION,
+  probeImageDimensions,
   reconcileToolCalls,
   isAllowedByRules,
   buildAllowRule,
@@ -2877,17 +3111,15 @@ export {
   listSnapshots,
   clearSnapshots,
   hydrateSnapshots,
+  listTurnSnapshots,
+  resolveSnapshotContent,
   undoTurnSnapshots,
   rewindToSnapshot,
   TodoStore,
   formatTodos,
   parseTodoArgs,
   loadTodos,
-  starHome,
-  globalConfigPath,
-  sessionsDir,
-  userMemoryPath,
-  projectConfigPath,
+  resetTodos,
   discoverSkills,
   defaultTaskManager,
   resolveShell,
@@ -2903,4 +3135,4 @@ export {
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-DZWTIMJ2.js.map
+//# sourceMappingURL=chunk-BV4PLM6X.js.map