@namzu/cli 38.1.0 → 38.2.0

package/dist/chunks/{chunk-2UGC7RUB.js → chunk-A64X23MU.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 {
@@ -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");
 
@@ -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:
@@ -25303,6 +25311,175 @@ function measureContent(content) {
 }
 __name(measureContent, "measureContent");
 
+// ../sdk/dist/tools/builtins/edit-match.js
+var LEFT_SINGLE_QUOTE = "\u2018";
+var RIGHT_SINGLE_QUOTE = "\u2019";
+var LEFT_DOUBLE_QUOTE = "\u201C";
+var RIGHT_DOUBLE_QUOTE = "\u201D";
+var HAS_UNICODE_ESCAPE = /\\u[0-9a-fA-F]{4}/;
+var HAS_NON_ASCII = /[\u0080-￿]/;
+function straightenQuotes(text9) {
+  return text9.replaceAll(LEFT_SINGLE_QUOTE, "'").replaceAll(RIGHT_SINGLE_QUOTE, "'").replaceAll(LEFT_DOUBLE_QUOTE, '"').replaceAll(RIGHT_DOUBLE_QUOTE, '"');
+}
+__name(straightenQuotes, "straightenQuotes");
+function decodeUnicodeEscapes(text9) {
+  return text9.replace(/(\\\\)|\\u([0-9a-fA-F]{4})/g, (whole, backslashes, hex2) => backslashes !== void 0 ? whole : String.fromCharCode(Number.parseInt(hex2, 16)));
+}
+__name(decodeUnicodeEscapes, "decodeUnicodeEscapes");
+function escapedLength(text9) {
+  let nonAscii = 0;
+  for (let i = 0; i < text9.length; i++)
+    if (text9.charCodeAt(i) >= 128)
+      nonAscii++;
+  return text9.length + 5 * nonAscii;
+}
+__name(escapedLength, "escapedLength");
+function trailingBackslashes2(text9, at) {
+  let count7 = 0;
+  while (text9[at - 1 - count7] === "\\")
+    count7++;
+  return count7;
+}
+__name(trailingBackslashes2, "trailingBackslashes");
+function escapeRegExp(text9) {
+  return text9.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function buildEscapeTolerantPattern(model) {
+  let pattern = "";
+  for (let i = 0; i < model.length; i++) {
+    const code = model.charCodeAt(i);
+    if (code >= 128) {
+      pattern += "\\\\u";
+      for (const digit of code.toString(16).padStart(4, "0"))
+        pattern += digit >= "a" ? `[${digit}${digit.toUpperCase()}]` : digit;
+    } else {
+      pattern += escapeRegExp(model[i]);
+    }
+  }
+  return pattern;
+}
+__name(buildEscapeTolerantPattern, "buildEscapeTolerantPattern");
+function findEscapedForm(model, file) {
+  if (trailingBackslashes2(model, model.length) % 2 === 1)
+    return null;
+  const sensitiveOffsets = model[0] === "\\" ? [0] : [];
+  let offset = 0;
+  for (let i = 0; i < model.length; i++) {
+    if (model.charCodeAt(i) >= 128) {
+      sensitiveOffsets.push(offset);
+      offset += 6;
+    } else {
+      offset += 1;
+    }
+  }
+  let regex;
+  try {
+    regex = new RegExp(buildEscapeTolerantPattern(model), "g");
+  } catch {
+    return null;
+  }
+  for (let match2 = regex.exec(file); match2 !== null; match2 = regex.exec(file)) {
+    const at = match2.index;
+    if (sensitiveOffsets.every((o) => trailingBackslashes2(file, at + o) % 2 === 0)) {
+      return file.indexOf(match2[0]) === at ? match2[0] : null;
+    }
+    regex.lastIndex = at + 1;
+  }
+  return null;
+}
+__name(findEscapedForm, "findEscapedForm");
+function resolveOldString(content, oldString) {
+  if (content.includes(oldString))
+    return oldString;
+  const straight = straightenQuotes(oldString);
+  const quoteIndex = straightenQuotes(content).indexOf(straight);
+  if (quoteIndex !== -1)
+    return content.substring(quoteIndex, quoteIndex + oldString.length);
+  if (HAS_UNICODE_ESCAPE.test(oldString)) {
+    const decoded = decodeUnicodeEscapes(oldString);
+    if (decoded !== oldString && content.includes(decoded))
+      return decoded;
+  }
+  if (HAS_NON_ASCII.test(oldString)) {
+    if (escapedLength(oldString) > content.length || !content.includes("\\u"))
+      return null;
+    return findEscapedForm(oldString, content);
+  }
+  return null;
+}
+__name(resolveOldString, "resolveOldString");
+function isOpeningPosition(chars, index) {
+  if (index === 0)
+    return true;
+  const before = chars[index - 1];
+  return before === " " || before === "	" || before === "\n" || before === "\r" || before === "(" || before === "[" || before === "{" || before === "\u2014" || before === "\u2013";
+}
+__name(isOpeningPosition, "isOpeningPosition");
+function curlifyDoubleQuotes(text9) {
+  const chars = [...text9];
+  return chars.map((char, index) => char === '"' ? isOpeningPosition(chars, index) ? LEFT_DOUBLE_QUOTE : RIGHT_DOUBLE_QUOTE : char).join("");
+}
+__name(curlifyDoubleQuotes, "curlifyDoubleQuotes");
+function curlifySingleQuotes(text9) {
+  const chars = [...text9];
+  return chars.map((char, index) => {
+    if (char !== "'")
+      return char;
+    const before = index > 0 ? chars[index - 1] : void 0;
+    const after = index < chars.length - 1 ? chars[index + 1] : void 0;
+    const betweenLetters = before !== void 0 && new RegExp("\\p{L}", "u").test(before) && after !== void 0 && new RegExp("\\p{L}", "u").test(after);
+    if (betweenLetters)
+      return RIGHT_SINGLE_QUOTE;
+    return isOpeningPosition(chars, index) ? LEFT_SINGLE_QUOTE : RIGHT_SINGLE_QUOTE;
+  }).join("");
+}
+__name(curlifySingleQuotes, "curlifySingleQuotes");
+function reconcileNewString(oldString, resolved2, newString) {
+  if (resolved2 === oldString)
+    return newString;
+  if (HAS_NON_ASCII.test(oldString) && escapedLength(oldString) === resolved2.length && findEscapedForm(oldString, resolved2) !== null) {
+    const perChar = /* @__PURE__ */ new Map();
+    let upper = 0;
+    let lower = 0;
+    for (let oldIndex = 0, resolvedIndex = 0; oldIndex < oldString.length; oldIndex++) {
+      const code = oldString.charCodeAt(oldIndex);
+      if (code >= 128) {
+        const hex2 = resolved2.slice(resolvedIndex + 2, resolvedIndex + 6);
+        perChar.set(code, hex2);
+        for (const digit of hex2)
+          if (digit >= "a" && digit <= "f")
+            lower++;
+          else if (digit >= "A" && digit <= "F")
+            upper++;
+        resolvedIndex += 6;
+      } else {
+        resolvedIndex += 1;
+      }
+    }
+    return newString.replace(/[\u0080-￿]/g, (char) => {
+      const code = char.charCodeAt(0);
+      const known = perChar.get(code);
+      if (known !== void 0)
+        return `\\u${known}`;
+      const hex2 = code.toString(16).padStart(4, "0");
+      return `\\u${upper > lower ? hex2.toUpperCase() : hex2}`;
+    });
+  }
+  if (HAS_UNICODE_ESCAPE.test(oldString) && decodeUnicodeEscapes(oldString) === resolved2) {
+    return decodeUnicodeEscapes(newString);
+  }
+  const hasCurlyDouble = resolved2.includes(LEFT_DOUBLE_QUOTE) || resolved2.includes(RIGHT_DOUBLE_QUOTE);
+  const hasCurlySingle = resolved2.includes(LEFT_SINGLE_QUOTE) || resolved2.includes(RIGHT_SINGLE_QUOTE);
+  let reconciled = newString;
+  if (hasCurlyDouble)
+    reconciled = curlifyDoubleQuotes(reconciled);
+  if (hasCurlySingle)
+    reconciled = curlifySingleQuotes(reconciled);
+  return reconciled;
+}
+__name(reconcileNewString, "reconcileNewString");
+
 // ../sdk/dist/tools/builtins/edit-apply.js
 function normalizeEditInput(input) {
   if (input.edits !== void 0) {
@@ -25398,23 +25575,35 @@ function applyOne(content, input) {
     return applyLineInsert(content, input);
   }
   const replacement = normalizeLineEndings(content, input);
-  if (!content.includes(replacement.oldString)) {
-    return {
-      success: false,
-      error: "old_string/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation."
-    };
+  let oldString = replacement.oldString;
+  let newString = replacement.newString;
+  if (!content.includes(oldString)) {
+    const resolved2 = resolveOldString(content, oldString);
+    if (resolved2 === null) {
+      return {
+        success: false,
+        error: "old_string/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation."
+      };
+    }
+    newString = reconcileNewString(oldString, resolved2, newString);
+    oldString = resolved2;
+  }
+  if (newString === "" && !oldString.endsWith("\n") && content.includes(`${oldString}
+`)) {
+    oldString = `${oldString}
+`;
   }
   if (replacement.replace_all) {
-    const parts = content.split(replacement.oldString);
+    const parts = content.split(oldString);
     const replacements = parts.length - 1;
     return {
       success: true,
-      content: parts.join(replacement.newString),
+      content: parts.join(newString),
       replacements
     };
   }
-  const firstIndex = content.indexOf(replacement.oldString);
-  const secondIndex = content.indexOf(replacement.oldString, firstIndex + 1);
+  const firstIndex = content.indexOf(oldString);
+  const secondIndex = content.indexOf(oldString, firstIndex + 1);
   if (secondIndex !== -1) {
     const lineNumber = content.slice(0, firstIndex).split("\n").length;
     const secondLine = content.slice(0, secondIndex).split("\n").length;
@@ -25425,22 +25614,22 @@ function applyOne(content, input) {
   }
   return {
     success: true,
-    content: content.slice(0, firstIndex) + replacement.newString + content.slice(firstIndex + replacement.oldString.length),
+    content: content.slice(0, firstIndex) + newString + content.slice(firstIndex + oldString.length),
     replacements: 1
   };
 }
 __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
   };
 }
@@ -25617,6 +25806,478 @@ 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/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."),
@@ -25813,6 +26474,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.',
@@ -25918,19 +26595,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;
@@ -25943,15 +26617,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
       };
     });
   }
@@ -25987,13 +26658,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;
@@ -26030,15 +26701,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");
@@ -26100,9 +26771,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) {
@@ -26124,7 +26795,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");
@@ -26170,8 +26841,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");
 
@@ -26388,33 +27059,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`,
@@ -26423,7 +27080,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,
@@ -26433,15 +27095,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 }
       }
     }
   };
@@ -26911,24 +27571,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");
@@ -29291,51 +29951,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) {
@@ -30687,24 +31347,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);
@@ -30731,6 +31390,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({
@@ -31180,7 +31841,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}]`;
       });
@@ -31188,7 +31849,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: {
@@ -33774,7 +34435,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}`,
@@ -33795,7 +34456,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.`;
@@ -34685,7 +35346,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, "");
@@ -34713,7 +35374,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)
@@ -34726,7 +35387,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");
@@ -34864,10 +35525,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];
@@ -36228,6 +36889,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))
@@ -45971,35 +46640,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) {
@@ -46017,18 +46686,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 {
@@ -46943,11 +47612,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++;
@@ -46971,14 +47640,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;
     }
@@ -53433,7 +54102,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)
@@ -55406,13 +56075,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;
     }
@@ -55430,7 +56099,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);
@@ -55464,7 +56133,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 };
 }
@@ -55482,9 +56151,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);
@@ -55493,7 +56162,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);
@@ -55502,9 +56171,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");
 
@@ -59874,9 +60543,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;
@@ -60625,11 +61294,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();
@@ -61072,7 +61741,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.5.0";
+var VERSION2 = "52.7.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -62662,18 +63331,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) {
@@ -63957,7 +64626,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
@@ -63969,41 +64638,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");
 
@@ -68798,8 +69467,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}
@@ -69507,7 +70176,12 @@ 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(); }));
+		return Promise.all(thunks.map(function (t, n) {
+			return Promise.resolve().then(t).catch(function (e) {
+				log('parallel item ' + (n + 1) + ' failed: ' + clean(e && e.message ? e.message : e, 300));
+				return null;
+			});
+		}));
 	}
 	async function pipeline(items) {
 		if (!Array.isArray(items)) {
@@ -69522,7 +70196,12 @@ var PRELUDE_SOURCE = String.raw`(function (config) {
 		return 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, index, item);
+				} catch (e) {
+					log('pipeline item ' + (index + 1) + ' stopped at stage ' + (i + 1) + ': ' + clean(e && e.message ? e.message : e, 300));
+					return null;
+				}
 				if (value === null || value === undefined) return null;
 			}
 			return value;
@@ -77941,11 +78620,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 "))
@@ -86089,17 +86768,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": {
@@ -86134,13 +86813,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": {
@@ -86264,8 +86943,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) {
@@ -86283,21 +86962,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) {
@@ -86323,18 +87002,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,
@@ -86901,15 +87580,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");
 
@@ -88199,38 +88878,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) {
@@ -88805,7 +89484,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;
@@ -88821,7 +89500,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) {
@@ -88848,7 +89527,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."
     ] : [];
@@ -88900,7 +89579,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}`;
@@ -88918,7 +89597,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) {
@@ -89553,12 +90232,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;
@@ -89572,13 +90251,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 {
@@ -90117,11 +90796,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 }
     };
@@ -90833,13 +91512,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) {
@@ -91447,13 +92126,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,
@@ -91877,8 +92556,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 = [
@@ -92210,6 +92889,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;
@@ -92268,7 +92978,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);
@@ -92281,7 +92995,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": {
@@ -92721,4 +93437,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-2UGC7RUB.js.map
+//# sourceMappingURL=chunk-A64X23MU.js.map