@cryer/star-cli 0.3.12 → 0.3.14

package/dist/{chunk-F5RWZMQY.js → chunk-4HANB3DJ.js}

@@ -2,6 +2,7 @@
 import {
   INTERRUPTED_TOOL_RESULT_TEXT,
   UNFINISHED_TOOL_RESULT_TEXT,
+  computeCostUsd,
   coreMessageText,
   diffTreeNames,
   isSyntheticUserMessage,
@@ -12,11 +13,11 @@ import {
   toCoreMessages,
   toStarMessage,
   trackTree
-} from "./chunk-MYHD3SZB.js";
+} from "./chunk-CECMCDZG.js";
 import {
   createModel,
   streamActivity
-} from "./chunk-MVAMPVTA.js";
+} from "./chunk-KILMI3S5.js";
 import {
   resolveModelConfig
 } from "./chunk-4IRY44TG.js";
@@ -24,7 +25,7 @@ import {
   ToolRegistry,
   createDefaultRegistry,
   debugStreamLog
-} from "./chunk-Q5FJN4LN.js";
+} from "./chunk-54KH4JSO.js";
 import {
   TodoStore,
   beginTurn,
@@ -32,6 +33,7 @@ import {
   defaultAgentTasks,
   dropTurnSnapshots,
   isOversizedImageError,
+  isSecretEnvName,
   isSensitivePath,
   isVisionUnsupportedError,
   pendingTodoTitles,
@@ -43,7 +45,7 @@ import {
   stripOversizedImages,
   undoTurnSnapshots,
   userMemoryPath
-} from "./chunk-LSYGHLRU.js";
+} from "./chunk-2ISBRSBA.js";
 
 // src/agent/loop.ts
 import { tool as aiTool, generateText as generateText3 } from "ai";
@@ -146,6 +148,157 @@ function estimateToolSchemaTokens(tools) {
   return tokens;
 }
 
+// src/context/elision.ts
+var DEFAULT_ELISION_ACTIVATION_FRACTION = 0.5;
+var DEFAULT_ELISION_KEEP_RECENT_MESSAGES = 24;
+var DEFAULT_ELISION_MIN_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, options = {}) {
+  const activationFraction = options.activationFraction ?? DEFAULT_ELISION_ACTIVATION_FRACTION;
+  const keepRecentMessages = options.keepRecentMessages ?? DEFAULT_ELISION_KEEP_RECENT_MESSAGES;
+  const minTokens = options.minTokens ?? DEFAULT_ELISION_MIN_TOKENS;
+  let total = overheadTokens;
+  for (const star of messages) total += estimateMessageTokens(star.message);
+  if (total < thresholdTokens * activationFraction) return null;
+  const cutoff = messages.length - keepRecentMessages;
+  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) < minTokens) 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) < minTokens) 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 };
+}
+var ELIDED_ASSISTANT_TEXT = "[assistant content elided by emergency context reduction]";
+function isElidedToolCallArgs(args) {
+  return args !== null && typeof args === "object" && args.elided === ELIDED_TOOL_CALL_ARGS_TEXT;
+}
+function emergencyElideMessage(star) {
+  const message = star.message;
+  if (message.role === "system") return null;
+  if (message.role === "tool") {
+    if (message.content.every((part) => part.result === ELIDED_TOOL_RESULT_TEXT)) return null;
+    return {
+      message: {
+        ...message,
+        content: message.content.map((part) => ({
+          ...part,
+          result: ELIDED_TOOL_RESULT_TEXT
+        }))
+      },
+      meta: { ...star.meta, elided: true }
+    };
+  }
+  if (message.role === "user") {
+    if (!Array.isArray(message.content)) return null;
+    if (!message.content.some((part) => part.type === "image" || part.type === "file")) {
+      return null;
+    }
+    return {
+      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 }
+    };
+  }
+  if (typeof message.content === "string") {
+    if (message.content === ELIDED_ASSISTANT_TEXT) return null;
+    return {
+      message: { ...message, content: ELIDED_ASSISTANT_TEXT },
+      meta: { ...star.meta, elided: true }
+    };
+  }
+  let changed = false;
+  const content = message.content.map((part) => {
+    if (part.type === "tool-call" && !isElidedToolCallArgs(part.args)) {
+      changed = true;
+      return { ...part, args: { elided: ELIDED_TOOL_CALL_ARGS_TEXT } };
+    }
+    if ((part.type === "text" || part.type === "reasoning") && part.text !== ELIDED_ASSISTANT_TEXT) {
+      changed = true;
+      return { ...part, text: ELIDED_ASSISTANT_TEXT };
+    }
+    return part;
+  });
+  if (!changed) return null;
+  return { message: { ...message, content }, meta: { ...star.meta, elided: true } };
+}
+function emergencyElideContent(messages, maxTokens, overheadTokens = 0, options = {}) {
+  const minTokens = options.minTokens ?? 1;
+  const out = messages.slice();
+  const tokens = messages.map((star) => estimateMessageTokens(star.message));
+  let estimatedTokens = overheadTokens;
+  for (const count of tokens) estimatedTokens += count;
+  let elidedCount = 0;
+  const floors = minTokens < DEFAULT_ELISION_MIN_TOKENS ? [DEFAULT_ELISION_MIN_TOKENS, minTokens] : [minTokens];
+  for (const floor of floors) {
+    for (let i = 0; i < out.length && estimatedTokens > maxTokens; i++) {
+      const star = out[i];
+      if (!star || (tokens[i] ?? 0) < floor) continue;
+      const replacement = emergencyElideMessage(star);
+      if (!replacement) continue;
+      const replacementTokens = estimateMessageTokens(replacement.message);
+      if (replacementTokens >= (tokens[i] ?? 0)) continue;
+      out[i] = replacement;
+      estimatedTokens += replacementTokens - (tokens[i] ?? 0);
+      elidedCount++;
+    }
+  }
+  return {
+    messages: out,
+    elidedCount,
+    estimatedTokens,
+    withinBudget: estimatedTokens <= maxTokens
+  };
+}
+
 // src/context/compaction.ts
 var MIN_KEPT_MESSAGES = 4;
 function placeholderMessage(droppedCount) {
@@ -226,20 +379,22 @@ function serializeSummaryInput(messages) {
 [... ${total - MAX_SUMMARY_INPUT_CHARS} characters omitted ...]
 ${tail}`;
 }
-async function summarizeMessages(messages, model, signal, temperature) {
+async function summarizeMessages(messages, model, signal, temperature, onUsage) {
   const transcript = serializeSummaryInput(messages);
-  const { text } = await generateText({
+  const { text, usage } = await generateText({
     model,
     system: SUMMARY_SYSTEM_PROMPT,
     prompt: `Summarize this conversation so far:
 
 ${transcript}`,
     temperature,
+    maxRetries: 0,
     // A hung relay must not stall the whole turn on the summary: cap it at
     // 60s and let the caller's abort (Esc) cut it short as well; the caller
     // falls back to the truncation placeholder on any failure.
     abortSignal: signal ? AbortSignal.any([signal, AbortSignal.timeout(6e4)]) : AbortSignal.timeout(6e4)
   });
+  onUsage?.(usage);
   return text.trim();
 }
 function compactMessages(messages, maxTokens, opts = {}) {
@@ -297,69 +452,6 @@ 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;
@@ -374,6 +466,19 @@ function toStreamErrorInfo(error) {
     if (typeof raw.statusCode === "number") info2.statusCode = raw.statusCode;
     if (typeof raw.status === "number") info2.statusCode = raw.status;
     if (typeof raw.code === "string") info2.code = raw.code;
+    if (raw.isRetryable === true) info2.isRetryable = true;
+    const causeCode2 = raw.cause && typeof raw.cause === "object" ? raw.cause.code : void 0;
+    if (typeof causeCode2 === "string") info2.causeCode = causeCode2;
+    if (raw.responseHeaders && typeof raw.responseHeaders === "object") {
+      const strings = {};
+      for (const [key, value] of Object.entries(raw.responseHeaders)) {
+        if (typeof value === "string") strings[key] = value;
+      }
+      if (Object.keys(strings).length > 0) info2.responseHeaders = strings;
+    }
+    if (typeof raw.responseBody === "string" && raw.responseBody.length > 0) {
+      info2.responseBody = raw.responseBody;
+    }
     return info2;
   }
   const err = error instanceof Error ? error : new Error(String(error));
@@ -400,7 +505,7 @@ function toStreamErrorInfo(error) {
 }
 
 // src/core/git.ts
-import { execFileSync } from "child_process";
+import { execFile, execFileSync } from "child_process";
 var GIT_TIMEOUT_MS = 2e3;
 var GIT_MAX_BUFFER = 8 * 1024 * 1024;
 var COMMIT_DIFF_MAX_LINES = 2e3;
@@ -440,6 +545,47 @@ function getGitSummaryCached(cwd) {
   gitSummaryCache.set(cwd, { at: now, summary });
   return summary;
 }
+function runGitAsync(args, cwd) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      {
+        cwd,
+        timeout: GIT_TIMEOUT_MS,
+        encoding: "utf8",
+        maxBuffer: GIT_MAX_BUFFER
+      },
+      (error, stdout) => resolve(error ? null : stdout.replace(/\n$/, ""))
+    );
+  });
+}
+var gitSummaryPending = /* @__PURE__ */ new Map();
+function getGitSummaryCachedAsync(cwd) {
+  const now = Date.now();
+  const hit = gitSummaryCache.get(cwd);
+  if (hit && now - hit.at < GIT_SUMMARY_CACHE_TTL_MS) return Promise.resolve(hit.summary);
+  const pending = gitSummaryPending.get(cwd);
+  if (pending) return pending;
+  const task = (async () => {
+    const branch = await runGitAsync(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    if (branch === null) {
+      gitSummaryCache.set(cwd, { at: Date.now(), summary: null });
+      return null;
+    }
+    const status = await runGitAsync(["status", "--porcelain"], cwd) ?? "";
+    const log = await runGitAsync(["log", "--oneline", "-3"], cwd) ?? "";
+    const summary = {
+      branch,
+      dirtyCount: status === "" ? 0 : status.split("\n").length,
+      recentCommits: log === "" ? [] : log.split("\n")
+    };
+    gitSummaryCache.set(cwd, { at: Date.now(), summary });
+    return summary;
+  })().finally(() => gitSummaryPending.delete(cwd));
+  gitSummaryPending.set(cwd, task);
+  return task;
+}
 function formatGitSummary(summary) {
   const lines = [
     "Git context for the working directory (refreshed each turn):",
@@ -574,6 +720,10 @@ function runCommand(hook, event, ctx, timeoutSec) {
       child.stdin.on("error", () => {
       });
       child.stdin.end(inputJson);
+    } else {
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end();
     }
     let stderr = "";
     const stderrDecoder = new StringDecoder("utf8");
@@ -674,7 +824,9 @@ var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
   "EPIPE",
   "EAI_AGAIN",
   "ENOTFOUND",
-  "ECONNABORTED"
+  "ECONNABORTED",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
 ]);
 function isNetworkFailure(error) {
   for (const code of [error.code, error.causeCode]) {
@@ -1088,7 +1240,16 @@ function lexShell(command) {
       while (end < command.length && /[A-Za-z0-9_]/.test(command[end] ?? "")) {
         end += 1;
       }
-      word += command.slice(pos, end);
+      let name = command.slice(pos + 1, end);
+      if (name.toLowerCase() === "env" && command[end] === ":" && /[A-Za-z_]/.test(command[end + 1] ?? "")) {
+        let varEnd = end + 1;
+        while (varEnd < command.length && /[A-Za-z0-9_]/.test(command[varEnd] ?? "")) {
+          varEnd += 1;
+        }
+        name = command.slice(end + 1, varEnd);
+        end = varEnd;
+      }
+      word += `$${name}`;
       return end;
     }
     word += "$";
@@ -1101,8 +1262,9 @@ function lexShell(command) {
         doubleQuoted = false;
         i += 1;
       } else if (c === "\\") {
-        if (i + 1 < command.length) {
-          word += command[i + 1];
+        const nextCh = command[i + 1];
+        if (nextCh !== void 0 && (nextCh === "$" || nextCh === "`" || nextCh === '"' || nextCh === "\\")) {
+          word += nextCh;
           i += 2;
         } else {
           word += "\\";
@@ -1213,6 +1375,7 @@ function splitShellSegments(tokens) {
   }
   return segments;
 }
+var DYNAMIC_SHELL_WORD = "\0star-dynamic-word\0";
 function segmentWords(segment) {
   const words = [];
   const redirectTargets = [];
@@ -1223,11 +1386,16 @@ function segmentWords(segment) {
       if (target?.kind === "word") {
         redirectTargets.push(target.text);
         k += 1;
+      } else if (target?.kind === "subst") {
+        redirectTargets.push(DYNAMIC_SHELL_WORD);
+        k += 1;
       }
       continue;
     }
     if (token.kind === "word") {
       words.push(token.text);
+    } else if (token.kind === "subst") {
+      words.push(DYNAMIC_SHELL_WORD);
     }
   }
   return { words, redirectTargets };
@@ -1362,25 +1530,67 @@ var EGRESS_COMMANDS = /* @__PURE__ */ new Set([
   "scp",
   "sftp",
   "ftp",
-  "telnet"
+  "telnet",
+  "dig",
+  "nslookup",
+  "host",
+  "certutil",
+  "bitsadmin",
+  "iwr",
+  "irm",
+  "invoke-webrequest",
+  "invoke-restmethod"
 ]);
 var BLOCK_DEVICE = /^\/dev\/(?:sd[a-z]+\d*|xvd[a-z]+\d*|vd[a-z]+\d*|hd[a-z]+\d*|nvme\d+n\d+(?:p\d+)?|mmcblk\d+(?:p\d+)?)$/i;
 function baseName(word) {
   const base = word.replace(/\\/g, "/").split("/").pop() ?? word;
   return base.toLowerCase().replace(/\.exe$/, "");
 }
+function isDynamicTarget(target) {
+  return target.includes(DYNAMIC_SHELL_WORD) || /\$[A-Za-z_]/.test(target) || /%[A-Za-z_][A-Za-z0-9_]*%/.test(target);
+}
 function isDangerousDeleteTarget(target) {
+  if (isDynamicTarget(target)) return true;
   if (/^\/+$/.test(target)) return true;
   const norm = target.replace(/\\/g, "/").replace(/\/+$/, "");
   if (norm === "/*" || norm === "*") return true;
   if (norm === "~" || norm.startsWith("~/") || /^~[^/]/.test(norm)) return true;
   if (norm === "." || norm === "./*") return true;
   if (/^[a-zA-Z]:$/.test(norm)) return true;
-  const homeVars = ["$HOME", "$USERPROFILE", "$HOMEPATH"];
-  if (homeVars.includes(norm)) return true;
-  if (homeVars.some((v) => norm.startsWith(`${v}/`))) return true;
-  if (/^%(USERPROFILE|HOMEDRIVE|HOMEPATH)%$/i.test(norm)) return true;
-  if (/^%(USERPROFILE|HOMEPATH)%\//i.test(norm)) return true;
+  if (/^\/[a-zA-Z]$/.test(norm)) return true;
+  const upper = norm.toUpperCase();
+  const homeVars = [
+    "$HOME",
+    "$USERPROFILE",
+    "$HOMEPATH",
+    "$APPDATA",
+    "$LOCALAPPDATA",
+    "$PROGRAMDATA",
+    "$PROGRAMFILES",
+    "$SYSTEMROOT"
+  ];
+  if (homeVars.includes(upper)) return true;
+  if (homeVars.some((v) => upper.startsWith(`${v}/`))) return true;
+  if (/^%(USERPROFILE|HOMEDRIVE|HOMEPATH|APPDATA|LOCALAPPDATA|SYSTEMROOT|PROGRAMDATA|PROGRAMFILES|PROGRAMFILES\(X86\))%$/i.test(
+    norm
+  ))
+    return true;
+  if (/^%(USERPROFILE|HOMEPATH|APPDATA|LOCALAPPDATA|SYSTEMROOT|PROGRAMDATA|PROGRAMFILES|PROGRAMFILES\(X86\))%\//i.test(
+    norm
+  ))
+    return true;
+  const win = /^(?:[a-zA-Z]:|\/[a-zA-Z])\/(.+)$/.exec(norm);
+  if (win) {
+    const rest = (win[1] ?? "").toLowerCase();
+    if (/^(?:windows|program files(?: \(x86\))?|programdata|boot|recovery|system volume information)(?:\/|$)/.test(
+      rest
+    )) {
+      return true;
+    }
+    if (/^users(?:\/[^/]+)?$/.test(rest)) return true;
+  }
+  if (/^\/(?:etc|usr|bin|sbin|lib|lib64|boot|opt|var|srv|sys|proc|dev)$/.test(norm)) return true;
+  if (/^\/(?:home|root)(?:\/[^/]+)?$/.test(norm)) return true;
   return false;
 }
 function rmIsDangerous(args) {
@@ -1614,7 +1824,7 @@ function decodePowerShellEncoded(encoded) {
 }
 function segmentIsDangerous(segment, depth, lex) {
   const { words, redirectTargets } = segmentWords(segment);
-  if (redirectTargets.some((target) => BLOCK_DEVICE.test(target))) {
+  if (redirectTargets.some((target) => isDynamicTarget(target) || BLOCK_DEVICE.test(target))) {
     return true;
   }
   const invocation = commandInvocation(words);
@@ -1656,10 +1866,10 @@ function segmentIsDangerous(segment, depth, lex) {
       return recursive && targets.some(isDangerousDeleteTarget);
     }
     case "format":
-      return rest.some((arg) => /^[a-z]:$/i.test(arg));
+      return rest.some((arg) => isDynamicTarget(arg) || /^[a-z]:$/i.test(arg));
     case "dd":
       return rest.some(
-        (arg) => arg.startsWith("if=") || arg.startsWith("of=") && BLOCK_DEVICE.test(arg.slice(3))
+        (arg) => arg.startsWith("if=") || arg.startsWith("of=") && (isDynamicTarget(arg.slice(3)) || BLOCK_DEVICE.test(arg.slice(3)))
       );
     case "find":
       return findIsDangerous(rest, depth, lex);
@@ -1740,6 +1950,10 @@ function tokenTouchesSensitivePath(word) {
   }
   return isSensitivePath(word);
 }
+function tokenReferencesSecretEnv(word) {
+  const m = /\$([A-Za-z_][A-Za-z0-9_]*)/.exec(word);
+  return m !== null && isSecretEnvName(m[1]);
+}
 function bashHygiene(command, lex) {
   let sensitive = false;
   let egress = false;
@@ -1751,7 +1965,7 @@ function bashHygiene(command, lex) {
     for (const segment of splitShellSegments(tokens)) {
       const { words, redirectTargets } = segmentWords(segment);
       for (const word of [...words, ...redirectTargets]) {
-        if (tokenTouchesSensitivePath(word)) sensitive = true;
+        if (tokenTouchesSensitivePath(word) || tokenReferencesSecretEnv(word)) sensitive = true;
       }
       const invocation = commandInvocation(words);
       if (!invocation) continue;
@@ -1765,6 +1979,20 @@ function bashHygiene(command, lex) {
         script = idx >= 0 ? invocation.rest.slice(idx + 1).join(" ") : void 0;
       } else if (invocation.name === "eval" && invocation.rest.length > 0) {
         script = invocation.rest.join(" ");
+      } else if (invocation.name === "powershell" || invocation.name === "pwsh") {
+        for (let k = 0; k < invocation.rest.length; k += 1) {
+          const arg = invocation.rest[k];
+          if (/^-(c|command)$/i.test(arg)) {
+            const joined = invocation.rest.slice(k + 1).join(" ");
+            script = joined.length > 0 ? joined : void 0;
+            break;
+          }
+          if (/^-(enc|encodedcommand)$/i.test(arg)) {
+            const encoded = invocation.rest[k + 1];
+            script = encoded === void 0 ? void 0 : decodePowerShellEncoded(encoded) ?? void 0;
+            break;
+          }
+        }
       }
       if (script !== void 0) visit(lexCached(lex, script), depth + 1);
     }
@@ -1940,21 +2168,23 @@ function sanitizeTitle(raw) {
   } while (title !== previous);
   return title.slice(0, TITLE_MAX_CHARS).trim();
 }
-async function generateSessionTitle(userText, model) {
-  const { text } = await generateText2({
+async function generateSessionTitle(userText, model, onUsage) {
+  const { text, usage } = await generateText2({
     model,
     system: TITLE_SYSTEM_PROMPT,
     prompt: userText.slice(0, TITLE_INPUT_MAX_CHARS),
     maxTokens: TITLE_MAX_TOKENS,
+    maxRetries: 0,
     abortSignal: AbortSignal.timeout(TITLE_TIMEOUT_MS)
   });
+  onUsage?.(usage);
   return sanitizeTitle(text);
 }
-function scheduleSessionTitle(store, userText, model) {
+function scheduleSessionTitle(store, userText, model, onUsage) {
   void (async () => {
     const meta = await store.meta();
     if (meta.title) return;
-    const title = await generateSessionTitle(userText, model);
+    const title = await generateSessionTitle(userText, model, onUsage);
     if (!title) return;
     const current = await store.meta();
     if (current.title) return;
@@ -2123,44 +2353,8 @@ 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. 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);
-  const toCfg = findModelPricing(config, names?.toName, to.modelId);
-  if (fromCfg?.promptPrice === void 0 || fromCfg.completionPrice === void 0 || toCfg?.promptPrice === void 0 || toCfg.completionPrice === void 0 || toCfg.promptPrice <= 0 || toCfg.completionPrice <= 0) {
-    return usage;
-  }
-  const cached = Math.min(Math.max(usage.cachedPromptTokens ?? 0, 0), usage.promptTokens);
-  const promptUsd = (usage.promptTokens - cached) * fromCfg.promptPrice;
-  const cachedUsd = cached * (fromCfg.cacheReadPrice ?? fromCfg.promptPrice);
-  const cacheReadUsd = (usage.cacheReadInputTokens ?? 0) * (fromCfg.cacheReadPrice ?? 0);
-  const completionUsd = usage.completionTokens * fromCfg.completionPrice;
-  const scaledCached = cachedUsd / (toCfg.cacheReadPrice ?? toCfg.promptPrice);
-  const promptTokens = Math.round(promptUsd / toCfg.promptPrice + scaledCached);
-  const cachedPromptTokens = Math.round(scaledCached);
-  const toCacheReadPrice = toCfg.cacheReadPrice !== void 0 && toCfg.cacheReadPrice > 0 ? toCfg.cacheReadPrice : void 0;
-  const completionTokens = Math.round(
-    completionUsd / toCfg.completionPrice + (toCacheReadPrice === void 0 ? cacheReadUsd / toCfg.completionPrice : 0)
-  );
-  const cacheReadInputTokens = toCacheReadPrice === void 0 ? 0 : Math.round(cacheReadUsd / toCacheReadPrice);
-  const result = {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens
-  };
-  if (cachedPromptTokens > 0) result.cachedPromptTokens = cachedPromptTokens;
-  if (cacheReadInputTokens > 0) result.cacheReadInputTokens = cacheReadInputTokens;
-  return result;
-}
-function findModelPricing(config, name, modelId) {
-  if (name !== void 0) {
-    const byName = config.models.find((m) => m.name === name);
-    if (byName) return byName;
-  }
-  return config.models.find((m) => m.model === modelId);
-}
 async function runSubagent(deps, args, cwd, signal, agentIdRef) {
-  const { AgentLoop: AgentLoop2 } = await import("./loop-BYXBNFFY.js");
+  const { AgentLoop: AgentLoop2 } = await import("./loop-M64D5YII.js");
   const child = new AgentLoop2({
     model: deps.model,
     registry: createDefaultRegistry(),
@@ -2175,6 +2369,7 @@ ${READ_ONLY_PROMPT}` : ""}` : `${SUBAGENT_PROMPT}${args.read_only ? `
 ${READ_ONLY_PROMPT}` : ""}`,
     providerMetadata: deps.providerMetadata,
     temperature: deps.temperature,
+    maxTokens: deps.maxTokens,
     streamIdleTimeoutSec: deps.streamIdleTimeoutSec,
     streamFirstChunkTimeoutSec: deps.streamFirstChunkTimeoutSec,
     vision: deps.vision,
@@ -2376,15 +2571,16 @@ ${context}
   }
   return messages;
 }
-async function checkTaskComplete(model, request, finalReply, signal, temperature) {
+async function checkTaskComplete(model, request, finalReply, toolSummary, signal, temperature, onUsage) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), COMPLETION_CHECK_TIMEOUT_MS);
   const onAbort = () => controller.abort();
   signal.addEventListener("abort", onAbort, { once: true });
   try {
-    const { text } = await generateText3({
+    const { text, usage } = await generateText3({
       model,
       maxTokens: 8,
+      maxRetries: 0,
       temperature,
       abortSignal: controller.signal,
       prompt: [
@@ -2396,9 +2592,14 @@ ${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? 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."
+        "These are the actual tool outcomes, including failures:",
+        `<tool-outcomes>
+${toolSummary.slice(0, 6e3)}
+</tool-outcomes>`,
+        "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? Failed tools and missing verification mean the work is not complete even when the reply claims success. 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. Or is it only describing, planning, or reporting progress with work still left? Answer with exactly one word: DONE or NOT_DONE."
       ].join("\n")
     });
+    onUsage(usage);
     const verdict = text.trim().toUpperCase();
     if (verdict.startsWith("NOT_DONE")) return false;
     if (verdict.startsWith("DONE")) return true;
@@ -2462,15 +2663,6 @@ var AgentLoop = class {
   // each new user turn restarts the streak.
   lastToolSignature = null;
   repeatedToolCalls = 0;
-  // Token usage subagents consumed, waiting to fold into this loop's next
-  // finish event with usage: sync children report when their tool call
-  // settles, background ones whenever they finish (drained or not).
-  // Consumers meter only root-loop finish events, so folding here bills
-  // subagent spend with zero consumer changes — /cost, /usage and
-  // sessionBudgetUsd all cover it. A background child still running when the
-  // session's last finish has passed never reports (best effort, noted in
-  // agent-tasks cleanup paths).
-  subagentUsage = null;
   // Turn context of the in-flight stream() turn, stamped onto every tool
   // execution so file snapshots attribute root changes to a turn and mark
   // subagent changes as excluded from turn-level retraction.
@@ -2489,6 +2681,7 @@ var AgentLoop = class {
   // turn context string. Saves a full toCoreMessages + attachTurnContext copy
   // per stream attempt, which retried steps used to pay every time.
   requestMessagesCache = null;
+  historyTokenSnapshot = null;
   // Memoized per (registry, plan flag): tools register on the registry only
   // at loop construction, and the plan filter re-reads the live permission
   // mode on every call — so a built map stays valid until either input
@@ -2531,11 +2724,12 @@ var AgentLoop = class {
   // their stderr surfaces through this callback (REPL system message / stderr
   // in print mode).
   onHookWarning;
+  onUsage;
   constructor(opts) {
     this.opts = opts;
     const depth = opts.subagentDepth ?? 0;
     if (depth > 0) {
-      opts.registry = new ToolRegistry(new TodoStore());
+      opts.registry = new ToolRegistry(new TodoStore({ persistence: "memory" }));
     } else {
       setTodoPersistGuard(() => {
         const mode = this.opts.config.permissionMode;
@@ -2551,6 +2745,7 @@ var AgentLoop = class {
     opts.registry?.register(createSkillTool({ cwd: opts.cwd }));
     opts.registry?.register(createRememberTool());
     if (opts.registry && depth < MAX_SUBAGENT_DEPTH) {
+      const subagentSessionStore = opts.sessionStore;
       opts.registry.register(
         createSubagentTool({
           model: opts.model,
@@ -2559,13 +2754,14 @@ var AgentLoop = class {
           system: opts.system,
           providerMetadata: opts.providerMetadata,
           temperature: opts.temperature,
+          maxTokens: opts.maxTokens,
           streamIdleTimeoutSec: opts.streamIdleTimeoutSec,
           streamFirstChunkTimeoutSec: opts.streamFirstChunkTimeoutSec,
           vision: opts.vision,
           depth,
           modelName: opts.modelName,
           getConfirmHandler: () => this.confirmHandler,
-          onUsage: (usage, childModel, childModelName) => this.addSubagentUsage(usage, childModel, childModelName)
+          onUsage: (usage, _childModel, childModelName) => this.recordUsage(usage, childModelName, subagentSessionStore)
         })
       );
     }
@@ -2631,8 +2827,25 @@ var AgentLoop = class {
   // 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.
+  historyTokens() {
+    const cached = this.historyTokenSnapshot;
+    if (cached?.source === this.messages && cached.length === this.messages.length) {
+      return cached.total;
+    }
+    let total = 0;
+    let start = 0;
+    if (cached?.source === this.messages && cached.length < this.messages.length) {
+      total = cached.total;
+      start = cached.length;
+    }
+    for (let i = start; i < this.messages.length; i++) {
+      total += estimateMessageTokens(this.messages[i]?.message ?? { role: "user", content: "" });
+    }
+    this.historyTokenSnapshot = { source: this.messages, length: this.messages.length, total };
+    return total;
+  }
   estimateContextTokens() {
-    return estimateTokens(this.getMessages()) + this.getToolSchemaTokens() + this.calibrationDelta() + (this.inflightStreamText.length > 0 ? roughTextTokens(this.inflightStreamText) : 0);
+    return this.historyTokens() + 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
@@ -2657,24 +2870,30 @@ var AgentLoop = class {
     this.resolveAuxModel();
     return this.auxModelValue ? this.auxTemperatureValue : this.opts.temperature;
   }
+  getAuxModelName() {
+    this.resolveAuxModel();
+    return this.auxModelValue && this.opts.config.smallModel ? this.opts.config.smallModel : this.opts.modelName ?? this.opts.model.modelId;
+  }
+  recordUsage(usage, modelName = this.opts.modelName ?? this.opts.model.modelId, store = this.opts.sessionStore) {
+    const normalized = { ...usage, totalTokens: usageTotalTokens(usage) };
+    const model = this.opts.config.models.find((entry) => entry.name === modelName);
+    const costUsd = computeCostUsd(normalized, model);
+    this.onUsage?.(normalized, modelName, costUsd);
+    void store?.addUsage(normalized, { modelName, costUsd }).catch(
+      (error) => this.onHookWarning?.(`failed to record token usage: ${String(error)}`)
+    );
+  }
   // Rebinds the per-call provider metadata (e.g. after the reasoning effort
   // for the current model changed via /model) without recreating the loop.
   setProviderMetadata(metadata) {
     this.opts.providerMetadata = metadata;
   }
   // Swaps the persistence target (/new starts a fresh session mid-REPL).
-  // Title generation is re-armed so the new session gets one after its first
-  // turn, and snapshot checkpoints now flow to the new store. The redo stack
-  // dies with the old session context: its trees describe working-tree states
-  // that no longer line up with the new session's conversation. Subagent
-  // usage still waiting to fold belongs to the old conversation too — it
-  // must not bill the new session's first finish.
   setSessionStore(store) {
     this.opts.sessionStore = store;
     this.titleScheduled = false;
     this.titleInput = void 0;
     this.redoStack = [];
-    this.subagentUsage = null;
     if (store) this.bindSnapshotHooks(store);
   }
   bindSnapshotHooks(store) {
@@ -2696,12 +2915,17 @@ var AgentLoop = class {
       onRemove: (ids) => store.removeCheckpoints(ids)
     });
   }
+  resetWholesaleHistoryState() {
+    this.serverTokenBaseline = null;
+    this.requestMessagesCache = null;
+    this.historyTokenSnapshot = null;
+    this.opts.registry?.resetVolatileState();
+  }
   async loadMessages(messages) {
     this.messages = reconcileStarMessages(messages.map(toStarMessage));
     this.turnMarkers = [];
     this.redoStack = [];
-    this.subagentUsage = null;
-    this.opts.registry?.resetVolatileState();
+    this.resetWholesaleHistoryState();
   }
   // Read-only counterpart of retractLastTurn: how many messages /undo would
   // drop, which snapshot turn's file changes it would revert (undefined =
@@ -2735,8 +2959,8 @@ var AgentLoop = class {
       REDO_LABEL_MAX
     );
     this.messages = result.messages;
-    await this.opts.sessionStore?.replaceMessages([...this.messages]);
-    this.opts.registry?.resetVolatileState();
+    await this.replacePersisted([...this.messages]);
+    this.resetWholesaleHistoryState();
     const last = this.turnMarkers[this.turnMarkers.length - 1];
     let turn;
     let tree;
@@ -2819,8 +3043,8 @@ var AgentLoop = class {
     const removed = this.messages.length - cut;
     if (removed === 0) return 0;
     this.messages = this.messages.slice(0, cut);
-    await this.opts.sessionStore?.replaceMessages([...this.messages]);
-    this.opts.registry?.resetVolatileState();
+    await this.replacePersisted([...this.messages]);
+    this.resetWholesaleHistoryState();
     this.turnMarkers = this.turnMarkers.filter((m) => m.userIndex < cut);
     this.redoStack = [];
     return removed;
@@ -2831,7 +3055,18 @@ var AgentLoop = class {
     await this.persist(message);
   }
   async persist(message, meta) {
-    await this.opts.sessionStore?.append(message, meta);
+    const store = this.opts.sessionStore;
+    if (!store) return;
+    if (!await store.append(message, meta) && !await store.recoverMessages()) {
+      throw new Error(`Session ${store.id} could not persist the message history`);
+    }
+  }
+  async replacePersisted(messages) {
+    const store = this.opts.sessionStore;
+    if (!store) return;
+    if (!await store.replaceMessages(messages) && !await store.recoverMessages()) {
+      throw new Error(`Session ${store.id} could not persist the rewritten history`);
+    }
   }
   // Replaces oversized image parts in the in-memory history with text
   // placeholders and rewrites the persisted session, so the failed request
@@ -2843,7 +3078,8 @@ var AgentLoop = class {
       message: messages[i] ?? star.message,
       meta: star.meta
     }));
-    await this.opts.sessionStore?.replaceMessages(this.messages);
+    await this.replacePersisted(this.messages);
+    this.resetWholesaleHistoryState();
     return removed;
   }
   // Same rewrite as above, but for text-only endpoints that reject any image
@@ -2856,7 +3092,8 @@ var AgentLoop = class {
       message: messages[i] ?? star.message,
       meta: star.meta
     }));
-    await this.opts.sessionStore?.replaceMessages(this.messages);
+    await this.replacePersisted(this.messages);
+    this.resetWholesaleHistoryState();
     return removed;
   }
   // Background title generation runs once per loop, fed by the first real
@@ -2872,7 +3109,12 @@ var AgentLoop = class {
     const input = this.titleInput;
     if (!input) return;
     this.titleScheduled = true;
-    scheduleSessionTitle(store, input, this.getAuxModel());
+    scheduleSessionTitle(
+      store,
+      input,
+      this.getAuxModel(),
+      (usage) => this.recordUsage(usage, this.getAuxModelName(), store)
+    );
   }
   // A user interrupt (Esc) ends the turn mid-stream, before the normal
   // assistant-message persistence runs. Whatever text and tool calls already
@@ -2910,8 +3152,7 @@ var AgentLoop = class {
         ]
       };
       this.messages.push({ message: synthetic });
-      await this.persist(synthetic).catch(() => {
-      });
+      await this.persist(synthetic);
       yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
     }
   }
@@ -2971,6 +3212,7 @@ var AgentLoop = class {
     let autoContinues = 0;
     let lastWasNudge = false;
     let usedToolsThisTurn = false;
+    const toolOutcomes = [];
     let streamCutContinues = 0;
     let openTodos = [];
     let todoRevision = this.opts.registry.todos.revision;
@@ -3043,24 +3285,57 @@ ${finished.result}`
         }
       }
       const maxTokens = this.opts.contextMaxTokens ?? config.contextMaxTokens;
-      const threshold = resolveCompactThreshold(config, maxTokens);
+      const outputReserve = Math.min(this.opts.maxTokens ?? 4096, Math.floor(maxTokens / 20));
+      const requestBudget = Math.max(1, maxTokens - outputReserve);
+      const threshold = Math.min(resolveCompactThreshold(config, maxTokens), requestBudget);
       const calibration = this.calibrationDelta();
-      const elided = elideStaleContent(this.messages, threshold, toolSchemaTokens + calibration);
+      const elided = elideStaleContent(this.messages, threshold, toolSchemaTokens + calibration, {
+        activationFraction: config.elisionThresholdFraction,
+        keepRecentMessages: config.elisionKeepRecentMessages,
+        minTokens: config.elisionMinTokens
+      });
       if (elided) {
         this.messages = elided.messages;
-        await this.opts.sessionStore?.replaceMessages([...this.messages]);
-        this.opts.registry?.resetVolatileState();
+        await this.replacePersisted([...this.messages]);
+        this.resetWholesaleHistoryState();
       }
       const compacted = compactMessages(this.messages, threshold, {
         overheadTokens: toolSchemaTokens + calibration
       });
       if (compacted.compacted) {
         this.messages = await this.applyCompactionSummary(compacted, signal);
-        await this.opts.sessionStore?.replaceMessages([...this.messages]);
+        await this.replacePersisted([...this.messages]);
         this.turnMarkers = [];
-        this.opts.registry?.resetVolatileState();
+        this.resetWholesaleHistoryState();
       }
-      const requestLocalTokens = estimateTokens(this.getMessages()) + toolSchemaTokens;
+      if (this.historyTokens() + toolSchemaTokens + calibration > requestBudget) {
+        const emergency = emergencyElideContent(
+          this.messages,
+          requestBudget,
+          toolSchemaTokens + calibration
+        );
+        if (emergency.elidedCount > 0) {
+          this.messages = emergency.messages;
+          await this.replacePersisted([...this.messages]);
+          this.resetWholesaleHistoryState();
+          yield {
+            type: "notice",
+            message: `Emergency context reduction elided ${emergency.elidedCount} oversized message(s).`
+          };
+        }
+        if (!emergency.withinBudget) {
+          yield {
+            type: "error",
+            error: {
+              name: "ContextLimitError",
+              message: `The request still exceeds the context window after compaction and emergency elision (${emergency.estimatedTokens}/${requestBudget} estimated tokens). Start a new session or use a model with a larger context window.`
+            }
+          };
+          await this.runStopHooks("error");
+          return;
+        }
+      }
+      const requestLocalTokens = this.historyTokens() + toolSchemaTokens;
       const maxRetries = Math.max(0, config.streamMaxRetries);
       const baseDelay = this.opts.retryDelayMs ?? STREAM_RETRY_BASE_DELAY_MS;
       let text = "";
@@ -3112,7 +3387,8 @@ ${finished.result}`
                   serverTokens: event.usage.promptTokens
                 };
               }
-              yield this.foldSubagentUsage(event);
+              if (event.usage) this.recordUsage(event.usage);
+              yield event;
             } else if (event.type === "error") {
               failure = event.error;
             } else {
@@ -3172,6 +3448,7 @@ ${finished.result}`
         }
       }
       if (failure) {
+        yield* this.persistInterrupted(text, toolCalls);
         yield { type: "error", error: failure };
         await this.runStopHooks("error");
         return;
@@ -3270,8 +3547,10 @@ ${finished.result}`
             this.getAuxModel(),
             inputText,
             text,
+            toolOutcomes.join("\n"),
             signal,
-            this.getAuxTemperature()
+            this.getAuxTemperature(),
+            (usage) => this.recordUsage(usage, this.getAuxModelName())
           );
           if (complete === false) {
             reason = "completion check reports the task unfinished";
@@ -3366,6 +3645,10 @@ Reissue ${call.name} with valid arguments.` : this.doomLoopRefusal(call);
           if (call.name === "todo_write" && !result.isError) {
             openTodos = pendingTodoTitles(call.args);
           }
+          toolOutcomes.push(
+            `${call.name} (${result.isError ? "failed" : "succeeded"}): ${result.content.slice(0, 500)}`
+          );
+          if (toolOutcomes.length > 20) toolOutcomes.shift();
           yield {
             type: "tool-result",
             id: call.id,
@@ -3390,8 +3673,7 @@ Reissue ${call.name} with valid arguments.` : this.doomLoopRefusal(call);
             ]
           };
           this.messages.push({ message: synthetic });
-          await this.persist(synthetic).catch(() => {
-          });
+          await this.persist(synthetic);
           yield { type: "tool-result", id: call.id, name: call.name, content, isError: true };
         }
         for (const { message, meta } of pendingImages) {
@@ -3453,7 +3735,8 @@ Reissue ${call.name} with valid arguments.` : this.doomLoopRefusal(call);
         dropped,
         this.getAuxModel(),
         signal,
-        this.getAuxTemperature()
+        this.getAuxTemperature(),
+        (usage) => this.recordUsage(usage, this.getAuxModelName())
       );
       if (summary.trim().length === 0) return compacted.messages;
       const messages = compacted.messages.slice();
@@ -3478,7 +3761,8 @@ ${summary}`
       providerMetadata: this.opts.providerMetadata,
       idleTimeoutMs: (this.opts.streamIdleTimeoutSec ?? this.opts.config.streamIdleTimeoutSec) * 1e3 * timeoutScale,
       firstPartTimeoutMs: (this.opts.streamFirstChunkTimeoutSec ?? this.opts.config.streamFirstChunkTimeoutSec) * 1e3 * timeoutScale,
-      temperature: this.opts.temperature
+      temperature: this.opts.temperature,
+      maxTokens: this.opts.maxTokens
     })) {
       if (event.type === "finish" && event.truncated) {
         yield {
@@ -3564,53 +3848,6 @@ ${summary}`
       return empty;
     }
   }
-  // Accumulates a settled subagent's usage. When the child provably ran on a
-  // different, fully priced model, the counts are first converted into
-  // this-model-priced equivalents (convertUsagePricing): session cost is
-  // token totals × the active model's price, so the conversion keeps the $
-  // estimate accurate where raw sums would misprice. Price lookup goes by
-  // the [[models]] entry names both loops were resolved from, not model id.
-  addSubagentUsage(usage, childModel, childModelName) {
-    const converted = convertUsagePricing(usage, childModel, this.opts.model, this.opts.config, {
-      fromName: childModelName,
-      toName: this.opts.modelName
-    });
-    const pending = this.subagentUsage ?? {
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: 0
-    };
-    pending.promptTokens += converted.promptTokens;
-    pending.completionTokens += converted.completionTokens;
-    pending.totalTokens += usageTotalTokens(converted);
-    if (converted.cachedPromptTokens) {
-      pending.cachedPromptTokens = (pending.cachedPromptTokens ?? 0) + converted.cachedPromptTokens;
-    }
-    if (converted.cacheReadInputTokens) {
-      pending.cacheReadInputTokens = (pending.cacheReadInputTokens ?? 0) + converted.cacheReadInputTokens;
-    }
-    this.subagentUsage = pending;
-  }
-  // Folds pending subagent usage into an outgoing finish event (and clears
-  // it). A finish without usage reports nothing to consumers, so the pending
-  // amount is kept for the next finish that carries usage instead. Totals
-  // sum the billed classes (usageTotalTokens), not whatever extra classes a
-  // provider folded into its reported totalTokens.
-  foldSubagentUsage(event) {
-    const pending = this.subagentUsage;
-    if (!pending || !event.usage) return event;
-    this.subagentUsage = null;
-    const usage = {
-      promptTokens: event.usage.promptTokens + pending.promptTokens,
-      completionTokens: event.usage.completionTokens + pending.completionTokens,
-      totalTokens: usageTotalTokens(event.usage) + usageTotalTokens(pending)
-    };
-    const cachedPromptTokens = (event.usage.cachedPromptTokens ?? 0) + (pending.cachedPromptTokens ?? 0);
-    const cacheReadInputTokens = (event.usage.cacheReadInputTokens ?? 0) + (pending.cacheReadInputTokens ?? 0);
-    if (cachedPromptTokens > 0) usage.cachedPromptTokens = cachedPromptTokens;
-    if (cacheReadInputTokens > 0) usage.cacheReadInputTokens = cacheReadInputTokens;
-    return { ...event, usage };
-  }
   // opencode's doom_loop guard: returns a refusal once the identical tool
   // call (name + stable-serialized args) has repeated config.doomLoopThreshold
   // times in a row; 0 disables. Any different signature resets the streak.
@@ -3706,7 +3943,7 @@ export {
   compactMessages,
   WORKING_DIFF_MAX_LINES,
   isGitRepo,
-  getGitSummaryCached,
+  getGitSummaryCachedAsync,
   collectCommitContext,
   buildCommitPrompt,
   collectWorkingDiff,
@@ -3719,4 +3956,4 @@ export {
   attachTurnContext,
   AgentLoop
 };
-//# sourceMappingURL=chunk-F5RWZMQY.js.map
+//# sourceMappingURL=chunk-4HANB3DJ.js.map