@cryer/star-cli 0.3.9 → 0.3.11

package/dist/{chunk-RE3NOULF.js → chunk-63CGUF3F.js}

@@ -12,7 +12,7 @@ import {
   toCoreMessages,
   toStarMessage,
   trackTree
-} from "./chunk-56ZIA57D.js";
+} from "./chunk-N4MIQSNZ.js";
 import {
   createModel,
   streamActivity
@@ -24,7 +24,7 @@ import {
   ToolRegistry,
   createDefaultRegistry,
   debugStreamLog
-} from "./chunk-OIJYNQFZ.js";
+} from "./chunk-Q5FJN4LN.js";
 import {
   TodoStore,
   beginTurn,
@@ -43,7 +43,7 @@ import {
   stripOversizedImages,
   undoTurnSnapshots,
   userMemoryPath
-} from "./chunk-A5PXPWHB.js";
+} from "./chunk-LSYGHLRU.js";
 
 // src/agent/loop.ts
 import { tool as aiTool, generateText as generateText3 } from "ai";
@@ -53,9 +53,19 @@ import { generateText } from "ai";
 
 // src/context/tokens.ts
 import { zodSchema } from "ai";
+import { encode } from "gpt-tokenizer/encoding/cl100k_base";
 var CHARS_PER_TOKEN = 4;
 var MESSAGE_OVERHEAD = 4;
 var IMAGE_PART_TOKENS = 1024;
+var ENCODE_OPTIONS = { disallowedSpecial: /* @__PURE__ */ new Set() };
+function countTextTokens(text) {
+  if (text.length === 0) return 0;
+  try {
+    return encode(text, ENCODE_OPTIONS).length;
+  } catch {
+    return Math.ceil(textWeight(text) / CHARS_PER_TOKEN);
+  }
+}
 function isCjkCode(code) {
   return code >= 12288 && code <= 12543 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 63744 && code <= 64255 || code >= 65280 && code <= 65519;
 }
@@ -66,26 +76,29 @@ function textWeight(text) {
   }
   return text.length + cjk * (CHARS_PER_TOKEN - 1);
 }
-function contentCharLength(message) {
+function roughTextTokens(text) {
+  return Math.ceil(textWeight(text) / CHARS_PER_TOKEN);
+}
+function contentTokenLength(message) {
   if (message.role === "tool") {
-    let chars2 = 0;
+    let tokens2 = 0;
     for (const part of message.content) {
-      chars2 += textWeight(JSON.stringify(part.result ?? null));
+      tokens2 += countTextTokens(JSON.stringify(part.result ?? null));
     }
-    return chars2;
+    return tokens2;
   }
   if (typeof message.content === "string") {
-    return textWeight(message.content);
+    return countTextTokens(message.content);
   }
-  let chars = 0;
+  let tokens = 0;
   for (const part of message.content) {
     if (part.type === "text" || part.type === "reasoning") {
-      chars += textWeight(part.text);
+      tokens += countTextTokens(part.text);
     } else if (part.type === "tool-call") {
-      chars += textWeight(part.toolName) + textWeight(JSON.stringify(part.args ?? null));
+      tokens += countTextTokens(part.toolName) + countTextTokens(JSON.stringify(part.args ?? null));
     }
   }
-  return chars;
+  return tokens;
 }
 function imagePartCount(message) {
   if (typeof message.content === "string" || message.role === "tool") return 0;
@@ -95,7 +108,7 @@ var tokenCache = /* @__PURE__ */ new WeakMap();
 function estimateMessageTokens(message) {
   const cached = tokenCache.get(message);
   if (cached !== void 0) return cached;
-  const tokens = Math.ceil(contentCharLength(message) / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD + imagePartCount(message) * IMAGE_PART_TOKENS;
+  const tokens = contentTokenLength(message) + MESSAGE_OVERHEAD + imagePartCount(message) * IMAGE_PART_TOKENS;
   tokenCache.set(message, tokens);
   return tokens;
 }
@@ -123,14 +136,14 @@ function parametersWireJson(parameters) {
   }
 }
 function estimateToolSchemaTokens(tools) {
-  let weight = 0;
+  let tokens = 0;
   for (const [name, tool] of Object.entries(tools)) {
-    weight += textWeight(name);
+    tokens += countTextTokens(name);
     const description = tool.description;
-    if (typeof description === "string") weight += textWeight(description);
-    weight += textWeight(parametersWireJson(tool.parameters));
+    if (typeof description === "string") tokens += countTextTokens(description);
+    tokens += countTextTokens(parametersWireJson(tool.parameters));
   }
-  return Math.ceil(weight / CHARS_PER_TOKEN);
+  return tokens;
 }
 
 // src/context/compaction.ts
@@ -231,6 +244,7 @@ ${transcript}`,
 }
 function compactMessages(messages, maxTokens, opts = {}) {
   const limit = opts.force ? 0 : maxTokens;
+  const minKept = opts.force ? 1 : MIN_KEPT_MESSAGES;
   const overhead = opts.overheadTokens ?? 0;
   const tokens = messages.map((star) => estimateMessageTokens(star.message));
   let total = overhead;
@@ -259,7 +273,7 @@ function compactMessages(messages, maxTokens, opts = {}) {
   let droppedCount = 0;
   let droppedTokens = 0;
   for (const turn of turns) {
-    if (restCount - droppedCount - turn.length < MIN_KEPT_MESSAGES) {
+    if (restCount - droppedCount - turn.length < minKept) {
       break;
     }
     droppedCount += turn.length;
@@ -283,6 +297,69 @@ function compactMessages(messages, maxTokens, opts = {}) {
   };
 }
 
+// src/context/elision.ts
+var ACTIVATION_FRACTION = 0.5;
+var KEEP_RECENT_MESSAGES = 24;
+var MIN_ELISION_TOKENS = 250;
+var ELIDED_TOOL_RESULT_TEXT = "[stale tool output elided to free context \u2014 it was shown in full earlier; re-run the tool if you need it again]";
+var ELIDED_IMAGE_TEXT = "[image elided to free context \u2014 re-attach it if it is still needed]";
+var ELIDED_TOOL_CALL_ARGS_TEXT = "arguments elided to free context \u2014 the call already ran; this placeholder is not valid tool input, re-read the file if you need the old content";
+function elideStaleContent(messages, thresholdTokens, overheadTokens = 0) {
+  let total = overheadTokens;
+  for (const star of messages) total += estimateMessageTokens(star.message);
+  if (total < thresholdTokens * ACTIVATION_FRACTION) return null;
+  const cutoff = messages.length - KEEP_RECENT_MESSAGES;
+  if (cutoff <= 0) return null;
+  let elidedCount = 0;
+  const out = messages.slice();
+  for (let i = 0; i < cutoff; i++) {
+    const star = out[i];
+    if (!star || star.meta?.elided) continue;
+    const message = star.message;
+    if (message.role === "tool") {
+      if (estimateMessageTokens(message) < MIN_ELISION_TOKENS) continue;
+      out[i] = {
+        message: {
+          ...message,
+          content: message.content.map((part) => ({
+            ...part,
+            result: ELIDED_TOOL_RESULT_TEXT
+          }))
+        },
+        meta: { ...star.meta, elided: true }
+      };
+      elidedCount++;
+    } else if (message.role === "assistant" && Array.isArray(message.content)) {
+      if (!message.content.some((part) => part.type === "tool-call")) continue;
+      if (estimateMessageTokens(message) < MIN_ELISION_TOKENS) continue;
+      out[i] = {
+        message: {
+          ...message,
+          content: message.content.map(
+            (part) => part.type === "tool-call" ? { ...part, args: { elided: ELIDED_TOOL_CALL_ARGS_TEXT } } : part
+          )
+        },
+        meta: { ...star.meta, elided: true }
+      };
+      elidedCount++;
+    } else if (message.role === "user" && Array.isArray(message.content)) {
+      if (!message.content.some((part) => part.type === "image" || part.type === "file")) continue;
+      out[i] = {
+        message: {
+          ...message,
+          content: message.content.map(
+            (part) => part.type === "image" || part.type === "file" ? { type: "text", text: ELIDED_IMAGE_TEXT } : part
+          )
+        },
+        meta: { ...star.meta, elided: true }
+      };
+      elidedCount++;
+    }
+  }
+  if (elidedCount === 0) return null;
+  return { messages: out, elidedCount };
+}
+
 // src/core/events.ts
 function usageTotalTokens(usage) {
   const summed = usage.promptTokens + usage.completionTokens;
@@ -650,10 +727,10 @@ function summarizeStreamError(error) {
 }
 
 // src/llm/stream.ts
-import { streamText } from "ai";
-var DEFAULT_IDLE_TIMEOUT_MS = 2e4;
+import { InvalidToolArgumentsError, streamText } from "ai";
+var DEFAULT_IDLE_TIMEOUT_MS = 6e4;
 var DEFAULT_FIRST_PART_TIMEOUT_MS = 12e4;
-var GENERATION_PART_TYPES = /* @__PURE__ */ new Set(["text-delta", "reasoning", "tool-call", "tool-call-delta"]);
+var CONTENT_PART_TYPES = /* @__PURE__ */ new Set(["text-delta", "tool-call", "tool-call-delta"]);
 var MAX_KEEPALIVE_SILENCE_MS = 10 * 6e4;
 var CACHE_READ_KEYS = ["cacheReadInputTokens", "cache_read_input_tokens"];
 var CACHED_PROMPT_KEYS = ["cachedPromptTokens", "cached_prompt_tokens", "cachedTokens"];
@@ -732,6 +809,7 @@ async function* streamChat(opts) {
   let deltas = 0;
   let hasContent = false;
   const argsProgress = /* @__PURE__ */ new Map();
+  let invalidArgsCounter = 0;
   let lastPartAt = Date.now();
   debugStreamLog("request", {
     messages: opts.messages.length,
@@ -791,7 +869,7 @@ async function* streamChat(opts) {
       }
       const part = next.value;
       lastPartAt = Date.now();
-      if (GENERATION_PART_TYPES.has(part.type)) seenContent = true;
+      if (CONTENT_PART_TYPES.has(part.type)) seenContent = true;
       switch (part.type) {
         case "text-delta":
           deltas++;
@@ -804,6 +882,7 @@ async function* streamChat(opts) {
           break;
         case "tool-call":
           hasContent = true;
+          argsProgress.delete(part.toolCallId);
           yield {
             type: "tool-call",
             id: part.toolCallId,
@@ -843,6 +922,22 @@ async function* streamChat(opts) {
             usage: part.usage,
             deltas
           });
+          for (const [id, progress] of argsProgress) {
+            debugStreamLog("truncated-tool-call", {
+              toolCallId: id,
+              toolName: progress.name,
+              chars: progress.chars,
+              finishReason: part.finishReason
+            });
+            yield {
+              type: "tool-call",
+              id,
+              name: progress.name,
+              args: {},
+              invalidArgs: `the arguments were cut off mid-stream after ${progress.chars} characters (finish reason: ${part.finishReason}) \u2014 the reply hit the output or context limit before the JSON completed. Reissue ${progress.name} with complete arguments; for large content, split it into several smaller calls.`
+            };
+          }
+          argsProgress.clear();
           yield {
             type: "finish",
             finishReason: part.finishReason,
@@ -857,6 +952,29 @@ async function* streamChat(opts) {
         }
         case "error": {
           if (opts.abortSignal?.aborted) return;
+          if (InvalidToolArgumentsError.isInstance(part.error)) {
+            const invalid = part.error;
+            let args = invalid.toolArgs;
+            try {
+              args = JSON.parse(invalid.toolArgs);
+            } catch {
+            }
+            const started = [...argsProgress.entries()].reverse().find(([, progress]) => progress.name === invalid.toolName);
+            debugStreamLog("invalid-tool-args", {
+              toolName: invalid.toolName,
+              recoveredId: started?.[0] ?? null
+            });
+            yield {
+              type: "tool-call",
+              id: started?.[0] ?? `invalid-args-${++invalidArgsCounter}`,
+              name: invalid.toolName,
+              args,
+              // The zod detail tells the model exactly which field to fix;
+              // capped because the message embeds the full rejected value.
+              invalidArgs: invalid.message.length > 2e3 ? `${invalid.message.slice(0, 2e3)}\u2026` : invalid.message
+            };
+            return;
+          }
           const error = toStreamErrorInfo(part.error);
           debugStreamLog("error-part", { seenContent, deltas, error: summarizeStreamError(error) });
           yield { type: "error", error };
@@ -1209,7 +1327,15 @@ function buildAllowRule(req) {
 }
 
 // src/permissions/gate.ts
-var FILE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "read_file", "read_image", "grep", "glob"]);
+var FILE_TOOLS = /* @__PURE__ */ new Set([
+  "write_file",
+  "edit_file",
+  "read_file",
+  "read_image",
+  "grep",
+  "glob",
+  "code_outline"
+]);
 var FORK_BOMB = /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/;
 var MAX_ANALYSIS_DEPTH = 8;
 var SH_FAMILY = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ash"]);
@@ -1981,7 +2107,8 @@ import { randomUUID } from "crypto";
 import { z as z2 } from "zod";
 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.";
+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. Your final text is returned to the main agent as the tool result \u2014 make it a self-contained report: state what you found or did, cite exact file paths with line numbers for anything the main agent may need to open, and note explicitly anything left undone or unverified. Report outcomes, not process.";
+var READ_ONLY_PROMPT = "This subtask is read-only: your tools cannot modify files, run shell commands, or kill tasks. Investigate and report; do not attempt changes.";
 function convertUsagePricing(usage, from, to, config, names) {
   if (from === to) return usage;
   const fromCfg = findModelPricing(config, names?.fromName, from.modelId);
@@ -2019,7 +2146,7 @@ function findModelPricing(config, name, modelId) {
   return config.models.find((m) => m.model === modelId);
 }
 async function runSubagent(deps, args, cwd, signal, agentIdRef) {
-  const { AgentLoop: AgentLoop2 } = await import("./loop-PVOSF6LR.js");
+  const { AgentLoop: AgentLoop2 } = await import("./loop-AY4PXRVP.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -2027,13 +2154,18 @@ async function runSubagent(deps, args, cwd, signal, agentIdRef) {
     cwd,
     system: deps.system ? `${deps.system}
 
-${SUBAGENT_PROMPT}` : SUBAGENT_PROMPT,
+${SUBAGENT_PROMPT}${args.read_only ? `
+
+${READ_ONLY_PROMPT}` : ""}` : `${SUBAGENT_PROMPT}${args.read_only ? `
+
+${READ_ONLY_PROMPT}` : ""}`,
     providerMetadata: deps.providerMetadata,
     temperature: deps.temperature,
     streamIdleTimeoutSec: deps.streamIdleTimeoutSec,
     streamFirstChunkTimeoutSec: deps.streamFirstChunkTimeoutSec,
     vision: deps.vision,
     subagentDepth: deps.depth + 1,
+    readOnly: args.read_only,
     modelName: deps.modelName,
     // Read after the dynamic-import await: defaultAgentTasks.start() has
     // returned by then, so a background spawn's ref.id is already assigned.
@@ -2083,8 +2215,11 @@ ${SUBAGENT_PROMPT}` : SUBAGENT_PROMPT,
     report = `${report.slice(0, MAX_REPORT_CHARS)}
 ... (truncated)`;
   }
-  const label = args.description ? ` "${args.description}"` : "";
-  const stats = `[subagent${label}: ${toolCalls} tool call(s)]`;
+  const tags = [
+    args.description ? `"${args.description}"` : null,
+    args.read_only ? "read-only" : null
+  ].filter(Boolean).join(" ");
+  const stats = `[subagent${tags ? ` ${tags}` : ""}: ${toolCalls} tool call(s)]`;
   if (error) {
     throw new Error([`Subagent failed: ${error}`, stats, report].filter(Boolean).join("\n"));
   }
@@ -2094,11 +2229,16 @@ ${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. 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).",
+    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, and it starts with zero context beyond what you write \u2014 brief it like a colleague who just walked in: state the goal, hand over what you already know (paths, identifiers, prior findings), and say exactly what the report should contain. Returns the subagent's final report. Prefer this for self-contained work that would otherwise clutter the main conversation. Set read_only for research, exploration, or review subtasks that must not modify anything. 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: z2.object({
-      prompt: z2.string().describe("Complete, self-contained instructions for the subagent."),
+      prompt: z2.string().describe(
+        "Complete, self-contained instructions for the subagent: the goal, everything you already know that it needs, and the expected report."
+      ),
       description: z2.string().optional().describe("Short label for the subtask, shown in the result header."),
+      read_only: z2.boolean().optional().describe(
+        "Restrict the subagent to read-level tools \u2014 no file writes, no shell commands, no task kills (default false). Use for research, exploration, and review subtasks."
+      ),
       run_in_background: z2.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."
       )
@@ -2203,6 +2343,7 @@ 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;
+var TODO_STALE_NUDGE_STEPS = 20;
 function attachTurnContext(messages, context) {
   if (!context) return messages;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -2241,7 +2382,7 @@ ${request.slice(0, 2e3)}
         `<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."
+        "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? For a task that changed code, completion also requires tests covering the change when the project has a test setup, and a test run that actually passed \u2014 a reply that claims success without an observed green check is not complete. 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();
@@ -2341,6 +2482,29 @@ var AgentLoop = class {
   // (the tool map's share of the request window) is computed alongside since
   // it depends on the same inputs.
   aiToolsCache = null;
+  // Server-calibration baseline for the context estimate: the latest finish
+  // event's provider-reported promptTokens paired with the local estimate of
+  // the exact request that produced it. Non-OpenAI tokenizers can count the
+  // same history far higher than the local cl100k estimate (a qwen endpoint
+  // counted ~30% more on a Chinese-heavy code session), which let the ctx%
+  // display and the auto-compaction trigger lag the real window fill until
+  // the provider itself started truncating replies. The delta refreshes on
+  // every step's finish, so drift is bounded to one step's new content.
+  serverTokenBaseline = null;
+  // Text streamed by the in-flight reply (visible text + reasoning +
+  // completed tool-call args). estimateContextTokens folds a rough token
+  // estimate of it into the status-bar ctx% so the display tracks the
+  // server's real-time occupancy — prompt PLUS generated-so-far, which is
+  // what llama.cpp-style monitors show — instead of lagging it by the whole
+  // in-flight generation (10k reasoning tokens ≈ 8% of a 128k window).
+  // Reset when each stream attempt ends: the persisted reply is then counted
+  // through the history estimate, and reasoning — never resent — drops out.
+  // User steering prompts submitted while a turn is running (the REPL's
+  // "insert now" choice). Drained into the history as synthetic user
+  // messages at the next step boundary — the in-flight model reply and its
+  // tool calls always finish first, so a steer never interrupts mid-step.
+  pendingSteers = [];
+  inflightStreamText = "";
   // Lazily resolved auxiliary model (config.smallModel) for cheap side calls
   // — compaction summaries, session titles, completion checks. Undefined =
   // use the main model; a resolution failure is surfaced once as a notice.
@@ -2391,6 +2555,9 @@ var AgentLoop = class {
         })
       );
     }
+    if (opts.readOnly && depth > 0) {
+      opts.registry?.retain((tool) => tool.permission === "read");
+    }
   }
   // CoreMessage view of the history (meta stripped): what the model, the
   // display and the token estimator consume. Element identity is preserved,
@@ -2403,12 +2570,56 @@ var AgentLoop = class {
   getStarMessages() {
     return this.messages;
   }
+  // Queue a user steering prompt for the running turn. Delivery happens at
+  // the next step boundary (see drainSteers); if the turn ends first the
+  // text stays queued and takeUndeliveredSteers hands it back to the caller.
+  injectUserMessage(text) {
+    const trimmed = text.trim();
+    if (trimmed.length > 0) this.pendingSteers.push(trimmed);
+  }
+  // Steers that never reached a step boundary (turn ended, aborted or
+  // errored first). The caller decides their fate — the REPL re-queues them
+  // as ordinary prompts so user input is never dropped.
+  takeUndeliveredSteers() {
+    return this.pendingSteers.splice(0);
+  }
+  // Append queued steers to the history as synthetic user messages: they
+  // belong to the turn in progress, so /undo, /rewind and compaction must
+  // not treat them as turn boundaries. Returns the number delivered.
+  async drainSteers() {
+    const steers = this.pendingSteers.splice(0);
+    for (const text of steers) {
+      const message = { role: "user", content: text };
+      const meta = { synthetic: "steer" };
+      this.messages.push({ message, meta });
+      await this.persist(message, meta);
+    }
+    return steers.length;
+  }
   // Wire-schema token overhead of the active tool set (memoized by
   // buildAiTools). The auto-compact budget includes it; surfaced here so the
   // status bar ctx% can show the same total the compaction decision uses.
   getToolSchemaTokens() {
     return this.buildAiTools().schemaTokens;
   }
+  // Additive correction from serverTokenBaseline, clamped ≥ 0: an
+  // under-reading provider estimate must pull compaction earlier (the bug
+  // this fixes), but an over-reading one must never push it later than the
+  // local estimate alone would — compacting early is safe, late is fatal.
+  calibrationDelta() {
+    const baseline = this.serverTokenBaseline;
+    if (!baseline) return 0;
+    return Math.max(0, baseline.serverTokens - baseline.localTokens);
+  }
+  // Effective context-window usage in tokens: local BPE estimate + tool
+  // schemas + the server-calibration delta + the in-flight reply's streamed
+  // output. This is the status bar's live ctx% view; the elision/compaction
+  // budgets deliberately use only the first three (history + schemas +
+  // calibration), since in-flight reasoning is never resent and must not
+  // trigger a compaction the next request won't need.
+  estimateContextTokens() {
+    return estimateTokens(this.getMessages()) + this.getToolSchemaTokens() + this.calibrationDelta() + (this.inflightStreamText.length > 0 ? roughTextTokens(this.inflightStreamText) : 0);
+  }
   // Auxiliary model for cheap side calls: config.smallModel, resolved once.
   // An unresolvable name/key degrades to the main model instead of breaking
   // turns; the failure rides out once as a notice at the next turn start.
@@ -2748,6 +2959,9 @@ var AgentLoop = class {
     let usedToolsThisTurn = false;
     let streamCutContinues = 0;
     let openTodos = [];
+    let todoRevision = this.opts.registry.todos.revision;
+    let stepsSinceTodoChange = 0;
+    const todoStaleNudgeSteps = this.opts.todoStaleNudgeSteps ?? TODO_STALE_NUDGE_STEPS;
     const maxSteps = config.maxSteps;
     let step = 0;
     let toolExecutedSinceCheckpoint = false;
@@ -2784,9 +2998,47 @@ ${finished.result}`
           await this.persist(note, meta);
         }
       }
+      const steered = await this.drainSteers();
+      if (steered > 0) {
+        yield {
+          type: "notice",
+          message: `${steered} steering message(s) delivered to the model; taking effect from this step.`
+        };
+      }
+      const currentTodoRevision = registry.todos.revision;
+      if (currentTodoRevision !== todoRevision) {
+        todoRevision = currentTodoRevision;
+        stepsSinceTodoChange = 0;
+      } else if (stepsSinceTodoChange >= todoStaleNudgeSteps) {
+        const open = registry.todos.list().filter((t) => t.status !== "done");
+        if (open.length > 0) {
+          stepsSinceTodoChange = 0;
+          yield {
+            type: "notice",
+            message: `todo list unchanged for ${todoStaleNudgeSteps} steps with ${open.length} open item(s); reminding the model to update it.`
+          };
+          const reminder = {
+            role: "user",
+            content: `[todo reminder] Your todo list still has ${open.length} open item(s), unchanged for ${todoStaleNudgeSteps} steps: ${open.slice(0, 5).map((t) => `"${t.title}"`).join(
+              ", "
+            )}${open.length > 5 ? ", \u2026" : ""}. Update the list with todo_write so it reflects what is done and what you are working on now, then continue working.`
+          };
+          const meta = { synthetic: "nudge" };
+          this.messages.push({ message: reminder, meta });
+          await this.persist(reminder, meta);
+        }
+      }
       const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
-      const compacted = compactMessages(this.messages, resolveCompactThreshold(config, maxTokens), {
-        overheadTokens: toolSchemaTokens
+      const threshold = resolveCompactThreshold(config, maxTokens);
+      const calibration = this.calibrationDelta();
+      const elided = elideStaleContent(this.messages, threshold, toolSchemaTokens + calibration);
+      if (elided) {
+        this.messages = elided.messages;
+        await this.opts.sessionStore?.replaceMessages([...this.messages]);
+        this.opts.registry?.resetVolatileState();
+      }
+      const compacted = compactMessages(this.messages, threshold, {
+        overheadTokens: toolSchemaTokens + calibration
       });
       if (compacted.compacted) {
         this.messages = await this.applyCompactionSummary(compacted, signal);
@@ -2794,6 +3046,7 @@ ${finished.result}`
         this.turnMarkers = [];
         this.opts.registry?.resetVolatileState();
       }
+      const requestLocalTokens = estimateTokens(this.getMessages()) + toolSchemaTokens;
       const maxRetries = Math.max(0, config.streamMaxRetries);
       const baseDelay = this.opts.retryDelayMs ?? STREAM_RETRY_BASE_DELAY_MS;
       let text = "";
@@ -2814,22 +3067,37 @@ ${finished.result}`
         lastUsage = void 0;
         sawReasoning = false;
         wasTruncated = false;
+        this.inflightStreamText = "";
         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;
+              this.inflightStreamText += event.text;
               yield event;
             } else if (event.type === "reasoning") {
               sawReasoning = true;
+              this.inflightStreamText += event.text;
               yield event;
             } else if (event.type === "tool-call") {
-              toolCalls.push({ id: event.id, name: event.name, args: event.args });
+              this.inflightStreamText += JSON.stringify(event.args ?? null);
+              toolCalls.push({
+                id: event.id,
+                name: event.name,
+                args: event.args,
+                ...event.invalidArgs !== void 0 ? { invalidArgs: event.invalidArgs } : {}
+              });
               yield event;
             } else if (event.type === "finish") {
               lastFinishReason = event.finishReason;
               if (event.truncated) wasTruncated = true;
               lastUsage = event.usage;
+              if (event.usage && event.usage.promptTokens > 0) {
+                this.serverTokenBaseline = {
+                  localTokens: requestLocalTokens,
+                  serverTokens: event.usage.promptTokens
+                };
+              }
               yield this.foldSubagentUsage(event);
             } else if (event.type === "error") {
               failure = event.error;
@@ -2842,6 +3110,7 @@ ${finished.result}`
             failure = toStreamErrorInfo(error);
           }
         }
+        this.inflightStreamText = "";
         if (signal.aborted) {
           yield* this.persistInterrupted(text, toolCalls);
           await this.runStopHooks("aborted");
@@ -2894,6 +3163,14 @@ ${finished.result}`
         return;
       }
       if (!hasOutput()) {
+        const steered2 = await this.drainSteers();
+        if (steered2 > 0) {
+          yield {
+            type: "notice",
+            message: `${steered2} steering message(s) delivered to the model after an empty reply.`
+          };
+          continue;
+        }
         if (isSteerableEmptyFinish(lastFinishReason) && config.permissionMode !== "plan" && autoContinues < config.maxAutoContinues) {
           autoContinues++;
           lastWasNudge = true;
@@ -2935,6 +3212,16 @@ ${finished.result}`
       this.messages.push({ message: assistantMessage });
       await this.persist(assistantMessage);
       if (toolCalls.length === 0) {
+        const steered2 = await this.drainSteers();
+        if (steered2 > 0) {
+          autoContinues = 0;
+          lastWasNudge = false;
+          yield {
+            type: "notice",
+            message: `${steered2} steering message(s) delivered to the model; the turn continues.`
+          };
+          continue;
+        }
         if (wasTruncated) {
           if (config.permissionMode !== "plan" && streamCutContinues < config.streamMaxRetries) {
             streamCutContinues++;
@@ -3019,10 +3306,12 @@ ${finished.result}`
         turnTreeReady = null;
       }
       const answered = /* @__PURE__ */ new Set();
+      const pendingImages = [];
       try {
         for (const call of toolCalls) {
           if (signal.aborted) break;
-          const refusal = this.doomLoopRefusal(call);
+          const refusal = call.invalidArgs !== void 0 ? `Tool call not executed \u2014 ${call.invalidArgs}
+Reissue ${call.name} with valid arguments.` : this.doomLoopRefusal(call);
           if (refusal !== null) {
             yield { type: "notice", message: refusal };
           } else {
@@ -3058,9 +3347,7 @@ ${finished.result}`
                 }))
               ]
             };
-            const meta = { synthetic: "tool-image" };
-            this.messages.push({ message: imageMessage, meta });
-            await this.persist(imageMessage, meta);
+            pendingImages.push({ message: imageMessage, meta: { synthetic: "tool-image" } });
           }
           if (call.name === "todo_write" && !result.isError) {
             openTodos = pendingTodoTitles(call.args);
@@ -3093,12 +3380,18 @@ ${finished.result}`
           });
           yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
         }
+        for (const { message, meta } of pendingImages) {
+          this.messages.push({ message, meta });
+          await this.persist(message, meta).catch(() => {
+          });
+        }
       }
       if (signal.aborted) {
         await this.runStopHooks("aborted");
         return;
       }
       step++;
+      stepsSinceTodoChange++;
     }
   }
   // The permission mode can change at runtime, so the system message is
@@ -3412,4 +3705,4 @@ export {
   attachTurnContext,
   AgentLoop
 };
-//# sourceMappingURL=chunk-RE3NOULF.js.map
+//# sourceMappingURL=chunk-63CGUF3F.js.map