@namzu/cli 38.1.1 → 39.0.0

package/dist/chunks/{chunk-XM3W7NMM.js → chunk-RQBT4RVE.js}

@@ -1832,7 +1832,7 @@ function formatSystemEvent(event, options = {}) {
     renderedBody
   ]);
   const closingTag = `</system-event-${nonce}>`;
-  const lines2 = [
+  const lines = [
     `<system-event-${nonce} kind="${escapeAttribute2(event.kind)}" id="${escapeAttribute2(event.id)}" status="${escapeAttribute2(event.status)}">`,
     SYSTEM_EVENT_HEADER,
     nonceClosureStatement(closingTag),
@@ -1844,7 +1844,7 @@ function formatSystemEvent(event, options = {}) {
     renderedBody,
     closingTag
   ];
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(formatSystemEvent, "formatSystemEvent");
 
@@ -1937,7 +1937,7 @@ function createMonitorStream(options) {
   const clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
   let closed = false;
   let partial = "";
-  let lines2 = [];
+  let lines = [];
   let timer;
   let timerArmed = false;
   let tokens = MONITOR_BUCKET_CAPACITY;
@@ -1993,10 +1993,10 @@ function createMonitorStream(options) {
       clearTimer(timer);
       timerArmed = false;
     }
-    if (lines2.length === 0)
+    if (lines.length === 0)
       return;
-    let batch = lines2.join("\n");
-    lines2 = [];
+    let batch = lines.join("\n");
+    lines = [];
     if (batch.length > MONITOR_BATCH_MAX_CHARS) {
       batch = batch.slice(0, MONITOR_BATCH_MAX_CHARS) + BATCH_TRUNCATED;
     }
@@ -2006,7 +2006,7 @@ function createMonitorStream(options) {
     const line = raw.trim();
     if (line.length === 0)
       return;
-    lines2.push(line.length > MONITOR_LINE_MAX_CHARS ? line.slice(0, MONITOR_LINE_MAX_CHARS) + LINE_TRUNCATED : line);
+    lines.push(line.length > MONITOR_LINE_MAX_CHARS ? line.slice(0, MONITOR_LINE_MAX_CHARS) + LINE_TRUNCATED : line);
     if (!timerArmed) {
       timerArmed = true;
       timer = setTimer(() => {
@@ -2022,7 +2022,7 @@ function createMonitorStream(options) {
       clearTimer(timer);
       timerArmed = false;
     }
-    lines2 = [];
+    lines = [];
     partial = "";
   }, "stop");
   return {
@@ -9342,7 +9342,7 @@ function codeFromMessage(message, status) {
   // a plain invalid request — which is not retryable, and which the
   // overflow rescue tests for by exact equality. The turn died holding
   // the remedy.
-  m.includes("too long for") || // The reference terminal's own wordings (its `context window` and
+  m.includes("too long for") || // Known wordings: `context window` and
   // `input length and max_tokens exceed context limit` matchers).
   // Only where the status cannot say otherwise: a 429, 5xx or 401 that
   // mentions the window is still a rate limit, a server fault or an auth
@@ -9781,14 +9781,14 @@ function revisionFileSegment(value) {
   return out;
 }
 __name(revisionFileSegment, "revisionFileSegment");
-function decodeRevisionFileSegment(segment) {
-  if (segment === "~empty")
+function decodeRevisionFileSegment(segment2) {
+  if (segment2 === "~empty")
     return "";
-  if (segment.length === 0)
+  if (segment2.length === 0)
     return null;
   let value = "";
-  for (let i = 0; i < segment.length; i++) {
-    const char = segment[i];
+  for (let i = 0; i < segment2.length; i++) {
+    const char = segment2[i];
     if (char === void 0)
       return null;
     if (char !== "~") {
@@ -9797,13 +9797,13 @@ function decodeRevisionFileSegment(segment) {
       value += char;
       continue;
     }
-    const escaped = segment.slice(i + 1, i + 5);
+    const escaped = segment2.slice(i + 1, i + 5);
     if (!/^[0-9a-f]{4}$/u.test(escaped))
       return null;
     value += String.fromCharCode(Number.parseInt(escaped, 16));
     i += 4;
   }
-  return revisionFileSegment(value) === segment ? value : null;
+  return revisionFileSegment(value) === segment2 ? value : null;
 }
 __name(decodeRevisionFileSegment, "decodeRevisionFileSegment");
 var DiskRevisionRecordStore = class {
@@ -10379,10 +10379,10 @@ var DiskSessionGoalStore = class extends SessionGoalStoreBase {
   }
   location(sessionId5) {
     const root = join4(this.config.rootDir, "goals");
-    const segment = revisionFileSegment(sessionId5);
+    const segment2 = revisionFileSegment(sessionId5);
     return {
-      legacyPath: join4(root, `${segment}.json`),
-      revisionsDir: join4(root, ".revisions", segment)
+      legacyPath: join4(root, `${segment2}.json`),
+      revisionsDir: join4(root, ".revisions", segment2)
     };
   }
   async put(record3) {
@@ -12928,7 +12928,8 @@ var EPHEMERAL_EVENT_TYPES = /* @__PURE__ */ new Set([
   "tool_input_delta",
   "reasoning_delta",
   "tool_progress",
-  "monitor_event"
+  "monitor_event",
+  "compaction_started"
 ]);
 function isEphemeralEvent(event) {
   return EPHEMERAL_EVENT_TYPES.has(event.type);
@@ -13339,6 +13340,7 @@ var SESSION_EVENT_TYPE_TABLE = {
   approval_policy_changed: true,
   request_envelope: true,
   iteration_completed: true,
+  compaction_started: true,
   compaction_shed: true,
   compaction_completed: true,
   compaction_tool_results_cleared: true,
@@ -14721,6 +14723,7 @@ var BOUNDARY_TYPES = /* @__PURE__ */ new Set([
   "log_repaired"
 ]);
 var PREVIEW_CHARS = 2e3;
+var COMPACTION_SPILL_ABOVE_BYTES = 256 * 1024;
 var ZERO_USAGE = {
   promptTokens: 0,
   completionTokens: 0,
@@ -14750,6 +14753,7 @@ var SessionLogCore = class {
   #spills;
   #now;
   #spillAbove;
+  #compactionSpillAbove;
   #structuredResultSpilling;
   #sync;
   #mutex = new Mutex();
@@ -14773,6 +14777,7 @@ var SessionLogCore = class {
     this.#structuredResultSpilling = options.structuredResultSpilling ?? false;
     this.#now = options.now ?? Date.now;
     this.#spillAbove = Math.min(options.spillAboveBytes ?? SESSION_RECORD_MAX_BYTES, SESSION_RECORD_MAX_BYTES);
+    this.#compactionSpillAbove = Math.min(options.compactionSpillAboveBytes ?? COMPACTION_SPILL_ABOVE_BYTES, this.#spillAbove);
     this.#sync = options.sync ?? "boundaries";
   }
   // ── state ──
@@ -15014,7 +15019,8 @@ var SessionLogCore = class {
       return candidate;
     const size = Buffer.byteLength(`${JSON.stringify(candidate)}
 `, "utf8");
-    if (size <= this.#spillAbove)
+    const spillAbove = type === "compaction" ? this.#compactionSpillAbove : this.#spillAbove;
+    if (size <= spillAbove)
       return candidate;
     if (type === "turn_completed") {
       if (typeof candidate.result !== "string")
@@ -15164,10 +15170,10 @@ async function* walkSessionLog(medium, options) {
   let anchorSeen = false;
   let stopped = false;
   outer: for await (const chunk of medium.stream(start)) {
-    let lines2;
+    let lines;
     try {
-      lines2 = splitter.push(chunk);
-      for (const { line, offset } of lines2) {
+      lines = splitter.push(chunk);
+      for (const { line, offset } of lines) {
         let entry;
         try {
           entry = chain.accept(line, offset);
@@ -15325,6 +15331,7 @@ var DiskSessionLog = class _DiskSessionLog extends SessionLogCore {
       spills: new DiskSpillStore(options.sessionDir, options.now),
       now: options.now,
       spillAboveBytes: options.spillAboveBytes,
+      compactionSpillAboveBytes: options.compactionSpillAboveBytes,
       structuredResultSpilling: options.structuredResultSpilling,
       sync: options.sync
     });
@@ -15412,6 +15419,7 @@ var InMemorySessionLog = class _InMemorySessionLog extends SessionLogCore {
       spills,
       now: options.now,
       spillAboveBytes: options.spillAboveBytes,
+      compactionSpillAboveBytes: options.compactionSpillAboveBytes,
       structuredResultSpilling: options.structuredResultSpilling,
       sync: "none"
     });
@@ -15538,23 +15546,23 @@ function renderSkillsSection(skills) {
   if (forModel.length === 0)
     return null;
   const available = forModel.map((s) => {
-    const lines2 = [
+    const lines = [
       "<skill>",
       `<name>${s.metadata.name}</name>`,
       `<description>${s.metadata.description.trim()}</description>`,
       `<location>${s.dirPath}/SKILL.md</location>`
     ];
     if (s.metadata.compatibility) {
-      lines2.push(`<compatibility>${s.metadata.compatibility}</compatibility>`);
+      lines.push(`<compatibility>${s.metadata.compatibility}</compatibility>`);
     }
     if (s.metadata.license) {
-      lines2.push(`<license>${s.metadata.license}</license>`);
+      lines.push(`<license>${s.metadata.license}</license>`);
     }
     if (s.metadata.allowedTools) {
-      lines2.push(`<pre_approved_tools>${s.metadata.allowedTools}</pre_approved_tools>`);
+      lines.push(`<pre_approved_tools>${s.metadata.allowedTools}</pre_approved_tools>`);
     }
-    lines2.push("</skill>");
-    return lines2.join("\n");
+    lines.push("</skill>");
+    return lines.join("\n");
   }).join("\n");
   const loadedSkills = forModel.filter((s) => s.body);
   const sections = [
@@ -15586,23 +15594,23 @@ ${skillSections.join("\n\n")}`);
 }
 __name(renderSkillsSection, "renderSkillsSection");
 function renderOutputDiscipline(discipline) {
-  const lines2 = [];
+  const lines = [];
   if (discipline.betweenToolCalls === "silent") {
-    lines2.push("- Emit zero words between tool calls. Call tools back-to-back with no narration.");
+    lines.push("- Emit zero words between tool calls. Call tools back-to-back with no narration.");
   } else {
-    lines2.push("- Emit minimal text between tool calls. Keep inter-tool narration to a single short sentence.");
+    lines.push("- Emit minimal text between tool calls. Keep inter-tool narration to a single short sentence.");
   }
   if (discipline.suppressInnerMonologue) {
-    lines2.push("- Do not output inner monologue, reasoning traces, or planning text between turns.");
+    lines.push("- Do not output inner monologue, reasoning traces, or planning text between turns.");
   }
   if (discipline.finalResponse?.singleFileMaxWords) {
-    lines2.push(`- Final response for single-file changes: ${discipline.finalResponse.singleFileMaxWords} words maximum. Describe the why, not the what.`);
+    lines.push(`- Final response for single-file changes: ${discipline.finalResponse.singleFileMaxWords} words maximum. Describe the why, not the what.`);
   }
   if (discipline.finalResponse?.multiFileMaxWords) {
-    lines2.push(`- Final response for multi-file changes: ${discipline.finalResponse.multiFileMaxWords} words maximum. Summarize intent and scope.`);
+    lines.push(`- Final response for multi-file changes: ${discipline.finalResponse.multiFileMaxWords} words maximum. Summarize intent and scope.`);
   }
   return `## Output Discipline
-${lines2.join("\n")}`;
+${lines.join("\n")}`;
 }
 __name(renderOutputDiscipline, "renderOutputDiscipline");
 
@@ -15841,8 +15849,8 @@ var OVERFLOW_BODY_PATTERNS = [
   // length" — so a pattern anchored on "exceeded" misses it entirely.
   /exceeds?\s+(?:the\s+)?(?:model'?s?\s+)?context\s+(?:length|window|size)/i,
   /context\s+(?:length|window|size)\s+exceed/i,
-  // The reference terminal's own list matches the bare phrase "context
-  // window". Here it must sit next to a verb that says the request did not
+  // The bare phrase "context
+  // window" is too broad on its own. Here it must sit next to a verb that says the request did not
   // fit ("larger than the model context window of N tokens"), so a 400 that
   // only names the window ("does not support this parameter with the 1M
   // context window beta") stays an invalid request. The same pattern lives in
@@ -17769,13 +17777,13 @@ function describeRequiredInput(schema) {
     if (required.length === 0)
       return "No required parameters known.";
     const props = json2.properties ?? {};
-    const lines2 = required.map((name2) => {
+    const lines = required.map((name2) => {
       const def = props[name2] ?? {};
       const type = def.type ?? "value";
       const desc = def.description ? ` \u2014 ${def.description}` : "";
       return `${name2}: ${type}${desc}`;
     });
-    return `Required: ${lines2.join(", ")}.`;
+    return `Required: ${lines.join(", ")}.`;
   } catch {
     return "Could not introspect required parameters.";
   }
@@ -18172,7 +18180,7 @@ Additional note from the user: "${freeText}"`;
 __name(describeSingle, "describeSingle");
 var labelOf = /* @__PURE__ */ __name((item) => item.header ?? item.question, "labelOf");
 function describeBatch(answers) {
-  const lines2 = answers.map((answer) => {
+  const lines = answers.map((answer) => {
     const { item, selected, freeText } = answer;
     if (selected.length > 0) {
       const joined3 = selected.map((s) => `"${s.label}"`).join(", ");
@@ -18185,7 +18193,7 @@ function describeBatch(answers) {
   const answered = answers.filter(isAnswered).length;
   return {
     output: `The user answered ${answered} of ${answers.length} questions:
-${lines2.join("\n")}`,
+${lines.join("\n")}`,
     data: {
       questions: answers.map(({ item }) => ({
         questionId: item.id,
@@ -22772,9 +22780,9 @@ function renderEntry(entry) {
   return JSON.stringify(body).replaceAll("<", "\\u003c");
 }
 __name(renderEntry, "renderEntry");
-function renderedLength(lines2) {
+function renderedLength(lines) {
   let total = 0;
-  for (const line of lines2)
+  for (const line of lines)
     total += line.length + 1;
   return total;
 }
@@ -22954,7 +22962,7 @@ function createAutoReviewClassifier(options) {
       excludeCallIds: /* @__PURE__ */ new Set([request.call.id]),
       ...options.maxEntryChars !== void 0 ? { maxEntryChars: options.maxEntryChars } : {}
     });
-    const lines2 = entries2.map(renderEntry);
+    const lines = entries2.map(renderEntry);
     const projected = projectAction(request.call.name, request.call.input, request.tools, ACTION_CHARS);
     if (projected.truncated) {
       return blocked(started, 0, "unreadable", "the action is too long for the safety check to read in full, so it was not run");
@@ -22964,10 +22972,10 @@ function createAutoReviewClassifier(options) {
       name: request.call.name,
       input: projected.text
     });
-    if (renderedLength(lines2) + action.length > maxChars2)
+    if (renderedLength(lines) + action.length > maxChars2)
       return { verdict: "too_long" };
     const body = `<transcript>
-${lines2.join("\n")}
+${lines.join("\n")}
 </transcript>
 
 The action under review:
@@ -23103,8 +23111,8 @@ var FILE_NAMES = new Set(PROTECTED_FILE_NAMES.map(fold));
 var NESTED = PROTECTED_NESTED_DIRECTORIES.map((sequence) => sequence.map(fold));
 function isProtectedPath(path2) {
   const segments = path2.split(/[\\/]+/).map(fold);
-  for (const segment of segments) {
-    if (DIRECTORIES.has(segment))
+  for (const segment2 of segments) {
+    if (DIRECTORIES.has(segment2))
       return true;
   }
   for (const sequence of NESTED) {
@@ -23337,10 +23345,10 @@ function checkTarget(program, args, spelled, word2, scope) {
 __name(checkTarget, "checkTarget");
 function hasParentAfterName(path2) {
   let named = false;
-  for (const segment of path2.split(/[\\/]+/)) {
-    if (segment === "" || segment === ".")
+  for (const segment2 of path2.split(/[\\/]+/)) {
+    if (segment2 === "" || segment2 === ".")
       continue;
-    if (segment === "..") {
+    if (segment2 === "..") {
       if (named)
         return true;
     } else
@@ -25613,15 +25621,15 @@ function applyOne(content, input) {
 __name(applyOne, "applyOne");
 function applyLineInsert(content, input) {
   const hasTrailingNewline = content.endsWith("\n");
-  const lines2 = content.split("\n");
+  const lines = content.split("\n");
   if (hasTrailingNewline)
-    lines2.pop();
-  const line = input.insertLine === "end" ? lines2.length : Math.min(Math.max(input.insertLine, 0), lines2.length);
+    lines.pop();
+  const line = input.insertLine === "end" ? lines.length : Math.min(Math.max(input.insertLine, 0), lines.length);
   const inserted = input.newString.endsWith("\n") ? input.newString.slice(0, -1).split("\n") : input.newString.split("\n");
-  lines2.splice(line, 0, ...inserted);
+  lines.splice(line, 0, ...inserted);
   return {
     success: true,
-    content: `${lines2.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
+    content: `${lines.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
     replacements: 1
   };
 }
@@ -25798,6 +25806,770 @@ function jsonStringEscapes(where) {
 }
 __name(jsonStringEscapes, "jsonStringEscapes");
 
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  static {
+    __name(this, "Diff");
+  }
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a2;
+    const done = /* @__PURE__ */ __name((value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    }, "done");
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a2 = options.timeout) !== null && _a2 !== void 0 ? _a2 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = /* @__PURE__ */ __name(() => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    }, "execEditLength");
+    if (callback) {
+      (/* @__PURE__ */ __name(function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      }, "exec"))();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path2, added, removed, oldPosInc, options) {
+    const last = path2.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path2.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path2.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[i] != str2[i]) {
+      return str1.slice(0, i);
+    }
+  }
+  return str1.slice(0, i);
+}
+__name(longestCommonPrefix, "longestCommonPrefix");
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i = 0; i < str1.length && i < str2.length; i++) {
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+      return str1.slice(-i);
+    }
+  }
+  return str1.slice(-i);
+}
+__name(longestCommonSuffix, "longestCommonSuffix");
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+__name(replacePrefix, "replacePrefix");
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+__name(replaceSuffix, "replaceSuffix");
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+__name(removePrefix, "removePrefix");
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+__name(removeSuffix, "removeSuffix");
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+__name(maximumOverlap, "maximumOverlap");
+function overlapCount(a, b) {
+  let startA = 0;
+  if (a.length > b.length) {
+    startA = a.length - b.length;
+  }
+  let endB = b.length;
+  if (a.length < b.length) {
+    endB = a.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1; j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i = startA; i < a.length; i++) {
+    while (k > 0 && a[i] != b[k]) {
+      k = map[k];
+    }
+    if (a[i] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+__name(overlapCount, "overlapCount");
+function segment(string, segmenter) {
+  const parts = [];
+  for (const segmentObj of Array.from(segmenter.segment(string))) {
+    const segment2 = segmentObj.segment;
+    if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment2)) {
+      parts[parts.length - 1] += segment2;
+    } else {
+      parts.push(segment2);
+    }
+  }
+  return parts;
+}
+__name(segment, "segment");
+function trailingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[1];
+  }
+  let i;
+  for (i = string.length - 1; i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+__name(trailingWs, "trailingWs");
+function leadingWs(string, segmenter) {
+  if (segmenter) {
+    return leadingAndTrailingWs(string, segmenter)[0];
+  }
+  const match2 = string.match(/^\s*/);
+  return match2 ? match2[0] : "";
+}
+__name(leadingWs, "leadingWs");
+function leadingAndTrailingWs(string, segmenter) {
+  if (!segmenter) {
+    return [leadingWs(string), trailingWs(string)];
+  }
+  if (segmenter.resolvedOptions().granularity != "word") {
+    throw new Error('The segmenter passed must have a granularity of "word"');
+  }
+  const segments = segment(string, segmenter);
+  const firstSeg = segments[0];
+  const lastSeg = segments[segments.length - 1];
+  const head2 = /\s/.test(firstSeg) ? firstSeg : "";
+  const tail = /\s/.test(lastSeg) ? lastSeg : "";
+  return [head2, tail];
+}
+__name(leadingAndTrailingWs, "leadingAndTrailingWs");
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+var WordDiff = class extends Diff {
+  static {
+    __name(this, "WordDiff");
+  }
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = segment(value, segmenter);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part2) => {
+      if (/\s/.test(part2)) {
+        if (prevPart == null) {
+          tokens.push(part2);
+        } else {
+          tokens.push(tokens.pop() + part2);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part2);
+        } else {
+          tokens.push(prevPart + part2);
+        }
+      } else {
+        tokens.push(part2);
+      }
+      prevPart = part2;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
+    }
+    return changes;
+  }
+};
+var wordDiff = new WordDiff();
+function diffWords(oldStr, newStr, options) {
+  if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
+    return diffWordsWithSpace(oldStr, newStr, options);
+  }
+  return wordDiff.diff(oldStr, newStr, options);
+}
+__name(diffWords, "diffWords");
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
+  if (deletion && insertion) {
+    const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter);
+    const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value, segmenter);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value, segmenter);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value, segmenter);
+    const deletionWsSuffix = trailingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value, segmenter);
+    const deletionWsPrefix = leadingWs(deletion.value, segmenter);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+__name(dedupeWhitespaceInChangeObjects, "dedupeWhitespaceInChangeObjects");
+var WordsWithSpaceDiff = class extends Diff {
+  static {
+    __name(this, "WordsWithSpaceDiff");
+  }
+  tokenize(value) {
+    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+};
+var wordsWithSpaceDiff = new WordsWithSpaceDiff();
+function diffWordsWithSpace(oldStr, newStr, options) {
+  return wordsWithSpaceDiff.diff(oldStr, newStr, options);
+}
+__name(diffWordsWithSpace, "diffWordsWithSpace");
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  static {
+    __name(this, "LineDiff");
+  }
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+__name(diffLines, "diffLines");
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+__name(tokenize, "tokenize");
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context2 = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: /* @__PURE__ */ __name((diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    }, "callback") }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    __name(contextLines, "contextLines");
+    const hunks2 = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context2 > 0 ? contextLines(prev.lines.slice(-context2)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context2 * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context2);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks2.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks2) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks: hunks2
+    };
+  }
+  __name(diffLinesResultToPatch, "diffLinesResultToPatch");
+}
+__name(structuredPatch, "structuredPatch");
+function splitLines(text9) {
+  const hasTrailingNl = text9.endsWith("\n");
+  const result = text9.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+__name(splitLines, "splitLines");
+
+// ../sdk/dist/tools/builtins/line-diff.js
+var CONTEXT_LINES = 3;
+var DIFF_TIMEOUT_MS = 5e3;
+var MAX_CARRIED_DIFF_LINES = 400;
+var MAX_CARRIED_LINE_CHARS = 500;
+function cutRow(row) {
+  if (row.length <= MAX_CARRIED_LINE_CHARS)
+    return row;
+  const cut = row.slice(0, MAX_CARRIED_LINE_CHARS - 1).replace(/[\uD800-\uDBFF]$/, "");
+  return `${cut}\u2026`;
+}
+__name(cutRow, "cutRow");
+function splitKeepingTerminators(text9) {
+  return text9.length === 0 ? [] : text9.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+__name(splitKeepingTerminators, "splitKeepingTerminators");
+function coarseDiff(before, after) {
+  const a = splitKeepingTerminators(before);
+  const b = splitKeepingTerminators(after);
+  let head2 = 0;
+  while (head2 < a.length && head2 < b.length && a[head2] === b[head2])
+    head2++;
+  let tail = 0;
+  while (tail < a.length - head2 && tail < b.length - head2 && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+    tail++;
+  const removed = a.slice(head2, a.length - tail);
+  const added = b.slice(head2, b.length - tail);
+  const rows = [
+    ...removed.map((line) => `-${line.replace(/\n$/, "")}`),
+    ...added.map((line) => `+${line.replace(/\n$/, "")}`)
+  ];
+  const kept = rows.slice(0, MAX_CARRIED_DIFF_LINES).map(cutRow);
+  return {
+    added: added.length,
+    removed: removed.length,
+    hunks: rows.length === 0 ? [] : [
+      {
+        oldStart: head2 + 1,
+        oldLines: removed.length,
+        newStart: head2 + 1,
+        newLines: added.length,
+        lines: kept
+      }
+    ],
+    truncated: rows.length > kept.length
+  };
+}
+__name(coarseDiff, "coarseDiff");
+function lineDiff2(before, after) {
+  if (before === after)
+    return { added: 0, removed: 0, hunks: [], truncated: false };
+  const patch = structuredPatch("a", "a", before, after, void 0, void 0, {
+    context: CONTEXT_LINES,
+    timeout: DIFF_TIMEOUT_MS
+  });
+  if (patch === void 0)
+    return coarseDiff(before, after);
+  let added = 0;
+  let removed = 0;
+  let budget = MAX_CARRIED_DIFF_LINES;
+  let truncated = false;
+  const hunks2 = [];
+  for (const hunk of patch.hunks) {
+    const rows = [];
+    for (const row of hunk.lines) {
+      if (row.startsWith("\\"))
+        continue;
+      if (row.startsWith("+"))
+        added++;
+      else if (row.startsWith("-"))
+        removed++;
+      if (budget > 0) {
+        rows.push(cutRow(row));
+        budget--;
+      } else {
+        truncated = true;
+      }
+    }
+    if (rows.length > 0) {
+      hunks2.push({
+        oldStart: hunk.oldStart,
+        oldLines: hunk.oldLines,
+        newStart: hunk.newStart,
+        newLines: hunk.newLines,
+        lines: rows
+      });
+    }
+  }
+  return { added, removed, hunks: hunks2, truncated };
+}
+__name(lineDiff2, "lineDiff");
+
 // ../sdk/dist/tools/builtins/edit.js
 var inputSchema3 = external_exports.object({
   path: external_exports.string().refine((value) => value.trim().length > 0, "Path must not be empty.").describe("Path to the file to edit. Must not be empty."),
@@ -25994,6 +26766,22 @@ function admitAgainstRead(context2, key5, content, operations) {
 }
 __name(admitAgainstRead, "admitAgainstRead");
 var EDIT_SHAPES = 'Three shapes. Replace: {"path":"file.md","old_string":"exact unique text","new_string":"replacement text"} (optional "replace_all": true). Insert: {"path":"file.md","insertLine":"end","new_string":"text to add"} where insertLine is a non-negative line number or "end". Batch: {"path":"file.md","edits":[{"old_string":"a","new_string":"b"},{"old_string":"c","new_string":"d"}]} applied in order, all or nothing. Exactly one of old_string, insertLine or edits \u2014 a call carrying more than one of them is refused rather than resolved.';
+function editFacts(path2, replacements, before, after) {
+  const diff = lineDiff2(before, after);
+  return {
+    diff,
+    facts: {
+      kind: "edit",
+      path: path2,
+      replacements,
+      added: diff.added,
+      removed: diff.removed,
+      ...diff.hunks.length > 0 ? { hunks: diff.hunks } : {},
+      ...diff.truncated ? { hunksTruncated: true } : {}
+    }
+  };
+}
+__name(editFacts, "editFacts");
 var EditTool = defineTool({
   name: "edit",
   description: 'Makes targeted edits to a file using exact string find-and-replace or line insertion. THIS IS THE PREFERRED WAY TO MODIFY AN EXISTING FILE \u2014 never reach for `write` to change a file that already exists, because `write` overwrites the whole body and discards earlier work on partial failure. `edit` keeps the rest of the file byte-for-byte intact and is recoverable: if a single edit fails (old_string/oldStr ambiguous, broader restructuring needed), follow up with another `edit` instead of re-emitting the entire file via `write`. The old_string/oldStr must be unique in the file unless replace_all is true. For insertions, pass insertLine plus new_string/newStr; use insertLine: "end" to extend a file at the end. Self-budget new_string/newStr under 12000 characters before emitting the tool call; use repeated bounded edits for long sections. Preserves file formatting and indentation. To make several changes to ONE file that only make sense together, send them as `edits`: a list of {old_string, new_string} applied in order and committed as one write \u2014 if any of them does not apply, nothing is written and the reply names which one, so the file is never left half-changed.',
@@ -26099,19 +26887,16 @@ var EditTool = defineTool({
         }
         await context2.sandbox.writeFile(parsed.data.path, result2.content);
         recordEditedContent(context2, parsed.data.path, result2.content);
+        const changed2 = editFacts(parsed.data.path, result2.replacements, content2, result2.content);
         return {
           success: true,
-          output: `Edited ${parsed.data.path}: ${result2.replacements} replacement(s) [sandboxed]`,
+          output: `Edited ${parsed.data.path}: ${result2.replacements} replacement(s) (+${changed2.diff.added} -${changed2.diff.removed}) [sandboxed]`,
           data: {
             path: parsed.data.path,
             replacements: result2.replacements,
             sandboxed: true
           },
-          facts: {
-            kind: "edit",
-            path: parsed.data.path,
-            replacements: result2.replacements
-          }
+          facts: changed2.facts
         };
       }
       const hostPath = filePath;
@@ -26124,15 +26909,12 @@ var EditTool = defineTool({
         return { success: false, output: "", error: result.error };
       await atomicWriteFile2(hostPath, result.content);
       recordEditedContent(context2, hostPath, result.content);
+      const changed = editFacts(hostPath, result.replacements, content, result.content);
       return {
         success: true,
-        output: `Edited ${hostPath}: ${result.replacements} replacement(s)`,
+        output: `Edited ${hostPath}: ${result.replacements} replacement(s) (+${changed.diff.added} -${changed.diff.removed})`,
         data: { path: hostPath, replacements: result.replacements },
-        facts: {
-          kind: "edit",
-          path: hostPath,
-          replacements: result.replacements
-        }
+        facts: changed.facts
       };
     });
   }
@@ -26168,13 +26950,13 @@ function clipTail(text9, max) {
 __name(clipTail, "clipTail");
 function windowText(text9, totalBytes = Buffer.byteLength(text9, "utf8")) {
   const body = text9.endsWith("\n") ? text9.slice(0, -1) : text9;
-  const lines2 = body.length === 0 ? [] : body.split("\n");
-  const totalLines = lines2.length;
+  const lines = body.length === 0 ? [] : body.split("\n");
+  const totalLines = lines.length;
   if (totalLines <= WINDOW_HEAD_LINES + WINDOW_TAIL_LINES && body.length <= WINDOW_HALF_CHARS * 2) {
     return { head: body, totalLines, totalBytes };
   }
-  const headLines = lines2.slice(0, WINDOW_HEAD_LINES);
-  const tailLines = totalLines > WINDOW_HEAD_LINES ? lines2.slice(Math.max(WINDOW_HEAD_LINES, totalLines - WINDOW_TAIL_LINES)) : [];
+  const headLines = lines.slice(0, WINDOW_HEAD_LINES);
+  const tailLines = totalLines > WINDOW_HEAD_LINES ? lines.slice(Math.max(WINDOW_HEAD_LINES, totalLines - WINDOW_TAIL_LINES)) : [];
   const head2 = clipHead(headLines.join("\n"), WINDOW_HALF_CHARS);
   const tail = clipTail(tailLines.join("\n"), WINDOW_HALF_CHARS);
   const omittedLines = totalLines - headLines.length - tailLines.length;
@@ -26211,15 +26993,15 @@ __name(looksBinary, "looksBinary");
 // ../sdk/dist/tools/builtins/read-render.js
 var DEFAULT_READ_LINES = 2e3;
 function renderNumberedRead(content, input) {
-  const lines2 = content.split("\n");
-  const { start, end } = resolveReadWindow(input, lines2.length);
-  const selected = lines2.slice(start, end);
+  const lines = content.split("\n");
+  const { start, end } = resolveReadWindow(input, lines.length);
+  const selected = lines.slice(start, end);
   const numbered2 = selected.map((line, i) => `${start + i + 1}	${line}`).join("\n");
   return {
-    output: numbered2 + partialViewNotice(start, selected.length, lines2.length),
-    totalLines: lines2.length,
+    output: numbered2 + partialViewNotice(start, selected.length, lines.length),
+    totalLines: lines.length,
     returnedLines: selected.length,
-    partial: selected.length < lines2.length
+    partial: selected.length < lines.length
   };
 }
 __name(renderNumberedRead, "renderNumberedRead");
@@ -26281,9 +27063,9 @@ function renderCappedRead(content, byteLength, input, options) {
       message: `File content (${humanBytes(byteLength)}) exceeds the maximum allowed size (${humanBytes(maxBytes)}). Use offset and limit to read part of it, or search for what you need instead of reading all of it.${hint}`
     };
   }
-  const lines2 = content.split("\n");
-  const { start, end } = resolveReadWindow(input, lines2.length);
-  const selected = lines2.slice(start, end);
+  const lines = content.split("\n");
+  const { start, end } = resolveReadWindow(input, lines.length);
+  const selected = lines.slice(start, end);
   const selectedText = selected.join("\n");
   const selectedBytes = Buffer.byteLength(selectedText, "utf8");
   if (selectedBytes > maxTokens * SELECTED_BYTES_PER_TOKEN) {
@@ -26305,7 +27087,7 @@ function renderCappedRead(content, byteLength, input, options) {
   }
   return {
     ok: true,
-    rendered: trimFirstPage(selected, lines2.length, selectedText, tokens, maxTokens, options.path)
+    rendered: trimFirstPage(selected, lines.length, selectedText, tokens, maxTokens, options.path)
   };
 }
 __name(renderCappedRead, "renderCappedRead");
@@ -26351,8 +27133,8 @@ function trimFirstPage(selected, totalLines, selectedText, tokens, maxTokens, pa
   };
 }
 __name(trimFirstPage, "trimFirstPage");
-function numbered(lines2) {
-  return lines2.map((line, i) => `${i + 1}	${line}`).join("\n");
+function numbered(lines) {
+  return lines.map((line, i) => `${i + 1}	${line}`).join("\n");
 }
 __name(numbered, "numbered");
 
@@ -26569,33 +27351,19 @@ import { dirname as dirname9 } from "node:path";
 
 // ../sdk/dist/tools/builtins/file-write-result.js
 import { createHash as createHash8 } from "node:crypto";
-function lines(text9) {
-  if (text9 === "")
-    return [];
-  const result = text9.split("\n");
-  if (result.at(-1) === "")
-    result.pop();
-  return result;
+function previewSide(hunks2, changed) {
+  return hunks2.flatMap((hunk) => hunk.lines).filter((row) => row.startsWith(" ") || row.startsWith(changed)).map((row) => `${row.slice(1)}
+`).join("");
 }
-__name(lines, "lines");
+__name(previewSide, "previewSide");
 function fileWriteResult(path2, before, after, sandboxed = false) {
   const operation = before === null ? "write" : before === void 0 ? "create" : before === after ? "unchanged" : "replace";
-  const oldLines = lines(before ?? "");
-  const newLines = lines(after);
-  let start = 0;
-  let end = 0;
-  if (typeof before === "string") {
-    while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start])
-      start++;
-    while (end < oldLines.length - start && end < newLines.length - start && oldLines[oldLines.length - end - 1] === newLines[newLines.length - end - 1])
-      end++;
-  }
-  const removed = oldLines.slice(start, oldLines.length - end);
-  const added = newLines.slice(start, newLines.length - end);
+  const diff = lineDiff2(typeof before === "string" ? before : "", after);
+  const known = before !== null;
   const bytes = Buffer.byteLength(after, "utf8");
   const label5 = operation === "create" ? "Created" : operation === "replace" ? "Updated" : operation === "unchanged" ? "Unchanged" : "Wrote";
   const newlineChanged = typeof before === "string" && before.endsWith("\n") !== after.endsWith("\n");
-  const summary2 = `${label5} ${path2}${before === null ? "" : ` (+${added.length} -${removed.length})`}${newlineChanged ? " \xB7 final newline changed" : ""}`;
+  const summary2 = `${label5} ${path2}${before === null ? "" : ` (+${diff.added} -${diff.removed})`}${newlineChanged ? " \xB7 final newline changed" : ""}`;
   return {
     success: true,
     output: `${summary2} \xB7 ${bytes} bytes`,
@@ -26604,7 +27372,12 @@ function fileWriteResult(path2, before, after, sandboxed = false) {
       path: path2,
       operation: operation === "create" ? "created" : operation === "replace" ? "updated" : operation === "unchanged" ? "unchanged" : "wrote",
       bytes,
-      ...before === null ? {} : { added: added.length, removed: removed.length }
+      ...known ? {
+        added: diff.added,
+        removed: diff.removed,
+        ...diff.hunks.length > 0 ? { hunks: diff.hunks } : {},
+        ...diff.truncated ? { hunksTruncated: true } : {}
+      } : {}
     },
     data: {
       path: path2,
@@ -26614,15 +27387,13 @@ function fileWriteResult(path2, before, after, sandboxed = false) {
         operation,
         ...before === null ? {} : {
           preview: {
-            before: removed.length ? `${removed.join("\n")}
-` : "",
-            after: added.length ? `${added.join("\n")}
-` : ""
+            before: previewSide(diff.hunks, "-"),
+            after: previewSide(diff.hunks, "+")
           }
         },
         bytes,
         sha256: createHash8("sha256").update(after, "utf8").digest("hex"),
-        ...before === null ? {} : { added: added.length, removed: removed.length, newlineChanged }
+        ...before === null ? {} : { added: diff.added, removed: diff.removed, newlineChanged }
       }
     }
   };
@@ -27092,24 +27863,24 @@ function observeRead(history, call2, claims, withBody, budget) {
 }
 __name(observeRead, "observeRead");
 function wholeFileRenderUnits(body, window2) {
-  const lines2 = countLines(body);
-  const { start, end } = resolveReadWindow(window2, lines2);
-  if (start !== 0 || end < lines2)
+  const lines = countLines(body);
+  const { start, end } = resolveReadWindow(window2, lines);
+  if (start !== 0 || end < lines)
     return void 0;
-  return body.length + lines2 + lineNumberUnits(lines2);
+  return body.length + lines + lineNumberUnits(lines);
 }
 __name(wholeFileRenderUnits, "wholeFileRenderUnits");
 function countLines(body) {
-  let lines2 = 1;
+  let lines = 1;
   for (let at = body.indexOf("\n"); at !== -1; at = body.indexOf("\n", at + 1))
-    lines2++;
-  return lines2;
+    lines++;
+  return lines;
 }
 __name(countLines, "countLines");
-function lineNumberUnits(lines2) {
+function lineNumberUnits(lines) {
   let units = 0;
-  for (let width = 1, first = 1; first <= lines2; width++, first *= 10)
-    units += (Math.min(lines2, first * 10 - 1) - first + 1) * width;
+  for (let width = 1, first = 1; first <= lines; width++, first *= 10)
+    units += (Math.min(lines, first * 10 - 1) - first + 1) * width;
   return units;
 }
 __name(lineNumberUnits, "lineNumberUnits");
@@ -28354,7 +29125,7 @@ function evaluateRule(rule, toolName, toolInput, toolDef, compiledPattern, nameS
       if (rule.decision === "deny" || rule.decision === "review") {
         if (compiledPattern.test(subject))
           return rule.decision;
-        if (segments.some((segment) => compiledPattern.test(segment)))
+        if (segments.some((segment2) => compiledPattern.test(segment2)))
           return rule.decision;
         if (isUrl)
           return null;
@@ -28362,7 +29133,7 @@ function evaluateRule(rule, toolName, toolInput, toolDef, compiledPattern, nameS
       }
       if (opaque2)
         return null;
-      return segments.every((segment) => compiledPattern.test(segment)) ? "allow" : null;
+      return segments.every((segment2) => compiledPattern.test(segment2)) ? "allow" : null;
     }
     case "allow_by_tier": {
       if (toolDef?.tier && rule.tiers.includes(toolDef.tier)) {
@@ -29472,51 +30243,51 @@ function renderPlan(plan) {
 }
 __name(renderPlan, "renderPlan");
 function renderFiles(files) {
-  const lines2 = [];
+  const lines = [];
   for (const [, slot] of files) {
-    lines2.push(`- \`${slot.path}\``);
+    lines.push(`- \`${slot.path}\``);
     for (const action of slot.actions) {
       if (action.type === "delete") {
-        lines2.push("  - deleted");
+        lines.push("  - deleted");
       } else {
         const desc = "detail" in action ? action.detail : action.summary;
-        lines2.push(`  - ${action.type}: ${desc ?? ""}`);
+        lines.push(`  - ${action.type}: ${desc ?? ""}`);
       }
     }
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(renderFiles, "renderFiles");
 function renderList(items, evictedCount = 0) {
-  const lines2 = items.map((item) => `- ${item}`);
+  const lines = items.map((item) => `- ${item}`);
   if (evictedCount > 0) {
     const noun = evictedCount === 1 ? "entry" : "entries";
-    lines2.push(`- _(${evictedCount} ${noun} dropped to stay within the state budget)_`);
+    lines.push(`- _(${evictedCount} ${noun} dropped to stay within the state budget)_`);
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(renderList, "renderList");
 function renderToolResults(results, evictedCount = 0) {
-  const lines2 = results.map((r) => `- **${r.tool}**: ${r.summary}`);
+  const lines = results.map((r) => `- **${r.tool}**: ${r.summary}`);
   if (evictedCount > 0) {
     const noun = evictedCount === 1 ? "result" : "results";
-    lines2.push(`- _(${evictedCount} earlier tool ${noun} dropped to stay within the state budget)_`);
+    lines.push(`- _(${evictedCount} earlier tool ${noun} dropped to stay within the state budget)_`);
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(renderToolResults, "renderToolResults");
 function renderPins(state) {
   const pins = state.pins ? [...state.pins.values()] : [];
   if (pins.length === 0)
     return null;
-  const lines2 = pins.map((p) => `- **${p.key}**: ${p.text} _(${p.source})_`);
+  const lines = pins.map((p) => `- **${p.key}**: ${p.text} _(${p.source})_`);
   const dropped = state.evicted.pins ?? 0;
   if (dropped > 0) {
-    lines2.push(`- _(${dropped} older ${dropped === 1 ? "pin" : "pins"} dropped to stay within the pin budget)_`);
+    lines.push(`- _(${dropped} older ${dropped === 1 ? "pin" : "pins"} dropped to stay within the pin budget)_`);
   }
   return `${SECTION_HEADERS.pins}
 
-${lines2.join("\n")}`;
+${lines.join("\n")}`;
 }
 __name(renderPins, "renderPins");
 function serializeState(state) {
@@ -30868,24 +31639,23 @@ var TurnRecorder = class {
     const durable = next.filter((entry) => !entry.transient);
     const recordedOrder = new Map(this.#view.filter((entry) => entry.id).map((entry, index) => [entry.id, index]));
     const first = durable.findIndex((entry) => entry.id !== void 0);
-    let last = -1;
-    for (let i = durable.length - 1; i >= 0; i--) {
-      if (durable[i]?.id !== void 0) {
-        last = i;
-        break;
+    let runEnd = first < 0 ? 0 : first + 1;
+    if (first >= 0) {
+      let prev = recordedOrder.get(durable[first]?.id) ?? -1;
+      for (let i = first + 1; i < durable.length; i++) {
+        const id3 = durable[i]?.id;
+        if (id3 === void 0)
+          break;
+        const order = recordedOrder.get(id3) ?? -1;
+        if (order <= prev)
+          break;
+        prev = order;
+        runEnd = i + 1;
       }
     }
-    const middle = first < 0 ? [] : durable.slice(first, last + 1);
-    let ordered = middle.every((entry) => entry.id !== void 0);
-    for (let i = 1; ordered && i < middle.length; i++) {
-      const before = recordedOrder.get(middle[i - 1]?.id) ?? -1;
-      const after = recordedOrder.get(middle[i]?.id) ?? -1;
-      if (after <= before)
-        ordered = false;
-    }
-    const summaryEntries = !ordered ? durable : first < 0 ? durable : durable.slice(0, first);
-    const keptEntries = ordered ? middle : [];
-    const tailEntries = ordered && first >= 0 ? durable.slice(last + 1) : [];
+    const summaryEntries = first < 0 ? [] : durable.slice(0, first);
+    const keptEntries = first < 0 ? [] : durable.slice(first, runEnd);
+    const tailEntries = durable.slice(first < 0 ? 0 : runEnd);
     for (const entry of summaryEntries) {
       entry.id = void 0;
       this.#ids.delete(entry.message);
@@ -30912,6 +31682,8 @@ var TurnRecorder = class {
     }).catch(() => void 0);
     for (const entry of tailEntries) {
       const message = entry.message;
+      this.#ids.delete(message);
+      this.#recorded.delete(message);
       const id3 = this.#idFor(message);
       entry.id = id3;
       void this.#enqueue(() => this.#append({
@@ -31361,7 +32133,7 @@ function buildAdvisoryTools(opts) {
     async execute() {
       const advisors = advisoryCtx.registry.listAll();
       const budget = advisoryCtx.getBudgetStatus();
-      const lines2 = advisors.map((a) => {
+      const lines = advisors.map((a) => {
         const domains = a.domains && a.domains.length > 0 ? a.domains.join(", ") : "general";
         return `- ${a.id}: ${a.name} [domains: ${domains}]`;
       });
@@ -31369,7 +32141,7 @@ function buildAdvisoryTools(opts) {
       return {
         success: true,
         output: advisors.length === 0 ? "No advisors configured." : `${advisors.length} advisor(s) available:
-${lines2.join("\n")}
+${lines.join("\n")}
 
 ${budgetLine}`,
         data: {
@@ -33549,9 +34321,20 @@ var CompletionInbox = class {
    * `log` is optional and unresolved until it is actually needed (the
    * eviction-warning path in `hold()`), same reason as `LocalTaskScheduler`.
    */
-  constructor(log) {
+  constructor(log, options = {}) {
     this.log = log;
+    this.holdsTurnOpen = options.holdsTurnOpen !== false;
   }
+  /**
+   * Whether a turn about to end waits here for the tasks still running.
+   *
+   * `true` (the default) is the original contract: the turn parks at its settle
+   * point until the tasks it launched report back, so their results enter the
+   * same turn. `false` lets the turn end with them still running; the host owns
+   * their completion from then on (it keeps them alive and wakes the model when
+   * they end). Completions that have already arrived are delivered either way.
+   */
+  holdsTurnOpen;
   /**
    * Start listening.
    *
@@ -33727,6 +34510,14 @@ var CompletionInbox = class {
   get hasPendingWork() {
     return this.unheard.size > 0 || this.outstanding.size > 0;
   }
+  /**
+   * Whether the turn has a reason to wait at its settle point: anything
+   * pending when it {@link holdsTurnOpen}, else only a completion already in
+   * hand (waiting for its persistence gate).
+   */
+  get holdsTurn() {
+    return this.holdsTurnOpen ? this.hasPendingWork : this.unheard.size > 0;
+  }
   /**
    * Wait for the next completion, deadline or abort, whichever comes first.
    * Aborting releases only this waiter; work and undelivered results remain owned.
@@ -33955,7 +34746,7 @@ ${partial.content}`;
       attributes: { agent: handle.agentId, task: handle.taskId },
       provenance: `This is the output of the delegated agent "${handle.agentId}", not this agent's own work.`
     }, neutralizeNotificationDelimiter(shown)) : "(the task produced no output)";
-    const lines2 = [
+    const lines = [
       `task_id: ${handle.taskId}`,
       `agent: ${handle.agentId}`,
       `state: ${handle.state}`,
@@ -33976,7 +34767,7 @@ ${partial.content}`;
       ...overLimit ? [`\u2026 truncated. Call wait_for_task with task_id "${handle.taskId}" for the full output.`] : []
     ];
     return `<task-notification>
-${lines2.join("\n")}
+${lines.join("\n")}
 </task-notification>`;
   });
   const preamble = handles.length === 1 ? "A task you launched has finished. This is its result \u2014 you were not waiting on it, so it arrives here rather than as a tool result." : `${handles.length} tasks you launched have finished. These are their results \u2014 you were not waiting on them, so they arrive here rather than as tool results.`;
@@ -34613,7 +35404,7 @@ function awaitedJobGraceMs(remainingBeforeFinalizeMs) {
 }
 __name(awaitedJobGraceMs, "awaitedJobGraceMs");
 async function* holdForOutstandingWork(ctx, iterationNum, hasToolCalls2, deliverInbound) {
-  const inbox = ctx.completionInbox?.hasPendingWork ? ctx.completionInbox : void 0;
+  const inbox = ctx.completionInbox?.holdsTurn ? ctx.completionInbox : void 0;
   const jobs = ctx.awaitedJobs?.hasPendingWork ? ctx.awaitedJobs : void 0;
   if (!inbox && !jobs)
     return false;
@@ -34738,7 +35529,12 @@ function settleOutstandingWork(ctx) {
 __name(settleOutstandingWork, "settleOutstandingWork");
 function recordAbandonedWork(ctx) {
   const abandoned = ctx.completionInbox?.outstandingTaskIds ?? [];
-  if (abandoned.length > 0) {
+  if (abandoned.length > 0 && ctx.completionInbox?.holdsTurnOpen === false) {
+    ctx.log.info("Turn ended with delegated work left running in the background", {
+      [NAMZU.TURN_ID]: ctx.recorder.turnId,
+      "namzu.runtime.tasks": abandoned
+    });
+  } else if (abandoned.length > 0) {
     ctx.log.warn("Turn ended with delegated work still running", {
       [NAMZU.TURN_ID]: ctx.recorder.turnId,
       "namzu.runtime.tasks": abandoned
@@ -34866,7 +35662,7 @@ function splitIdentifier(raw) {
   return parts.length > 1 ? parts : [];
 }
 __name(splitIdentifier, "splitIdentifier");
-function tokenize(text9) {
+function tokenize2(text9) {
   const out = [];
   for (const match2 of text9.matchAll(WORD)) {
     const raw = match2[0].replace(/^[.\-/\\:]+|[.\-/\\:]+$/g, "");
@@ -34877,11 +35673,11 @@ function tokenize(text9) {
       out.push(whole);
     const segments = raw.split(/[/\\.:\-]+/).filter((s) => s.length > 0);
     if (segments.length > 1) {
-      for (const segment of segments) {
-        const lower = segment.toLowerCase();
+      for (const segment2 of segments) {
+        const lower = segment2.toLowerCase();
         if (!STOP_WORDS.has(lower) && lower !== whole)
           out.push(lower);
-        for (const part2 of splitIdentifier(segment))
+        for (const part2 of splitIdentifier(segment2))
           out.push(part2.toLowerCase());
       }
     } else {
@@ -34894,7 +35690,7 @@ function tokenize(text9) {
   }
   return out;
 }
-__name(tokenize, "tokenize");
+__name(tokenize2, "tokenize");
 function termFrequencies(tokens) {
   const tf = /* @__PURE__ */ new Map();
   for (const token of tokens)
@@ -34907,7 +35703,7 @@ __name(termFrequencies, "termFrequencies");
 var K1 = 1.2;
 var B = 0.75;
 function indexDocument(text9) {
-  const tokens = tokenize(text9);
+  const tokens = tokenize2(text9);
   return { tf: termFrequencies(tokens), length: tokens.length };
 }
 __name(indexDocument, "indexDocument");
@@ -35045,10 +35841,10 @@ function scoreMessages(messages, options) {
   const n = messages.length;
   const texts = messages.map(messageText);
   const richContent = messages.map(hasRichContent);
-  const tokenLists = texts.map(tokenize);
+  const tokenLists = texts.map(tokenize2);
   const documents = texts.map(indexDocument);
   const index = buildIndex(documents);
-  const goalTokens = tokenize(options.goal);
+  const goalTokens = tokenize2(options.goal);
   const rawRelevance = documents.map((doc) => bm25Score(index, doc, goalTokens));
   const maxRelevance = Math.max(0, ...rawRelevance.filter((_, i) => {
     const m = messages[i];
@@ -36409,6 +37205,14 @@ async function runCompactionCheckInner(ctx, pass, options) {
       });
     }
   }
+  await ctx.emitEvent?.({
+    type: "compaction_started",
+    turnId: ctx.recorder.turnId,
+    iteration: ctx.recorder.currentIteration,
+    reason: pass.reason,
+    tokensBefore: estimatedTokens,
+    contextWindowTokens: budget
+  });
   const reducer = ctx.contextReducer ?? (config.strategy === "sliding-window" ? createSlidingWindowReducer() : void 0);
   if (reducer) {
     if (!options?.force && await stopOnRefill(ctx))
@@ -46152,35 +46956,35 @@ __name(assertTurnMayStart, "assertTurnMayStart");
 // ../sdk/dist/runtime/query/prompt.js
 function buildEnvContext(workingDirectory, config) {
   const { runtimeContext, tools, allowedTools } = config;
-  const lines2 = [
+  const lines = [
     `<env>
 Working directory: ${workingDirectory}
 ${config.sandboxed ? "Host platform" : "Platform"}: ${process.platform}`
   ];
   if (runtimeContext?.label) {
-    lines2.push(`Runtime: ${runtimeContext.label}`);
+    lines.push(`Runtime: ${runtimeContext.label}`);
   }
   if (runtimeContext?.outputDirectory) {
-    lines2.push(`Output directory: ${runtimeContext.outputDirectory}`);
+    lines.push(`Output directory: ${runtimeContext.outputDirectory}`);
   }
   if (runtimeContext?.outputFileMarker) {
-    lines2.push(`Output file marker: ${runtimeContext.outputFileMarker}`);
+    lines.push(`Output file marker: ${runtimeContext.outputFileMarker}`);
   }
   if (runtimeContext?.notes?.length) {
-    lines2.push("Runtime notes:");
+    lines.push("Runtime notes:");
     for (const note of runtimeContext.notes) {
-      lines2.push(`- ${note}`);
+      lines.push(`- ${note}`);
     }
   }
-  lines2.push(`</env>
+  lines.push(`</env>
 
 Resolve relative paths against the working directory above; use supplied absolute paths as given.`);
   if (hasFilesystemTools(tools, allowedTools)) {
-    lines2.push("When file contents are needed, read known file paths directly. Discover unknown paths with available filesystem tools using targeted directories and patterns.");
+    lines.push("When file contents are needed, read known file paths directly. Discover unknown paths with available filesystem tools using targeted directories and patterns.");
     const canGlob = tools.has("glob") && (!allowedTools || allowedTools.includes("glob")) && tools.availability("glob") === "active";
-    lines2.push(canGlob ? "For an immediate directory overview, use glob with pattern '*' or an available directory listing tool. Use '**' only when recursive discovery is needed." : "For an immediate directory overview, use an available directory listing tool.", "Keep discovery within the task's scope; do not recursively inventory unrelated home directories or cache trees.");
+    lines.push(canGlob ? "For an immediate directory overview, use glob with pattern '*' or an available directory listing tool. Use '**' only when recursive discovery is needed." : "For an immediate directory overview, use an available directory listing tool.", "Keep discovery within the task's scope; do not recursively inventory unrelated home directories or cache trees.");
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(buildEnvContext, "buildEnvContext");
 function hasFilesystemTools(tools, allowedTools) {
@@ -46198,18 +47002,18 @@ function hasFilesystemTools(tools, allowedTools) {
 }
 __name(hasFilesystemTools, "hasFilesystemTools");
 function buildShellContext(config) {
-  const lines2 = [];
+  const lines = [];
   for (const name2 of config.allowedTools ?? config.tools.listNames()) {
     const tool = config.tools.get(name2);
     if (!tool?.commandArgument || !tool.commandDialect || config.tools.availability(name2) !== "active")
       continue;
     const dialect = tool.commandDialect({ sandboxed: config.sandboxed === true });
     const gitBash = !config.sandboxed && dialect === "bash" && isWindowsBash();
-    lines2.push(`Execution shell for ${name2}: ${dialect}${config.sandboxed ? " (sandbox guest)" : gitBash ? " (Git Bash on Windows, host)" : " (host)"}.`);
+    lines.push(`Execution shell for ${name2}: ${dialect}${config.sandboxed ? " (sandbox guest)" : gitBash ? " (Git Bash on Windows, host)" : " (host)"}.`);
     if (dialect === "cmd")
-      lines2.push("Use native Windows CMD command syntax. Single quotes do not quote arguments; backslashes do not escape shell operators. PowerShell syntax requires explicitly invoking PowerShell. Command-specific automatic permission grants are unavailable; an exact-call review may be required.");
+      lines.push("Use native Windows CMD command syntax. Single quotes do not quote arguments; backslashes do not escape shell operators. PowerShell syntax requires explicitly invoking PowerShell. Command-specific automatic permission grants are unavailable; an exact-call review may be required.");
   }
-  return lines2.length > 0 ? lines2.join("\n") : void 0;
+  return lines.length > 0 ? lines.join("\n") : void 0;
 }
 __name(buildShellContext, "buildShellContext");
 var PromptBuilder = class {
@@ -47124,11 +47928,11 @@ function normalizeLine(line) {
   return line.replace(/^\s*\d+[\s:.|)]+/, "").replace(/\d+/g, "N");
 }
 __name(normalizeLine, "normalizeLine");
-function collapseRepeated(lines2) {
+function collapseRepeated(lines) {
   const result = [];
   let prevNorm = "";
   let repeatCount = 0;
-  for (const line of lines2) {
+  for (const line of lines) {
     const norm = normalizeLine(line);
     if (norm === prevNorm && norm.trim().length > 0) {
       repeatCount++;
@@ -47152,14 +47956,14 @@ function compressShellOutputFull(raw, options) {
   const minReduction = options?.minReductionPercent ?? DEFAULT_MIN_REDUCTION;
   const maxStackFrames = options?.maxStackFrames ?? DEFAULT_MAX_STACK_FRAMES;
   const maxPassLines = options?.maxPassLines ?? DEFAULT_MAX_PASS_LINES;
-  const lines2 = raw.split("\n");
-  if (lines2.length < minLines) {
+  const lines = raw.split("\n");
+  if (lines.length < minLines) {
     return { text: raw, original: null };
   }
   const pass1 = [];
   let stackCount = 0;
   let passCount = 0;
-  for (const line of lines2) {
+  for (const line of lines) {
     if (NOISE_RE.test(line)) {
       continue;
     }
@@ -53614,7 +54418,7 @@ function createMemoryRecallStep(options) {
     const terms2 = [
       .../* @__PURE__ */ new Set([
         ...anchors,
-        ...tokenize(options.identifierGrounding === true ? query2.slice(-4e3).normalize("NFKC") : query2.slice(-4e3))
+        ...tokenize2(options.identifierGrounding === true ? query2.slice(-4e3).normalize("NFKC") : query2.slice(-4e3))
       ])
     ].filter((term) => term.length > 1 && !GLUE.has(term)).slice(0, 32);
     if (terms2.length === 0 || charBudget <= HEADER.length)
@@ -55587,13 +56391,13 @@ function parseValue(raw, file, line) {
 __name(parseValue, "parseValue");
 function parseMemoryFile(raw, file) {
   const text9 = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
-  const lines2 = text9.split("\n");
-  if (!FENCE.test((lines2[0] ?? "").replace(/\r$/, ""))) {
+  const lines = text9.split("\n");
+  if (!FENCE.test((lines[0] ?? "").replace(/\r$/, ""))) {
     throw new MemoryFileFormatError(file, "a memory file must start with a --- frontmatter fence", 1);
   }
   let closing = -1;
-  for (let i = 1; i < lines2.length; i++) {
-    if (FENCE.test((lines2[i] ?? "").replace(/\r$/, ""))) {
+  for (let i = 1; i < lines.length; i++) {
+    if (FENCE.test((lines[i] ?? "").replace(/\r$/, ""))) {
       closing = i;
       break;
     }
@@ -55611,7 +56415,7 @@ function parseMemoryFile(raw, file) {
   }, "closeList");
   for (let i = 1; i < closing; i++) {
     const lineNumber = i + 1;
-    const line = (lines2[i] ?? "").replace(/\r$/, "");
+    const line = (lines[i] ?? "").replace(/\r$/, "");
     if (!line.trim() || line.trimStart().startsWith("#"))
       continue;
     const item = ITEM_LINE.exec(line);
@@ -55645,7 +56449,7 @@ function parseMemoryFile(raw, file) {
     values.set(typedKey, parseValue(rawValue, file, lineNumber));
   }
   closeList();
-  let body = lines2.slice(closing + 1).join("\n");
+  let body = lines.slice(closing + 1).join("\n");
   body = body.replace(/^\r?\n/, "").replace(/\r?\n$/, "");
   return { values, body };
 }
@@ -55663,9 +56467,9 @@ function formatValue(value) {
 }
 __name(formatValue, "formatValue");
 function formatMemoryFile(fields2, body) {
-  const lines2 = ["---"];
+  const lines = ["---"];
   const put = /* @__PURE__ */ __name((key5, value) => {
-    lines2.push(`${key5}: ${formatValue(value)}`);
+    lines.push(`${key5}: ${formatValue(value)}`);
   }, "put");
   put("name", fields2.name);
   put("description", fields2.description);
@@ -55674,7 +56478,7 @@ function formatMemoryFile(fields2, body) {
   put("createdAt", new Date(fields2.createdAt).toISOString());
   put("updatedAt", new Date(fields2.updatedAt).toISOString());
   if (fields2.tags.length > 0)
-    lines2.push(`tags: ${JSON.stringify(fields2.tags)}`);
+    lines.push(`tags: ${JSON.stringify(fields2.tags)}`);
   put("id", fields2.id);
   if (fields2.title !== fields2.name)
     put("title", fields2.title);
@@ -55683,9 +56487,9 @@ function formatMemoryFile(fields2, body) {
   if (fields2.format !== "markdown")
     put("format", fields2.format);
   if (fields2.metadata !== void 0)
-    lines2.push(`metadata: ${JSON.stringify(fields2.metadata)}`);
-  lines2.push("---", "", body);
-  return `${lines2.join("\n")}${body.endsWith("\r") ? "\r\n" : "\n"}`;
+    lines.push(`metadata: ${JSON.stringify(fields2.metadata)}`);
+  lines.push("---", "", body);
+  return `${lines.join("\n")}${body.endsWith("\r") ? "\r\n" : "\n"}`;
 }
 __name(formatMemoryFile, "formatMemoryFile");
 
@@ -56969,8 +57773,8 @@ var DiskMessageFeedbackStore = class {
       }
       ids.set(messageId4, messageId4);
     }
-    for (const segment of await records2.scanNames(this.revisionsDir(sessionId5), "")) {
-      const decoded = decodeRevisionFileSegment(segment);
+    for (const segment2 of await records2.scanNames(this.revisionsDir(sessionId5), "")) {
+      const decoded = decodeRevisionFileSegment(segment2);
       if (decoded === null)
         continue;
       const messageId4 = asMessageId(decoded);
@@ -60055,9 +60859,9 @@ var StdioTransport = class {
     return this.connected;
   }
   processBuffer() {
-    const lines2 = this.buffer.split("\n");
-    this.buffer = lines2.pop() ?? "";
-    for (const line of lines2) {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed)
         continue;
@@ -60806,11 +61610,11 @@ function parseSseMessages(raw) {
   const messages = [];
   let lastEventId;
   for (const event of events) {
-    const lines2 = event.split("\n");
-    const idLines = lines2.filter((line) => line.startsWith("id:")).map((line) => line.slice("id:".length).trim());
+    const lines = event.split("\n");
+    const idLines = lines.filter((line) => line.startsWith("id:")).map((line) => line.slice("id:".length).trim());
     if (idLines.length > 0)
       lastEventId = idLines.at(-1);
-    const dataLines = lines2.filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart());
+    const dataLines = lines.filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart());
     if (dataLines.length === 0)
       continue;
     const data = dataLines.join("\n").trim();
@@ -61253,7 +62057,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.6.0";
+var VERSION2 = "53.0.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -62843,18 +63647,18 @@ var MCPToolDiscovery = class {
 
 // ../sdk/dist/connector/mcp/prompt-adapter.js
 function renderPromptMessages(serverName, promptName, messages, description) {
-  const lines2 = [];
+  const lines = [];
   if (description)
-    lines2.push(description, "");
+    lines.push(description, "");
   for (const message of messages) {
     const body = message.content.type === "text" ? message.content.text : message.content.type === "resource" ? message.content.resource.text ?? `[resource ${message.content.resource.uri}]` : `[${message.content.type}]`;
-    lines2.push(`[${message.role}] ${body}`, "");
+    lines.push(`[${message.role}] ${body}`, "");
   }
   return wrapUntrusted({
     kind: "mcp-prompt",
     attributes: { server: serverName, name: promptName },
     provenance: "This is content the named server composed, not this agent."
-  }, lines2.join("\n").trimEnd());
+  }, lines.join("\n").trimEnd());
 }
 __name(renderPromptMessages, "renderPromptMessages");
 function argumentSchema(prompt) {
@@ -64138,7 +64942,7 @@ function derivedUncertainty(report) {
 }
 __name(derivedUncertainty, "derivedUncertainty");
 function formatReport(report) {
-  const lines2 = [
+  const lines = [
     `${report.name}: ${report.passed}/${report.cases.length} passed (mean ${report.mean.toFixed(2)}) in ${report.durationMs}ms`,
     // On its own line and always printed, including when the interval is
     // undefined. A mean printed alone is the thing that has been
@@ -64150,41 +64954,41 @@ function formatReport(report) {
     ""
   ];
   if (report.inconclusive > 0) {
-    lines2.push(`  ${report.inconclusive} case${report.inconclusive === 1 ? "" : "s"} could not be judged \u2014 the numbers below cover the rest`, "");
+    lines.push(`  ${report.inconclusive} case${report.inconclusive === 1 ? "" : "s"} could not be judged \u2014 the numbers below cover the rest`, "");
   }
   for (const [name2, mean] of Object.entries(report.byScorer)) {
-    lines2.push(`  ${name2}: ${mean.toFixed(2)}`);
+    lines.push(`  ${name2}: ${mean.toFixed(2)}`);
   }
   const failures = report.cases.filter((c) => c.status === "failed");
   if (failures.length > 0) {
-    lines2.push("", "Failures:");
+    lines.push("", "Failures:");
     for (const failure2 of failures) {
-      lines2.push(`  \u2717 ${failure2.case} (${failure2.mean.toFixed(2)})`);
+      lines.push(`  \u2717 ${failure2.case} (${failure2.mean.toFixed(2)})`);
       if (failure2.failedGates && failure2.failedGates.length > 0) {
-        lines2.push(`      gate missed: ${failure2.failedGates.join(", ")}`);
+        lines.push(`      gate missed: ${failure2.failedGates.join(", ")}`);
       }
       for (const [name2, score] of Object.entries(failure2.scores)) {
         if (score.unavailable === true) {
-          lines2.push(`      ${name2}: not judged \u2014 ${score.reason}`);
+          lines.push(`      ${name2}: not judged \u2014 ${score.reason}`);
         } else if (score.score < 1) {
-          lines2.push(`      ${name2}: ${score.reason}`);
+          lines.push(`      ${name2}: ${score.reason}`);
         }
       }
       if (failure2.turn.error)
-        lines2.push(`      error: ${failure2.turn.error}`);
+        lines.push(`      error: ${failure2.turn.error}`);
     }
   }
   const unjudged = report.cases.filter((c) => c.status === "inconclusive");
   if (unjudged.length > 0) {
-    lines2.push("", "Not judged:");
+    lines.push("", "Not judged:");
     for (const item of unjudged) {
-      lines2.push(`  ? ${item.case}`);
+      lines.push(`  ? ${item.case}`);
       for (const [name2, score] of Object.entries(item.scores)) {
-        lines2.push(`      ${name2}: ${score.reason}`);
+        lines.push(`      ${name2}: ${score.reason}`);
       }
     }
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(formatReport, "formatReport");
 
@@ -64427,8 +65231,6 @@ var PLAN_MODE_DOCTRINE = `## Plan mode
 You are in plan mode. Read, search and think; do not change anything. \`read\`, \`grep\`, \`glob\` and the other read-only tools work as usual, and you may keep a task list. Any \`edit\`, \`write\` or shell command that changes state will be refused, so do not attempt one.
 
 When you have understood the task, reply with the plan: what you would change, in which files, in what order, and what you would verify. Be concrete \u2014 name files and functions \u2014 and short enough to read in one screen. Then stop and wait; the user will leave plan mode to have the plan carried out, and that switch is their approval.`;
-var CODING_AGENT_HYPERMODE_DOCTRINE = `### Hypermode
-This session has hypermode on: treat delegation through \`Agent\` as the default for substantive work, not the exception. Before doing multi-step work yourself, ask whether an independent piece of it \u2014 a lookup, a draft, a check \u2014 could run as its own delegation, and prefer delegating it when the answer is yes. This changes only how eagerly you reach for \`Agent\` on work you would otherwise do inline; it does not mount a roster or start any delegation by itself. Agents in the same phase are launched in the same response, each with \`run_in_background: true\` when you mean to wait for them together; a phase is never started one agent at a time.`;
 
 // ../sdk/dist/manager/resident/learning.js
 import { createHash as createHash23 } from "node:crypto";
@@ -68979,8 +69781,8 @@ var WorkerCodeRuntime = class {
         calls
       };
     }
-    const appendOutput = /* @__PURE__ */ __name((lines2) => {
-      for (const line of lines2) {
+    const appendOutput = /* @__PURE__ */ __name((lines) => {
+      for (const line of lines) {
         if (truncated)
           return;
         const next = printCount === 0 ? line : `${output}
@@ -69660,6 +70462,15 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 		if (t === 'object') return typeof value.then === 'function' ? 'a promise' : 'an object';
 		return 'a ' + t;
 	}
+	function overBudget() {
+		return config.tokenLimit !== null && config.tokenLimit > 0 && spent.tokensUsed >= config.tokenLimit;
+	}
+	function budgetError() {
+		var e = new Error('Workflow token budget exceeded (' + spent.tokensUsed.toLocaleString('en-US') + ' / ' + config.tokenLimit.toLocaleString('en-US') + ' output tokens). Stopping further agent() calls. Agents already running will finish and their results are kept.');
+		e.name = 'WorkflowBudgetExceededError';
+		return e;
+	}
+	function isBudgetError(e) { return !!e && e.name === 'WorkflowBudgetExceededError'; }
 	async function agent(prompt, opts) {
 		if (typeof prompt !== 'string' || prompt.length === 0) {
 			throw new TypeError('agent(prompt, options?): the prompt must be a non-empty string, got ' + kind(prompt));
@@ -69668,6 +70479,7 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 		if (typeof o !== 'object' || Array.isArray(o)) {
 			throw new TypeError('agent(prompt, options?): options must be an object, got ' + kind(o));
 		}
+		if (overBudget()) throw budgetError();
 		var request = { prompt: prompt, cursor: cursor };
 		if (o.label != null) request.label = clean(o.label, 120);
 		if (o.phase != null) request.phase = clean(o.phase, 120);
@@ -69688,7 +70500,16 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 				throw new TypeError('parallel(thunks): item ' + (p + 1) + ' must be a function (wrap the work as () => agent(...)), got ' + kind(thunks[p]));
 			}
 		}
-		return Promise.all(thunks.map(function (t) { return t(); }));
+		var dropped = 0;
+		var results = await Promise.all(thunks.map(function (t, n) {
+			return Promise.resolve().then(t).catch(function (e) {
+				if (isBudgetError(e)) { dropped++; return null; }
+				log('Step ' + (n + 1) + ' stopped: ' + clean(e && e.message ? e.message : e, 300));
+				return null;
+			});
+		}));
+		if (dropped > 0) log('parallel: ' + dropped + (dropped === 1 ? ' item' : ' items') + ' dropped because the token budget is spent.');
+		return results;
 	}
 	async function pipeline(items) {
 		if (!Array.isArray(items)) {
@@ -69700,16 +70521,31 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 				throw new TypeError('pipeline(items, ...stages): stage ' + (s + 1) + ' must be a function, got ' + kind(stages[s]));
 			}
 		}
-		return Promise.all(items.map(async function (item, index) {
+		if (items.length > 0 && overBudget()) throw budgetError();
+		var dropped = 0;
+		var results = await Promise.all(items.map(async function (item, index) {
 			var value = item;
 			for (var i = 0; i < stages.length; i++) {
-				value = await stages[i](value, index, item);
+				try {
+					value = await stages[i](value, item, index);
+				} catch (e) {
+					if (isBudgetError(e)) { dropped++; return null; }
+					log('Item ' + (index + 1) + ' stopped at step ' + (i + 1) + ': ' + clean(e && e.message ? e.message : e, 300));
+					return null;
+				}
 				if (value === null || value === undefined) return null;
 			}
 			return value;
 		}));
+		if (dropped > 0) log('pipeline: ' + dropped + (dropped === 1 ? ' item' : ' items') + ' dropped because the token budget is spent.');
+		return results;
 	}
 	var budget = Object.freeze({
+		get total() { return config.tokenLimit; },
+		spent: function () { return spent.tokensUsed; },
+		remaining: function () {
+			return config.tokenLimit === null ? Infinity : Math.max(0, config.tokenLimit - spent.tokensUsed);
+		},
 		get tokensUsed() { return spent.tokensUsed; },
 		get tokenLimit() { return config.tokenLimit === null ? undefined : config.tokenLimit; },
 	});
@@ -69888,6 +70724,11 @@ var AGENT_CALL_KEYS = /* @__PURE__ */ new Set([
   "model",
   "effort"
 ]);
+function defaultAgentLabel(prompt, index) {
+  const label5 = prompt.slice(0, 60).replace(/\s+/g, " ").trim();
+  return label5.length > 0 ? label5 : `Agent ${index}`;
+}
+__name(defaultAgentLabel, "defaultAgentLabel");
 function integer4(name2, value, min, max) {
   if (!Number.isSafeInteger(value) || value < min || value > max) {
     throw new RangeError(`${name2} must be an integer between ${min} and ${max}.`);
@@ -69896,10 +70737,10 @@ function integer4(name2, value, min, max) {
 }
 __name(integer4, "integer");
 function resolveWorkflowLimits(limits = {}) {
-  const defaultConcurrency = Math.min(8, Math.max(1, cpus().length - 2));
+  const defaultConcurrency = Math.min(16, Math.max(2, cpus().length - 2));
   return {
     maxConcurrency: integer4("maxConcurrency", limits.maxConcurrency ?? defaultConcurrency, 1, 16),
-    maxAgents: integer4("maxAgents", limits.maxAgents ?? 200, 1, 1e3),
+    maxAgents: integer4("maxAgents", limits.maxAgents ?? 1e3, 1, 1e3),
     maxSourceBytes: integer4("maxSourceBytes", limits.maxSourceBytes ?? 256 * 1024, 1, 4 * 1024 * 1024),
     memoryLimitBytes: integer4("memoryLimitBytes", limits.memoryLimitBytes ?? 64 * 1024 * 1024, 16 * 1024 * 1024, 256 * 1024 * 1024),
     maxValueBytes: integer4("maxValueBytes", limits.maxValueBytes ?? 1024 * 1024, 1, 16 * 1024 * 1024),
@@ -70231,7 +71072,7 @@ var WorkflowRuntime = class {
       const queuedAt = now();
       const agent = {
         index,
-        label: call2.label || `Agent ${index}`,
+        label: call2.label || defaultAgentLabel(call2.prompt, index),
         prompt: call2.prompt,
         ...phase ? { phaseIndex: phase.index, phaseTitle: phase.title } : {},
         ...call2.agentType !== void 0 ? { agentType: call2.agentType } : {},
@@ -73020,7 +73861,7 @@ function pathOf(toolInput) {
   return void 0;
 }
 __name(pathOf, "pathOf");
-var REFERENCE_EVENT_NAMES = {
+var PASCAL_EVENT_NAMES = {
   user_prompt_submit: "UserPromptSubmit",
   session_start: "SessionStart",
   session_end: "SessionEnd",
@@ -73099,7 +73940,7 @@ function readShellHookJson(event, stdout) {
   if (typeof named !== "string") {
     return { invalid: "`hookSpecificOutput` is missing its `hookEventName`" };
   }
-  if (named !== event && named !== REFERENCE_EVENT_NAMES[event]) {
+  if (named !== event && named !== PASCAL_EVENT_NAMES[event]) {
     return {
       invalid: `\`hookSpecificOutput.hookEventName\` is "${named}" but this hook ran for ${event}`
     };
@@ -73708,7 +74549,7 @@ var AgentManager = class {
   }
   /**
    * The refusal for a delegation past the depth limit. It tells the model what
-   * to do instead (the reference terminal's rule): a bare limit leaves it
+   * to do instead: a bare limit leaves it
    * retrying the same spawn, while an instruction to do the work itself ends the
    * attempt. The limit is `AgentManagerConfig.maxDepth`; there is no env override.
    */
@@ -76796,17 +77637,17 @@ function planWalk(root, options) {
     });
   });
   const sets = matchers.flatMap((matcher) => matcher.set);
-  if (sets.some((set3) => set3.some((segment) => segment === ".."))) {
+  if (sets.some((set3) => set3.some((segment2) => segment2 === ".."))) {
     throw new Error("Expanded file walk pattern escapes its root");
   }
   const patternDepth = Math.max(1, ...sets.map((set3) => set3.includes(GLOBSTAR) ? Number.POSITIVE_INFINITY : set3.length));
   const maxDepth = Math.min(patternDepth, options.maxDepth === void 0 ? Number.POSITIVE_INFINITY : positiveInteger(options.maxDepth, "maxDepth"));
   const prefix = [];
   for (let index = 0; sets.length > 0; index += 1) {
-    const segment = sets[0]?.[index];
-    if (typeof segment !== "string" || !segment || segment === "." || sets.some((set3) => index >= set3.length - 1 || set3[index] !== segment))
+    const segment2 = sets[0]?.[index];
+    if (typeof segment2 !== "string" || !segment2 || segment2 === "." || sets.some((set3) => index >= set3.length - 1 || set3[index] !== segment2))
       break;
-    prefix.push(segment);
+    prefix.push(segment2);
   }
   const expressions = matchers.flatMap((matcher) => {
     const expression = matcher.makeRe();
@@ -76820,7 +77661,7 @@ function planWalk(root, options) {
     maxEntries: positiveInteger(options.maxEntries, "maxEntries"),
     maxVisitedEntries: positiveInteger(options.maxVisitedEntries ?? 2e4, "maxVisitedEntries"),
     includeHidden: options.includeHidden ?? false,
-    patterns: sets.map((set3) => set3.map((segment) => segment === GLOBSTAR ? null : typeof segment === "string" ? segment : { source: segment.source, flags: segment.flags }))
+    patterns: sets.map((set3) => set3.map((segment2) => segment2 === GLOBSTAR ? null : typeof segment2 === "string" ? segment2 : { source: segment2.source, flags: segment2.flags }))
   };
 }
 __name(planWalk, "planWalk");
@@ -76837,11 +77678,11 @@ function directoryMatcher(plan) {
     for (const name2 of relative10.split("/")) {
       const next = /* @__PURE__ */ new Set();
       for (const index of states) {
-        const segment = pattern[index];
-        if (segment === null) {
+        const segment2 = pattern[index];
+        if (segment2 === null) {
           if (plan.includeHidden || !name2.startsWith("."))
             next.add(index);
-        } else if (typeof segment === "string" ? segment === name2 : segment?.test(name2))
+        } else if (typeof segment2 === "string" ? segment2 === name2 : segment2?.test(name2))
           next.add(index + 1);
       }
       states = closure(next);
@@ -78122,11 +78963,11 @@ __name(isStrictDescendant, "isStrictDescendant");
 function parseWorktreeList(stdout, worktreePath) {
   const blocks = stdout.split(/\n\n+/);
   for (const block of blocks) {
-    const lines2 = block.split("\n").filter((l) => l.length > 0);
+    const lines = block.split("\n").filter((l) => l.length > 0);
     let path2;
     let head2;
     let branch;
-    for (const line of lines2) {
+    for (const line of lines) {
       if (line.startsWith("worktree "))
         path2 = line.slice("worktree ".length);
       else if (line.startsWith("HEAD "))
@@ -86270,17 +87111,17 @@ var CodeAnalysisTool = defineTool({
           });
           return render3(result, (value) => {
             const f = value.files;
-            const lines2 = [
+            const lines = [
               `Indexed ${value.root}: ${f.indexed} files (${f.parsed} parsed, ${f.unchanged} unchanged, ${f.removed} removed, ${f.skipped} skipped, ${f.withParseErrors} with parse errors) in ${value.durationMs} ms.`,
               `${value.functions} functions, ${value.strings} string literals, ${value.calls} calls. ${value.persisted ? "Cached on disk." : "Held in memory only; it is gone when this process exits."}`
             ];
             if (value.truncated)
-              lines2.push(value.truncated);
+              lines.push(value.truncated);
             const reasons = Object.entries(value.skippedReasons);
             if (reasons.length > 0) {
-              lines2.push(`Skipped: ${reasons.map(([why, n]) => `${n} ${why}`).join(", ")}.`);
+              lines.push(`Skipped: ${reasons.map(([why, n]) => `${n} ${why}`).join(", ")}.`);
             }
-            return lines2;
+            return lines;
           });
         }
         case "find_literal": {
@@ -86315,13 +87156,13 @@ var CodeAnalysisTool = defineTool({
                 value.inClass !== void 0 ? `${place} is in the body of class ${value.inClass}, outside every method; not inside any function.` : `${place} is not inside any function.`
               ];
             }
-            const lines2 = [describeFunction(value.function, root)];
+            const lines = [describeFunction(value.function, root)];
             if (value.parents.length > 0) {
-              lines2.push(`parents: ${value.parents.map(shortFunction).join(" < ")}`);
+              lines.push(`parents: ${value.parents.map(shortFunction).join(" < ")}`);
             }
             if (value.source)
-              lines2.push(...sourceLines(value.source));
-            return lines2;
+              lines.push(...sourceLines(value.source));
+            return lines;
           });
         }
         case "function_source": {
@@ -86445,8 +87286,8 @@ function relativeTo(root, path2) {
 }
 __name(relativeTo, "relativeTo");
 function shortFunction(fn) {
-  const lines2 = fn.endLine === fn.line ? `L${fn.line}` : `L${fn.line}-${fn.endLine}`;
-  return `${fn.qualifiedName ?? fn.name ?? "(anonymous)"}#${fn.id} ${lines2}`;
+  const lines = fn.endLine === fn.line ? `L${fn.line}` : `L${fn.line}-${fn.endLine}`;
+  return `${fn.qualifiedName ?? fn.name ?? "(anonymous)"}#${fn.id} ${lines}`;
 }
 __name(shortFunction, "shortFunction");
 function describeFunction(fn, root) {
@@ -86464,21 +87305,21 @@ function describeEdge(edge) {
 }
 __name(describeEdge, "describeEdge");
 function sourceLines(slice) {
-  const lines2 = ["--- source ---", slice.text];
+  const lines = ["--- source ---", slice.text];
   if (slice.truncated) {
-    lines2.push(slice.window ? `--- cut: showing ${slice.text.length} of ${slice.chars} characters, the function's first ${slice.window.headerChars} and the part around the position; raise max_chars to see more ---` : `--- cut: showing ${slice.text.length} of ${slice.chars} characters; raise max_chars to see more ---`);
+    lines.push(slice.window ? `--- cut: showing ${slice.text.length} of ${slice.chars} characters, the function's first ${slice.window.headerChars} and the part around the position; raise max_chars to see more ---` : `--- cut: showing ${slice.text.length} of ${slice.chars} characters; raise max_chars to see more ---`);
   }
-  return lines2;
+  return lines;
 }
 __name(sourceLines, "sourceLines");
 function evidenceLines(evidence) {
-  const lines2 = [];
+  const lines = [];
   if (evidence.observed.length > 0)
-    lines2.push(`observed: ${evidence.observed.join("; ")}`);
+    lines.push(`observed: ${evidence.observed.join("; ")}`);
   if (evidence.inferred.length > 0)
-    lines2.push(`inferred: ${evidence.inferred.join("; ")}`);
-  lines2.push(evidence.coverage.status === "complete" ? "coverage: complete" : `coverage: partial - ${evidence.coverage.reasons.join("; ")}`);
-  return lines2;
+    lines.push(`inferred: ${evidence.inferred.join("; ")}`);
+  lines.push(evidence.coverage.status === "complete" ? "coverage: complete" : `coverage: partial - ${evidence.coverage.reasons.join("; ")}`);
+  return lines;
 }
 __name(evidenceLines, "evidenceLines");
 function render3(result, body, data) {
@@ -86504,18 +87345,18 @@ function renderPage(result, line, fileOf) {
     if (page.items.length === 0) {
       return [page.total === 0 ? "No results." : "No results on this page."];
     }
-    const lines2 = [];
+    const lines = [];
     let current;
     for (const item of page.items) {
       const file = fileOf?.(item);
       if (file !== void 0 && file !== current) {
-        lines2.push(file);
+        lines.push(file);
         current = file;
       }
-      lines2.push(file === void 0 ? line(item) : `  ${line(item)}`);
+      lines.push(file === void 0 ? line(item) : `  ${line(item)}`);
     }
-    lines2.push(page.nextCursor !== void 0 ? `-- ${page.items.length} of ${page.total} shown. next cursor: ${page.nextCursor}` : `-- ${page.items.length} of ${page.total} shown. last page.`);
-    return lines2;
+    lines.push(page.nextCursor !== void 0 ? `-- ${page.items.length} of ${page.total} shown. next cursor: ${page.nextCursor}` : `-- ${page.items.length} of ${page.total} shown. last page.`);
+    return lines;
   }, (page) => ({
     total: page.total,
     count: page.items.length,
@@ -87082,15 +87923,15 @@ function grantNotice(allowed, grant, canGrant) {
 
 [This skill lists allowed-tools (${allowed.join(", ")}), but this host applies no pre-approval, so those calls are reviewed as usual. ${unchanged}]`;
   }
-  const lines2 = [];
-  lines2.push(grant.granted.length > 0 ? `Pre-approved for the rest of this turn: ${grant.granted.join(", ")}. Deny and ask rules, plan and strict mode, and review of destructive calls still apply.` : "Nothing in allowed-tools could be pre-approved.");
+  const lines = [];
+  lines.push(grant.granted.length > 0 ? `Pre-approved for the rest of this turn: ${grant.granted.join(", ")}. Deny and ask rules, plan and strict mode, and review of destructive calls still apply.` : "Nothing in allowed-tools could be pre-approved.");
   for (const { entry, reason: reason2 } of grant.ignored) {
-    lines2.push(`Ignored allowed-tools entry "${entry}": ${reason2}.`);
+    lines.push(`Ignored allowed-tools entry "${entry}": ${reason2}.`);
   }
-  lines2.push(unchanged);
+  lines.push(unchanged);
   return `
 
-[${lines2.join(" ")}]`;
+[${lines.join(" ")}]`;
 }
 __name(grantNotice, "grantNotice");
 
@@ -88380,38 +89221,38 @@ function buildDescription(host, caps, settings) {
   const available = availableActions(host, caps);
   const unavailable3 = unavailableHostActions(host, caps);
   const intro = hostActionAvailable(caps, "screenshot") ? `Controls the user's desktop on a ${caps.displayServer} host: screenshots, mouse and keyboard, for GUI tasks.` : windowCaptureAvailable(host, caps) ? `Controls named windows on a ${caps.displayServer} host: window screenshots, mouse and keyboard, for GUI tasks.` : available.length > 0 ? `Offers the available computer controls on a ${caps.displayServer} host.` : `Computer control is unavailable on this ${caps.displayServer} host; this tool reports the limitation.`;
-  const lines2 = [intro, `Available actions: ${available.join("; ") || "none"}.`];
+  const lines = [intro, `Available actions: ${available.join("; ") || "none"}.`];
   if (unavailable3.length > 0) {
-    lines2.push(caps.unavailableReason ? `Unavailable on this host: ${unavailable3.join(", ")} \u2014 ${caps.unavailableReason} Do not retry; tell the user.` : `Unavailable on this host: ${unavailable3.join(", ")}.`);
+    lines.push(caps.unavailableReason ? `Unavailable on this host: ${unavailable3.join(", ")} \u2014 ${caps.unavailableReason} Do not retry; tell the user.` : `Unavailable on this host: ${unavailable3.join(", ")}.`);
   }
   if (!available.includes("screenshot"))
-    return finish(lines2, caps, available);
-  lines2.push('Coordinates: every x/y you send is a pixel of the most recent screenshot this tool returned \u2014 origin at its top-left, x to the right, y down \u2014 never a screen pixel. Each screenshot states its id and size (for example "s3: 1456x819"); stay inside it. Display screenshots map onto the display. To aim at an earlier display screenshot, pass its id as screenshot_id.', "Take a screenshot before your first click.");
+    return finish(lines, caps, available);
+  lines.push('Coordinates: every x/y you send is a pixel of the most recent screenshot this tool returned \u2014 origin at its top-left, x to the right, y down \u2014 never a screen pixel. Each screenshot states its id and size (for example "s3: 1456x819"); stay inside it. Display screenshots map onto the display. To aim at an earlier display screenshot, pass its id as screenshot_id.', "Take a screenshot before your first click.");
   if (settings.screenshotAfterActions)
-    lines2.push(`After any action that changes something, the tool waits ${settings.settleMs} ms and returns a new screenshot \u2014 do not call screenshot again after acting.`);
-  lines2.push("zoom returns a closer, sharper view of region {x, y, width, height} of the screenshot; your coordinates still refer to the screenshot, not to the zoomed image.", `wait pauses for ms milliseconds (at most ${settings.maxWaitMs} per call, a batch's waits together) and then shows the screen.`);
+    lines.push(`After any action that changes something, the tool waits ${settings.settleMs} ms and returns a new screenshot \u2014 do not call screenshot again after acting.`);
+  lines.push("zoom returns a closer, sharper view of region {x, y, width, height} of the screenshot; your coordinates still refer to the screenshot, not to the zoomed image.", `wait pauses for ms milliseconds (at most ${settings.maxWaitMs} per call, a batch's waits together) and then shows the screen.`);
   if (available.includes("batch"))
-    lines2.push(`batch: {"type":"batch","actions":[...]} runs up to ${settings.maxBatchActions} actions in order, stops at the first one that fails, and returns one screenshot at the end. Every call costs a model round trip of several seconds, so put the steps you can already predict into one batch (click a field, type, press ENTER) rather than one call each \u2014 but end the batch at any step that should bring up a new window, and look before typing into it. A batch cannot contain screenshot${available.includes("ui_snapshot") ? ", zoom or ui_snapshot" : " or zoom"}.`);
+    lines.push(`batch: {"type":"batch","actions":[...]} runs up to ${settings.maxBatchActions} actions in order, stops at the first one that fails, and returns one screenshot at the end. Every call costs a model round trip of several seconds, so put the steps you can already predict into one batch (click a field, type, press ENTER) rather than one call each \u2014 but end the batch at any step that should bring up a new window, and look before typing into it. A batch cannot contain screenshot${available.includes("ui_snapshot") ? ", zoom or ui_snapshot" : " or zoom"}.`);
   if (caps.displayServer === "win32" && available.includes("key") && available.includes("type_text"))
-    lines2.push("To start a Windows program, a shell command (Start-Process notepad, or cmd.exe /c start calc) is surest when you have a shell tool. The Start menu searches by display names in the system language, and ENTER on a name it does not find opens a web search in the browser.");
+    lines.push("To start a Windows program, a shell command (Start-Process notepad, or cmd.exe /c start calc) is surest when you have a shell tool. The Start menu searches by display names in the system language, and ENTER on a name it does not find opens a web search in the browser.");
   if (available.includes("list_windows"))
-    lines2.push("list_windows names the open windows with their ids; focus_window brings one to the front.");
+    lines.push("list_windows names the open windows with their ids; focus_window brings one to the front.");
   if (windowCaptureAvailable(host, caps))
-    lines2.push(`When the user names an application or window, ${available.includes("list_windows") ? "use list_windows then screenshot {window_id}" : "use screenshot {window_id} with a host-provided window id"} to capture pixels for that window. Its x/y are pixels of that window image; clicks, drags, typing and keys target that window. Window pointer input uses background delivery only; if a click or drag is refused, inspect a fresh image before any other action. ${caps.windowScroll === false ? `Window pixel scrolling is unavailable on this host; for a browser page use key PAGE_DOWN or ARROW_DOWN with delivery_mode:"foreground"${hostActionAvailable(caps, "screenshot") ? ", or deliberately take a display screenshot for display scrolling" : ""}. ` : ""}To type into a browser field, first mouse_click its point in the window image, then type_text with delivery_mode:"foreground" if background text is unavailable. This may briefly bring the verified window to the front. For browser shortcuts such as CTRL+L, use key with delivery_mode:"foreground". A stale or moved window is refused; take a fresh window screenshot. ${hostActionAvailable(caps, "screenshot") ? "Plain screenshot still shows the display. " : "screenshot requires window_id on this host. "}Browser permission bubbles outside the window may be absent. If the window image is blank or shows another window, do not click it; focus the target and capture it again.`);
+    lines.push(`When the user names an application or window, ${available.includes("list_windows") ? "use list_windows then screenshot {window_id}" : "use screenshot {window_id} with a host-provided window id"} to capture pixels for that window. Its x/y are pixels of that window image; clicks, drags, typing and keys target that window. Window pointer input uses background delivery only; if a click or drag is refused, inspect a fresh image before any other action. ${caps.windowScroll === false ? `Window pixel scrolling is unavailable on this host; for a browser page use key PAGE_DOWN or ARROW_DOWN with delivery_mode:"foreground"${hostActionAvailable(caps, "screenshot") ? ", or deliberately take a display screenshot for display scrolling" : ""}. ` : ""}To type into a browser field, first mouse_click its point in the window image, then type_text with delivery_mode:"foreground" if background text is unavailable. This may briefly bring the verified window to the front. For browser shortcuts such as CTRL+L, use key with delivery_mode:"foreground". A stale or moved window is refused; take a fresh window screenshot. ${hostActionAvailable(caps, "screenshot") ? "Plain screenshot still shows the display. " : "screenshot requires window_id on this host. "}Browser permission bubbles outside the window may be absent. If the window image is blank or shows another window, do not click it; focus the target and capture it again.`);
   if (available.includes("ui_snapshot"))
-    lines2.push(`ui_snapshot {window_id} reads a window's controls (its accessibility tree) as text, each control you can act on with a ref such as e12; without window_id it reads the window in front. ui_act {ref, action, value} acts on one control: invoke (press a button, open a menu item), set_value (replace a field's text with value), toggle, select, expand, collapse. Prefer ui_act to clicking pixels when the control is in the tree: it does not depend on coordinates or on which window is in front, and a batch of ui_act steps (for example pressing several buttons) runs in one call. Refs are valid only until the next ui_snapshot; take a new one after the window changes.`);
-  lines2.push(windowCaptureAvailable(host, caps) ? "After a display screenshot, typing and keys go to whichever window has focus: confirm on that screenshot that the right window is in front before type_text or key. After a named-window screenshot, input targets the captured window." : "Typing and keys go to whichever window has focus: confirm on a screenshot that the right window is in front before type_text or key.");
+    lines.push(`ui_snapshot {window_id} reads a window's controls (its accessibility tree) as text, each control you can act on with a ref such as e12; without window_id it reads the window in front. ui_act {ref, action, value} acts on one control: invoke (press a button, open a menu item), set_value (replace a field's text with value), toggle, select, expand, collapse. Prefer ui_act to clicking pixels when the control is in the tree: it does not depend on coordinates or on which window is in front, and a batch of ui_act steps (for example pressing several buttons) runs in one call. Refs are valid only until the next ui_snapshot; take a new one after the window changes.`);
+  lines.push(windowCaptureAvailable(host, caps) ? "After a display screenshot, typing and keys go to whichever window has focus: confirm on that screenshot that the right window is in front before type_text or key. After a named-window screenshot, input targets the captured window." : "Typing and keys go to whichever window has focus: confirm on a screenshot that the right window is in front before type_text or key.");
   if (available.includes("list_windows"))
-    lines2.push("type_text and key are refused while a terminal window is in front \u2014 usually the one running this agent, or the user\u2019s own; bring the window you mean to the front first (focus_window, or click it).");
-  return finish(lines2, caps, available);
+    lines.push("type_text and key are refused while a terminal window is in front \u2014 usually the one running this agent, or the user\u2019s own; bring the window you mean to the front first (focus_window, or click it).");
+  return finish(lines, caps, available);
 }
 __name(buildDescription, "buildDescription");
-function finish(lines2, caps, available) {
+function finish(lines, caps, available) {
   if (caps.mouseClickButtons && available.includes("mouse_click"))
-    lines2.push(`Click buttons: ${caps.mouseClickButtons.join(", ") || "none"}.`);
+    lines.push(`Click buttons: ${caps.mouseClickButtons.join(", ") || "none"}.`);
   if (caps.mouseDragButtons && available.includes("mouse_drag"))
-    lines2.push(`Drag buttons: ${caps.mouseDragButtons.join(", ") || "none"}.`);
-  return lines2.join(" ");
+    lines.push(`Drag buttons: ${caps.mouseDragButtons.join(", ") || "none"}.`);
+  return lines.join(" ");
 }
 __name(finish, "finish");
 function pointModelSchema(description) {
@@ -88986,7 +89827,7 @@ function createComputerUseTool(host, options = {}) {
     const refs = /* @__PURE__ */ new Map();
     const latest = frames.latest();
     const frame = latest?.window ? void 0 : latest;
-    const lines2 = [];
+    const lines = [];
     let chars = 0;
     let shown = 0;
     let total = 0;
@@ -89002,7 +89843,7 @@ function createComputerUseTool(host, options = {}) {
         if (chars + line.length + 1 > MAX_UI_SNAPSHOT_CHARS) {
           cut = true;
         } else {
-          lines2.push(line);
+          lines.push(line);
           chars += line.length + 1;
           shown += 1;
           if (ref) {
@@ -89029,7 +89870,7 @@ function createComputerUseTool(host, options = {}) {
       ...snapshot.app !== void 0 ? [`Application ${quotedText(snapshot.app)}`] : [],
       ...snapshot.title !== void 0 && snapshot.title !== snapshot.root.name ? [`Window title ${quotedText(snapshot.title)}`] : []
     ];
-    const body = [...about, ...lines2].join("\n");
+    const body = [...about, ...lines].join("\n");
     const footer = cut || snapshot.truncated ? [
       cut ? `The tree was cut at ${MAX_UI_SNAPSHOT_CHARS} characters after ${shown} of ${total} controls. Read a smaller window, or use a screenshot for the rest.` : "The host stopped reading the tree before it ended; controls further down are missing. Use a screenshot for the rest."
     ] : [];
@@ -89081,7 +89922,7 @@ function createComputerUseTool(host, options = {}) {
       return "no windows are open";
     const latest = frames.latest();
     const frame = latest?.window ? void 0 : latest;
-    const lines2 = windows.slice(0, MAX_LISTED_WINDOWS).map((window2) => {
+    const lines = windows.slice(0, MAX_LISTED_WINDOWS).map((window2) => {
       const where = frame ? (() => {
         const rect = window2.minimized ? null : desktopRectOnImage(frame, window2.bounds);
         return rect ? `at ${pointLabel(rect)} ${rect.width}x${rect.height} in ${frame.id}` : window2.minimized ? "minimized" : `not on the display of ${frame.id}`;
@@ -89099,7 +89940,7 @@ function createComputerUseTool(host, options = {}) {
 ${wrapUntrusted({
       kind: "desktop-windows",
       provenance: "The open windows on the user's desktop, as the host listed them. Titles are whatever each application shows, which can include text anyone wrote."
-    }, [...lines2, ...more].join("\n"))}`;
+    }, [...lines, ...more].join("\n"))}`;
   }, "listWindows");
   const describeFrame = /* @__PURE__ */ __name((frame) => {
     if (frame.window) {
@@ -89413,17 +90254,17 @@ import { isAbsolute as isAbsolute13, join as join43, relative as relative8, sep
 // ../sdk/dist/tools/posix-path.js
 function normalizeSegments(path2) {
   const out = [];
-  for (const segment of path2.split("/")) {
-    if (segment === "" || segment === ".")
+  for (const segment2 of path2.split("/")) {
+    if (segment2 === "" || segment2 === ".")
       continue;
-    if (segment === "..") {
+    if (segment2 === "..") {
       if (out.length > 0 && out[out.length - 1] !== "..")
         out.pop();
       else
         out.push("..");
       continue;
     }
-    out.push(segment);
+    out.push(segment2);
   }
   return out;
 }
@@ -89734,12 +90575,12 @@ var GrepTool = defineTool({
           unreadableFiles++;
           continue;
         }
-        const lines2 = content.split("\n");
+        const lines = content.split("\n");
         let fileMatches = 0;
         const relPath = sandbox ? `./${relativePosix(sandbox.rootDir, filePath)}` : `./${relative9(context2.workingDirectory, join44(lexicalRoot, relative9(root, filePath))).split(sep13).join("/")}`;
-        for (let i = 0; i < lines2.length; i++) {
+        for (let i = 0; i < lines.length; i++) {
           context2.abortSignal?.throwIfAborted();
-          const line = lines2[i] ?? "";
+          const line = lines[i] ?? "";
           regex.lastIndex = 0;
           if (!regex.test(line))
             continue;
@@ -89753,13 +90594,13 @@ var GrepTool = defineTool({
             continue;
           if (input.context_lines > 0) {
             const start = Math.max(0, i - input.context_lines);
-            const end = Math.min(lines2.length - 1, i + input.context_lines);
+            const end = Math.min(lines.length - 1, i + input.context_lines);
             if (results.length > 0) {
               results.push("--");
             }
             for (let j = start; j <= end; j++) {
               const prefix = j === i ? ":" : "-";
-              const text9 = lines2[j] ?? "";
+              const text9 = lines[j] ?? "";
               results.push(`${relPath}${prefix}${j + 1}${prefix}${clipLine(text9, j === i ? "matching" : "context")}`);
             }
           } else {
@@ -90298,11 +91139,11 @@ var VerifyOutputsTool = defineTool({
       failed: failed.length,
       min_bytes: minBytes
     };
-    const lines2 = results.map((r) => r.ok ? `- OK   ${r.path}${typeof r.size_bytes === "number" ? ` (${r.size_bytes}B)` : ""}` : `- FAIL ${r.path} \u2014 ${r.error ?? (r.exists ? `size ${r.size_bytes ?? 0}B < min ${minBytes}B` : "missing")}`);
+    const lines = results.map((r) => r.ok ? `- OK   ${r.path}${typeof r.size_bytes === "number" ? ` (${r.size_bytes}B)` : ""}` : `- FAIL ${r.path} \u2014 ${r.error ?? (r.exists ? `size ${r.size_bytes ?? 0}B < min ${minBytes}B` : "missing")}`);
     const header = `Verify outputs: ${passed}/${results.length} passed (min ${minBytes}B)`;
     return {
       success: failed.length === 0,
-      output: [header, "", ...lines2].join("\n"),
+      output: [header, "", ...lines].join("\n"),
       error: failed.length > 0 ? `${failed.length} of ${results.length} expected outputs failed verification` : void 0,
       data: { results, summary: summary2 }
     };
@@ -91014,13 +91855,13 @@ function renderSnapshot(snapshot, maxChars2) {
     text9 = text9.slice(0, maxChars2);
     cut = true;
   }
-  const lines2 = [formatBrowserPageHeader(snapshot.page), wrapPageText(snapshot.page, text9)];
+  const lines = [formatBrowserPageHeader(snapshot.page), wrapPageText(snapshot.page, text9)];
   if (snapshot.nextCursor !== void 0) {
-    lines2.push(`More of this page follows: call browser with action "snapshot" and cursor ${JSON.stringify(snapshot.nextCursor)}.`);
+    lines.push(`More of this page follows: call browser with action "snapshot" and cursor ${JSON.stringify(snapshot.nextCursor)}.`);
   } else if (cut) {
-    lines2.push(`The snapshot was cut at ${maxChars2} characters. Take a snapshot of one region with ref to see the rest.`);
+    lines.push(`The snapshot was cut at ${maxChars2} characters. Take a snapshot of one region with ref to see the rest.`);
   }
-  return lines2.join("\n");
+  return lines.join("\n");
 }
 __name(renderSnapshot, "renderSnapshot");
 function hostMessage(message) {
@@ -91628,13 +92469,13 @@ function defineSearchMemoryTool(search) {
         };
       }
       const now = Date.now();
-      const lines2 = result.entries.map((e, i) => {
+      const lines = result.entries.map((e, i) => {
         const kind = [e.name, e.type, describeMemoryAge(e.updatedAt, now)].filter(Boolean).join(", ");
         return `${i + 1}. [${e.id}] ${e.title} (${kind}) \u2014 ${e.description ?? e.summary}${e.tags.length > 0 ? ` [${e.tags.join(", ")}]` : ""}`;
       });
       const output = result.totalCount > result.entries.length ? `Found ${result.totalCount} memories${page} (showing ${result.entries.length}):
-${lines2.join("\n")}${continuation}` : `Found ${result.totalCount} memories${page}:
-${lines2.join("\n")}${continuation}`;
+${lines.join("\n")}${continuation}` : `Found ${result.totalCount} memories${page}:
+${lines.join("\n")}${continuation}`;
       return {
         success: true,
         output,
@@ -92058,8 +92899,8 @@ async function list(host, input) {
   }
   if (jobs.length === 0)
     return { success: true, output: "No scheduled jobs.", data: { jobs: [] } };
-  const lines2 = jobs.map((j) => `${j.name} \xB7 ${j.state} \xB7 ${j.schedule}${j.nextFireAt ? ` \xB7 next ${j.nextFireAt}` : ""}${j.lastStatus ? ` \xB7 last ${j.lastStatus}` : ""} \xB7 ${j.folder}${j.inSessionFolder ? " (this folder)" : ""}`);
-  return { success: true, output: lines2.join("\n"), data: { jobs } };
+  const lines = jobs.map((j) => `${j.name} \xB7 ${j.state} \xB7 ${j.schedule}${j.nextFireAt ? ` \xB7 next ${j.nextFireAt}` : ""}${j.lastStatus ? ` \xB7 last ${j.lastStatus}` : ""} \xB7 ${j.folder}${j.inSessionFolder ? " (this folder)" : ""}`);
+  return { success: true, output: lines.join("\n"), data: { jobs } };
 }
 __name(list, "list");
 var CHANGEABLE = [
@@ -92391,6 +93232,37 @@ function pick2(entries2) {
   return out;
 }
 __name(pick2, "pick");
+var MAX_HUNKS = 100;
+var MAX_HUNK_ROWS = 400;
+var MAX_ROW_CHARS = 600;
+function hunks(value) {
+  if (!Array.isArray(value) || value.length > MAX_HUNKS)
+    return void 0;
+  const out = [];
+  let rows = 0;
+  for (const entry of value) {
+    if (!isRecord4(entry) || !Array.isArray(entry.lines))
+      return void 0;
+    const oldStart = count6(entry.oldStart);
+    const oldLines = count6(entry.oldLines);
+    const newStart = count6(entry.newStart);
+    const newLines = count6(entry.newLines);
+    if (oldStart === void 0 || oldLines === void 0 || newStart === void 0 || newLines === void 0)
+      return void 0;
+    rows += entry.lines.length;
+    if (rows > MAX_HUNK_ROWS)
+      return void 0;
+    const lines = [];
+    for (const row of entry.lines) {
+      if (typeof row !== "string" || row.length > MAX_ROW_CHARS || !(row.startsWith(" ") || row.startsWith("+") || row.startsWith("-")))
+        return void 0;
+      lines.push(row);
+    }
+    out.push({ oldStart, oldLines, newStart, newLines, lines });
+  }
+  return out.length > 0 ? out : void 0;
+}
+__name(hunks, "hunks");
 function admitToolFacts(value) {
   if (!isRecord4(value))
     return void 0;
@@ -92449,7 +93321,11 @@ function admitToolFacts(value) {
       return pick2({
         kind: "edit",
         path: text8(value.path),
-        replacements: count6(value.replacements)
+        replacements: count6(value.replacements),
+        added: count6(value.added),
+        removed: count6(value.removed),
+        hunks: hunks(value.hunks),
+        hunksTruncated: flag(value.hunksTruncated)
       });
     case "write": {
       const path2 = text8(value.path);
@@ -92462,7 +93338,9 @@ function admitToolFacts(value) {
         operation,
         bytes: count6(value.bytes),
         added: count6(value.added),
-        removed: count6(value.removed)
+        removed: count6(value.removed),
+        hunks: hunks(value.hunks),
+        hunksTruncated: flag(value.hunksTruncated)
       });
     }
     case "failure": {
@@ -92709,6 +93587,7 @@ export {
   findPendingCheckpoint,
   isTerminalAgentTaskState,
   CompletionInbox,
+  formatCompletionNotification,
   buildAskUserQuestionTool,
   resolveTriggerThreshold,
   resolveContextWindow,
@@ -92741,6 +93620,8 @@ export {
   InMemorySessionTokenBudgetStore,
   DiskSessionCheckpointStore,
   createFileReadTracker,
+  diffWords,
+  structuredPatch,
   dryRunEdit,
   seedObservationLedger,
   toolResultInjectionGuardrail,
@@ -92822,7 +93703,6 @@ export {
   CODING_AGENT_WORKING_DOCTRINE,
   CODING_AGENT_DELEGATION_DOCTRINE,
   PLAN_MODE_DOCTRINE,
-  CODING_AGENT_HYPERMODE_DOCTRINE,
   projectResidentLearning,
   createResidentStepContributions,
   createResidentStepContext,
@@ -92902,4 +93782,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-XM3W7NMM.js.map
+//# sourceMappingURL=chunk-RQBT4RVE.js.map