@cryer/star-cli 0.3.0 → 0.3.1

package/README.md

@@ -15,7 +15,7 @@ Multi-model LLM access · streaming terminal UI · tool calling · permission co
 
 </div>
 
-Features: streaming REPL with slash commands (+ autocomplete) · OpenAI / Anthropic / OpenAI-compatible providers · built-in fs / bash / web tools with a permission gate · git integration (`/commit` drafts Conventional Commits messages, `/diff` shows a colored working-tree diff, repo status injected into the system prompt) · plan mode with read-only research and plan approval · thinking spinner with dim reasoning preview · diff preview on write/edit approval · `@file` mentions · `!cmd` shell passthrough · custom slash commands from Markdown files · conversation compaction (`/compact`) · session persistence and resume with auto-generated titles (`/resume`, `star -r`) · subagent delegation for focused subtasks · lifecycle hooks (`PreToolUse`/`PostToolUse`/`Stop` shell commands from config) · file-write snapshots with `/undo` and checkpoint rollback with `/rewind` · TODO task tracking · background shell tasks with status-bar visibility (`/tasks`) · terminal bell on long turns and background-task completion · Markdown session export (`/export`) · `/init` + `/doctor` project scaffolding and environment checks · cost estimation · update notifier · `--json` NDJSON output for scripting.
+Features: streaming REPL with slash commands (+ autocomplete) · OpenAI / Anthropic / OpenAI-compatible providers with an interactive `/connect` onboarding wizard · built-in fs / bash / web tools with a permission gate · git integration (`/commit` drafts Conventional Commits messages, `/diff` shows a colored working-tree diff, repo status injected into the system prompt) · plan mode with read-only research and plan approval · thinking spinner with dim reasoning preview · diff preview on write/edit approval · `@file` mentions · `!cmd` shell passthrough · custom slash commands from Markdown files · conversation compaction (`/compact`) · session persistence and resume with auto-generated titles (`/resume`, `star -r`) · subagent delegation for focused subtasks · lifecycle hooks (`PreToolUse`/`PostToolUse`/`Stop` shell commands from config) · file-write snapshots with `/undo` and checkpoint rollback with `/rewind` · TODO task tracking · background shell tasks with status-bar visibility (`/tasks`) · terminal bell on long turns and background-task completion · Markdown session export (`/export`) · `/init` + `/doctor` project scaffolding and environment checks · cost estimation · update notifier · `--json` NDJSON output for scripting.
 
 ## Requirements
 
@@ -105,14 +105,17 @@ command = "biome check --write ."
 # timeoutSec = 30                      # optional per-hook timeout
 ```
 
-API keys resolve from the environment variable first (`apiKeyEnv`), then the `apiKey` field in the config file.
+API keys resolve from the environment variable first (`apiKeyEnv`), then the `apiKey` field in the config file. On startup Star CLI also loads `~/.star-cli/.env` (dotenv-style `KEY=VALUE` lines) into the environment without overwriting variables that are already set — this is where `/connect` stores the keys it collects, so `config.toml` only ever references the variable name, never the key itself.
+
+The fastest way to set up a provider is the `/connect` wizard inside the REPL: pick a preset (OpenAI, Anthropic, Kimi/Moonshot, DeepSeek) or a custom endpoint, paste the API key (masked while typing), name a model, and it appends the `[[providers]]`/`[[models]]` blocks to `config.toml` (existing content and comments preserved), writes the key to `~/.star-cli/.env` (as `STAR_API_KEY_<NAME>`, file mode 600 where the platform honors it), and optionally makes the new model the default — all without restarting.
+
 
 ## CLI flags
 
 ```
 star                          start the interactive REPL
 star -p "prompt"              non-interactive print mode (pipe-friendly)
-star -p "prompt" --image x.png  attach an image (png/jpg/jpeg/gif/webp, max 5MB; repeatable)
+star -p "prompt" --image x.png  attach an image (png/jpg/jpeg/gif/webp, max 5MB; repeatable; anything past 2000px on the longest side is downsampled)
 star -p "prompt" --json       NDJSON event stream on stdout (text/tool/usage/error lines)
 star -m gpt                   pick a model
 star --permission-mode auto   ask | auto | readonly | yolo | plan
@@ -140,11 +143,12 @@ star --clear-sessions all     delete every stored session
 | `/usage` | token usage dashboard across all sessions: totals, per-day bar chart, per-model breakdown with $ estimate |
 | `/config` | show resolved config |
 | `/permission [mode]` | set the permission mode — no argument opens an interactive picker; `ask` / `auto` / `readonly` / `yolo` are saved to config, `plan` stays session-only |
+| `/connect` | interactive provider onboarding wizard: pick a preset or custom endpoint, paste the API key (masked), name a model — appends `[[providers]]`/`[[models]]` to the config, stores the key in `~/.star-cli/.env` (never in `config.toml`), and can set the new model as default + switch to it immediately |
 | `/plan` | toggle plan mode: read-only research, then approve the generated plan before it executes (session-only) |
 | `/memory [add <text>]` | show the long-term memory file (`~/.star-cli/MEMORY.md`, injected into every session's system prompt), or append a line to it — see [Long-term memory](#long-term-memory) |
 | `/compact` | compact conversation history to free up context |
 | `/export [path]` | export the current session to a Markdown file |
-| `/undo` | undo the last conversation turn: revert its file changes (write_file/edit_file) and retract its messages — earlier turns are never touched |
+| `/undo` | undo the last conversation turn: revert its file changes (write_file/edit_file) and retract its messages — earlier turns are never touched (previews the message count and per-file revert diffs, then asks for confirmation) |
 | `/rewind [n]` | list file-change checkpoints, or rewind to just before checkpoint `n`: restore every file changed since then and retract the matching conversation messages (asks for confirmation first) |
 | `/init [force]` | scan the project and generate an AGENTS.md (LLM-polished when a model is available) |
 | `/doctor` | environment self-check (Node, shell, config, API key status, sessions dir writability) |
@@ -156,11 +160,11 @@ star --clear-sessions all     delete every stored session
 | `/exit` | quit |
 | `/q` | quit (alias of `/exit`) |
 
-Keys: `ESC` / `Ctrl+C` interrupts the current stream; on a permission prompt: `y` allow, `n` deny, `a` always allow — the generated allow-rule (e.g. `bash(npm test)`) is saved to `permissions.allow` in the config file and survives restarts. Write/edit prompts include a colored diff preview of the pending change. `Shift+Tab` cycles the permission mode for the session (`ask` → `auto` → `readonly` → `plan`; not saved to config). Input editing: arrow keys move the cursor, `Ctrl+A`/`Ctrl+E` jump to start/end, `Ctrl+U`/`Ctrl+K` delete before/after the cursor, `Ctrl+W` deletes the previous word, up/down recall history (persisted to `~/.star-cli/history` across sessions, consecutive duplicates collapsed). Multi-line input: `Shift+Enter` inserts a newline where the terminal reports it; on terminals that don't (e.g. Windows Terminal) use `Ctrl+J` or end the line with `\` and press `Enter` — pasted multi-line text is kept intact. Typing `/` shows slash-command suggestions with their usage — prefix matches first, then fuzzy subsequence matches; `↑`/`↓` to highlight, `Tab` (or `→` at end of input) to complete, `ESC` to dismiss, and an unknown command name gets a `Did you mean: …` hint. Typing `@` completes file paths relative to the working directory with the same keys; directories end in `/` so `Tab` descends, and `node_modules`, `.git`, `dist` and `.starignore` entries are skipped. `Alt+V` pastes an image from the clipboard as an attachment (each one shows as `[image attached: clipboard.png]` above the input; uses PowerShell on Windows, pngpaste/osascript on macOS, xclip on Linux). `Ctrl+V` also works where the terminal passes it through — Windows Terminal binds Ctrl+V to its own paste, so use `Alt+V` there. While a turn is streaming you can keep typing: submitted prompts (and `!` bangs) queue up as dimmed entries and auto-send in order once the turn finishes; `ESC` during a turn aborts it and clears the queue. Pressing `ESC` twice within half a second while idle retracts your last prompt and restores its text into the input for editing.
+Keys: `ESC` / `Ctrl+C` interrupts the current stream — the partial reply generated so far stays on screen (and in the session history) with a dim `[interrupted]` marker; on a permission prompt: `y` allow, `n` deny, `a` always allow — the generated allow-rule (e.g. `bash(npm test)`) is saved to `permissions.allow` in the config file and survives restarts. Write/edit prompts include a colored diff preview of the pending change. `Shift+Tab` cycles the permission mode for the session (`ask` → `auto` → `readonly` → `plan`; not saved to config). Input editing: arrow keys move the cursor, `Ctrl+A`/`Ctrl+E` jump to start/end, `Ctrl+U`/`Ctrl+K` delete before/after the cursor, `Ctrl+W` deletes the previous word, up/down recall history (persisted to `~/.star-cli/history` across sessions, capped at 50 entries, consecutive duplicates collapsed, slash commands and key-repeat garbage never recorded); while a recalled entry is unmodified up/down keep switching entries, but once you edit the text — or are typing your own multi-line input — up/down move the cursor between lines instead. `Ctrl+R` starts a reverse history search: type to filter (case-insensitive, newest match first), `Ctrl+R`/`↑` for older matches, `↓` for newer, `Enter` to accept the match into the input, `ESC`/`Ctrl+C`/`Ctrl+G` to cancel and restore what you had. Multi-line input: use `Ctrl+J` (or `Alt+Enter`), or end the line with `\` and press `Enter` — pasted multi-line text is kept intact. Pasting a large block (10+ lines or 500+ characters in one go) collapses it into a dim `[pasted #N: L lines]` placeholder so the input box stays compact; the full text is restored into what gets submitted, and `Backspace` removes the placeholder as a unit. A huge paste that the terminal delivers in several chunks is reassembled (via bracketed paste where the terminal supports it) and still collapses into a single placeholder. Typing `/` shows slash-command suggestions with their usage — prefix matches first, then fuzzy subsequence matches; `↑`/`↓` to highlight, `Tab` (or `→` at end of input) to complete, `ESC` to dismiss, and an unknown command name gets a `Did you mean: …` hint. Typing `@` completes file paths relative to the working directory with the same keys; directories end in `/` so `Tab` descends, and `node_modules`, `.git`, `dist` and `.starignore` entries are skipped. `Alt+V` pastes an image from the clipboard as an attachment (each one shows as `[image attached: clipboard.png]` above the input; uses PowerShell on Windows, pngpaste/osascript on macOS, xclip on Linux). Images larger than 2000px on the longest side are automatically downsampled to fit (keeping the aspect ratio, via platform-native tools — no extra installs on Windows/macOS; ImageMagick or ffmpeg on Linux); when resizing isn't possible the original is kept and a warning is shown. `Ctrl+V` also works where the terminal passes it through — Windows Terminal binds Ctrl+V to its own paste, so use `Alt+V` there. While a turn is streaming you can keep typing: submitted prompts (and `!` bangs) queue up as dimmed entries and auto-send in order once the turn finishes; `ESC` during a turn aborts it and clears the queue (the partial reply is kept, marked `[interrupted]`). Pressing `ESC` twice within half a second while idle retracts your last prompt and restores its text into the input for editing.
 
 While the model is working, a spinner (`- \ | /`) shows `star is thinking…`; reasoning models also stream a dimmed tail of their thinking (last ~200 chars), which collapses to a one-line summary once the answer starts.
 
-The status bar shows the working directory (full path on wide terminals), the git branch, the model, the permission mode, context usage as a percentage of the model's context window (its own `contextMaxTokens` when set, else the top-level one), the session cost when the model has pricing configured, and total tokens.
+The status bar shows the working directory (full path on wide terminals), the git branch, the model, the permission mode, context usage as a percentage of the model's context window (its own `contextMaxTokens` when set, else the top-level one), the session prompt-cache hit rate when the provider reports cache usage (`cache: 42%`, or `cache: Not provided` when it never does), the session cost when the model has pricing configured, and total tokens.
 
 ## !shell passthrough
 
@@ -256,7 +260,7 @@ Prefix a path with `@` in any prompt to attach its content (REPL and print mode
 star -p "summarize @README.md and @src/main.tsx"
 ```
 
-Image files (`@screenshot.png` — png, jpg, jpeg, gif, webp, up to 5MB) are sent to the model as image input instead of inlined text, in both the REPL and print mode. In print mode you can also attach images with the repeatable `--image <path>` flag:
+Image files (`@screenshot.png` — png, jpg, jpeg, gif, webp, up to 5MB) are sent to the model as image input instead of inlined text, in both the REPL and print mode; anything over 2000px on the longest side is downsampled first. In print mode you can also attach images with the repeatable `--image <path>` flag:
 
 ```
 star -p "what's wrong in this UI?" --image screenshot.png --image mockup.jpg
@@ -264,6 +268,10 @@ star -p "what's wrong in this UI?" --image screenshot.png --image mockup.jpg
 
 Invalid `--image` paths (unsupported type, missing, unreadable, or oversized) abort print mode with a non-zero exit.
 
+If a provider still rejects a request because an image is too large, the agent automatically removes the oversized images from the conversation (replaced with a `[image removed: too large for the model]` placeholder, also in the stored session) and retries the request once, with a notice in the UI.
+
+A directory mention (`@src/agent/`, with or without the trailing slash) inlines an indented tree of the directory instead of file contents — handy for giving the model project structure without pasting `tree` output. Listings honor `.starignore` and skip sensitive files, and are capped at 200 entries / 10 levels deep with a `... (truncated, N more entries)` marker when larger.
+
 Missing, binary, oversized (>100KB for text, >5MB for images), or sensitive files (`.env`, private keys) are skipped with a note. The chat history keeps your original `@path` text, so resumed sessions don't carry the injected bulk.
 
 ## .starignore
@@ -278,7 +286,7 @@ The `subagent` tool (`exec` level, so it is hidden in plan mode and denied in re
 
 Permission modes: `ask` (reads allowed, writes/exec ask) · `auto` (everything allowed except the hard-denied rules above) · `readonly` (read-only) · `yolo` (allow everything, never ask — **all safety checks disabled**, use at your own risk) · `plan` (read-only research with a plan-approval flow, see above — session-only). Switch at runtime with `/permission` (persisted to the config file), per session with `/plan` or `Shift+Tab`, or at startup with `--permission-mode`. On top of the modes, the `[permissions]` config block holds persistent `allow` and `deny` rule lists (same `bash(npm test *)` syntax); deny rules are evaluated right after the hard safety rules and beat both `auto` mode and allow-rules, while `yolo` bypasses everything.
 
-Every successful `write_file` / `edit_file` first snapshots the file's previous content (in-memory, last 50 writes per session); `/undo` restores the most recent snapshot, deleting the file if it didn't exist before.
+Every successful `write_file` / `edit_file` first snapshots the file's previous content (in-memory, last 50 writes per session); `/undo` reverts the last turn's snapshots — restoring old content, or deleting files the turn created — but only after showing a preview of the retraction and per-file revert diffs and getting a `y`/`n` confirmation.
 
 ## Checkpoints and /rewind
 

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

@@ -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--) {
@@ -778,6 +911,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 +925,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 +937,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()) };
     }
   };
@@ -954,6 +1090,9 @@ function sessionsDir() {
 function userMemoryPath() {
   return path5.join(starHome(), "MEMORY.md");
 }
+function envFilePath() {
+  return path5.join(starHome(), ".env");
+}
 function projectConfigPath(cwd) {
   return path5.join(cwd, ".star", "config.toml");
 }
@@ -2155,7 +2294,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-ED6AAMWV.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -2300,6 +2439,13 @@ 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 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();
@@ -2434,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
@@ -2487,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.
@@ -2497,6 +2665,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 +2756,13 @@ ${finished.result}`
       let text = "";
       const toolCalls = [];
       let failure = null;
+      let lastFinishReason;
+      let oversizedImagesStripped = false;
       for (let attempt = 0; ; attempt++) {
         text = "";
         toolCalls.length = 0;
         failure = null;
-        let finishReason;
+        lastFinishReason = void 0;
         const timeoutScale = Math.min(attempt + 1, 3);
         try {
           for await (const event of this.streamOnce(aiTools, signal, timeoutScale)) {
@@ -2564,7 +2775,7 @@ ${finished.result}`
               toolCalls.push({ id: event.id, name: event.name, args: event.args });
               yield event;
             } else if (event.type === "finish") {
-              finishReason = event.finishReason;
+              lastFinishReason = event.finishReason;
               yield event;
             } else if (event.type === "error") {
               failure = event.error;
@@ -2573,18 +2784,35 @@ ${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 && isSteerableEmptyFinish(lastFinishReason))
+          break;
         yield {
           type: "retry",
           attempt: attempt + 2,
           maxAttempts: maxRetries + 1,
-          reason: failure ? failure.message : `empty response (finish: ${finishReason ?? "none"})`
+          reason: failure ? failure.message : `empty response (finish: ${lastFinishReason ?? "none"})`
         };
         if (!await sleep(baseDelay * 2 ** attempt, signal)) return;
       }
@@ -2593,6 +2821,21 @@ ${finished.result}`
         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 +2880,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 +3013,7 @@ ${summary}`
     }
   }
   async *streamOnce(aiTools, signal, timeoutScale = 1) {
-    const { streamChat } = await import("./stream-Y55NRF2S.js");
+    const { streamChat } = await import("./stream-YQCRUBO3.js");
     yield* streamChat({
       model: this.opts.model,
       messages: this.messages,
@@ -2870,6 +3123,8 @@ export {
   collectCommitContext,
   buildCommitPrompt,
   collectWorkingDiff,
+  MAX_IMAGE_DIMENSION,
+  probeImageDimensions,
   reconcileToolCalls,
   isAllowedByRules,
   buildAllowRule,
@@ -2877,16 +3132,20 @@ export {
   listSnapshots,
   clearSnapshots,
   hydrateSnapshots,
+  listTurnSnapshots,
+  resolveSnapshotContent,
   undoTurnSnapshots,
   rewindToSnapshot,
   TodoStore,
   formatTodos,
   parseTodoArgs,
   loadTodos,
+  resetTodos,
   starHome,
   globalConfigPath,
   sessionsDir,
   userMemoryPath,
+  envFilePath,
   projectConfigPath,
   discoverSkills,
   defaultTaskManager,
@@ -2903,4 +3162,4 @@ export {
   PLAN_MODE_PROMPT,
   AgentLoop
 };
-//# sourceMappingURL=chunk-DZWTIMJ2.js.map
+//# sourceMappingURL=chunk-K4SIXWCI.js.map