@cydm/pie 1.0.17 → 1.0.19

package/dist/chunks/{chunk-B4VUX6SD.js → chunk-GZVSE44O.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   Agent
-} from "./chunk-VE2HDCNB.js";
+} from "./chunk-2R3XTLE2.js";
 import {
   FileSystemGateway,
   Type,
@@ -9,8 +9,9 @@ import {
   detectPlatform,
   getFileSystem,
   getPlatformConfig,
+  hashText,
   streamSimple
-} from "./chunk-5DA2D3K2.js";
+} from "./chunk-Q2N6B5JN.js";
 import {
   __require
 } from "./chunk-TG2EQLX2.js";
@@ -1995,7 +1996,7 @@ function isTransientFileError(error) {
   return /^(EPERM|EACCES|EBUSY|ENOTEMPTY)$/.test(code) || /\b(EPERM|EACCES|EBUSY|locked|busy)\b/i.test(message);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function retryFileOperation(operation, retryDelaysMs) {
   let lastError;
@@ -3038,15 +3039,15 @@ var AgentSessionAutoCompactScheduler = class {
   }
   ensurePendingWait() {
     if (this.pendingWait) return;
-    this.pendingWait = new Promise((resolve2) => {
-      this.resolvePendingWait = resolve2;
+    this.pendingWait = new Promise((resolve3) => {
+      this.resolvePendingWait = resolve3;
     });
   }
   resolvePending() {
-    const resolve2 = this.resolvePendingWait;
+    const resolve3 = this.resolvePendingWait;
     this.pendingWait = void 0;
     this.resolvePendingWait = void 0;
-    resolve2?.();
+    resolve3?.();
   }
 };
 
@@ -3124,29 +3125,29 @@ var AgentSessionAutoContinueController = class {
     this.options.emit({ type: "auto_continue_scheduled", reason });
     this.options.agent.followUp(message);
     const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout2;
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       this.autoContinueTimer = setTimer(() => {
         this.autoContinueTimer = void 0;
         if (this.options.getDisposed()) {
-          resolve2();
+          resolve3();
           return;
         }
         void this.options.continueTurn().catch(() => {
-        }).finally(resolve2);
+        }).finally(resolve3);
       }, 0);
     });
   }
   ensurePending() {
     if (this.pendingAutoContinue) return;
-    this.pendingAutoContinue = new Promise((resolve2) => {
-      this.resolvePendingAutoContinue = resolve2;
+    this.pendingAutoContinue = new Promise((resolve3) => {
+      this.resolvePendingAutoContinue = resolve3;
     });
   }
   resolvePending() {
-    const resolve2 = this.resolvePendingAutoContinue;
+    const resolve3 = this.resolvePendingAutoContinue;
     this.pendingAutoContinue = void 0;
     this.resolvePendingAutoContinue = void 0;
-    resolve2?.();
+    resolve3?.();
   }
 };
 
@@ -3555,15 +3556,15 @@ var AgentSessionQueueDispatcher = class {
   }
   ensurePending() {
     if (this.pendingDispatch) return;
-    this.pendingDispatch = new Promise((resolve2) => {
-      this.resolvePendingDispatch = resolve2;
+    this.pendingDispatch = new Promise((resolve3) => {
+      this.resolvePendingDispatch = resolve3;
     });
   }
   resolvePending() {
-    const resolve2 = this.resolvePendingDispatch;
+    const resolve3 = this.resolvePendingDispatch;
     this.pendingDispatch = void 0;
     this.resolvePendingDispatch = void 0;
-    resolve2?.();
+    resolve3?.();
   }
 };
 
@@ -3717,15 +3718,15 @@ var AgentSessionRetryController = class {
     if (this.pendingRetry) {
       return;
     }
-    this.pendingRetry = new Promise((resolve2) => {
-      this.resolvePendingRetry = resolve2;
+    this.pendingRetry = new Promise((resolve3) => {
+      this.resolvePendingRetry = resolve3;
     });
   }
   resolvePending() {
-    const resolve2 = this.resolvePendingRetry;
+    const resolve3 = this.resolvePendingRetry;
     this.pendingRetry = void 0;
     this.resolvePendingRetry = void 0;
-    resolve2?.();
+    resolve3?.();
   }
 };
 
@@ -5443,9 +5444,98 @@ function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
   return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
 }
 
+// ../../packages/shared-headless-capabilities/src/builtin/fs/file-observation-state.ts
+function snapshotsEqual(left, right) {
+  return left.mtimeMs === right.mtimeMs && left.size === right.size && left.contentHash === right.contentHash;
+}
+function snapshotsHaveSameContent(left, right) {
+  return left.size === right.size && left.contentHash === right.contentHash;
+}
+function snapshotFromStatAndContent(stat, content) {
+  return {
+    mtimeMs: stat.mtime.getTime(),
+    size: stat.size,
+    contentHash: hashText(content)
+  };
+}
+function createFileObservationState(options = {}) {
+  const files = /* @__PURE__ */ new Map();
+  const maxFiles = Math.max(1, Math.floor(options.maxFiles ?? 100));
+  const maxRangesPerFile = Math.max(0, Math.floor(options.maxRangesPerFile ?? 8));
+  function touchFile(absolutePath, observed) {
+    files.delete(absolutePath);
+    files.set(absolutePath, observed);
+    while (files.size > maxFiles) {
+      const oldest = files.keys().next().value;
+      if (oldest === void 0) break;
+      files.delete(oldest);
+    }
+  }
+  function touchRange(readRanges, rangeKey, range) {
+    if (maxRangesPerFile === 0) {
+      readRanges.clear();
+      return;
+    }
+    readRanges.delete(rangeKey);
+    readRanges.set(rangeKey, range);
+    while (readRanges.size > maxRangesPerFile) {
+      const oldest = readRanges.keys().next().value;
+      if (oldest === void 0) break;
+      readRanges.delete(oldest);
+    }
+  }
+  return {
+    isUnchangedReadRange(absolutePath, rangeKey, snapshot, selectedContentHash) {
+      const observed = files.get(absolutePath);
+      const range = observed?.readRanges.get(rangeKey);
+      if (!observed || !range) {
+        return false;
+      }
+      const unchanged = snapshotsEqual(range.snapshot, snapshot) && range.selectedContentHash === selectedContentHash;
+      touchRange(observed.readRanges, rangeKey, range);
+      touchFile(absolutePath, observed);
+      return unchanged;
+    },
+    recordTextRead(absolutePath, rangeKey, snapshot, selectedContentHash, completeTextKnown) {
+      const observed = files.get(absolutePath) ?? {
+        snapshot,
+        completeTextKnown: false,
+        readRanges: /* @__PURE__ */ new Map()
+      };
+      const preservesFreshCompleteRead = observed.completeTextKnown && snapshotsHaveSameContent(observed.snapshot, snapshot);
+      observed.snapshot = snapshot;
+      observed.completeTextKnown = completeTextKnown || preservesFreshCompleteRead;
+      touchRange(observed.readRanges, rangeKey, { snapshot, selectedContentHash });
+      touchFile(absolutePath, observed);
+    },
+    getCompleteTextSnapshot(absolutePath) {
+      const observed = files.get(absolutePath);
+      if (!observed?.completeTextKnown) {
+        return void 0;
+      }
+      touchFile(absolutePath, observed);
+      return observed.snapshot;
+    },
+    recordCompleteTextWrite(absolutePath, snapshot) {
+      touchFile(absolutePath, {
+        snapshot,
+        completeTextKnown: true,
+        readRanges: /* @__PURE__ */ new Map()
+      });
+    },
+    invalidate(absolutePath) {
+      files.delete(absolutePath);
+    },
+    clear() {
+      files.clear();
+    }
+  };
+}
+
 // ../../packages/shared-headless-capabilities/src/builtin/fs/read.ts
 function createReadTool(cwd, options) {
   const fs2 = getFileSystem();
+  const fileObservationState = options?.fileObservationState ?? createFileObservationState();
   const rootSchema = buildRootParameterSchema(cwd, options);
   const readSchema = Type.Object({
     path: Type.String({ description: "Path to the file to read. Example: 'Scripts/PlayerController.cs' or 'Assets/Gen/config.json'." }),
@@ -5464,7 +5554,7 @@ function createReadTool(cwd, options) {
       const { path: path3, root, offset, limit, question } = params;
       const absolutePath = resolveReadPath(path3, cwd, options, root);
       return new Promise(
-        (resolve2, reject) => {
+        (resolve3, reject) => {
           if (signal?.aborted) {
             reject(new Error("Operation aborted"));
             return;
@@ -5480,11 +5570,18 @@ function createReadTool(cwd, options) {
           (async () => {
             try {
               await fs2.access(absolutePath);
+              if (isSpecialDevicePath(absolutePath)) {
+                throw new Error(`Refusing to read special device path: ${absolutePath}`);
+              }
+              const stat = await fs2.stat(absolutePath);
+              if (!stat.isFile) {
+                throw new Error(`Refusing to read non-regular file: ${absolutePath}`);
+              }
               if (aborted) return;
               const imageInfo = await readImageInfo(absolutePath, fs2);
               if (imageInfo) {
                 if (question && options?.understandFile) {
-                  resolve2(await options.understandFile({
+                  resolve3(await options.understandFile({
                     absolutePath,
                     displayPath: path3,
                     mimeType: imageInfo.mimeType,
@@ -5496,7 +5593,7 @@ function createReadTool(cwd, options) {
                   return;
                 }
                 const dimensionText = imageInfo.width && imageInfo.height ? `, ${imageInfo.width}x${imageInfo.height}` : "";
-                resolve2({
+                resolve3({
                   content: [
                     { type: "text", text: `Read image file [${imageInfo.mimeType}${dimensionText}]. Original image attached as an image block; for very large images, prefer a smaller crop or resized copy before rereading.` },
                     { type: "image", data: imageInfo.base64, mimeType: imageInfo.mimeType }
@@ -5513,7 +5610,7 @@ function createReadTool(cwd, options) {
               }
               const mediaInfo = detectUnderstandingKind(absolutePath);
               if (mediaInfo && options?.understandFile) {
-                resolve2(await options.understandFile({
+                resolve3(await options.understandFile({
                   absolutePath,
                   displayPath: path3,
                   mimeType: mediaInfo.mimeType,
@@ -5524,7 +5621,7 @@ function createReadTool(cwd, options) {
                 return;
               }
               if (mediaInfo) {
-                resolve2({
+                resolve3({
                   content: [{
                     type: "text",
                     text: `Cannot read ${mediaInfo.kind} file ${path3} semantically: no media understanding handler is configured for ${mediaInfo.mimeType}.`
@@ -5540,24 +5637,62 @@ function createReadTool(cwd, options) {
                 });
                 return;
               }
-              const content = String(await fs2.readFile(absolutePath, "utf-8"));
-              const allLines = content.split("\n");
-              const totalFileLines = allLines.length;
               const startLine = offset ? Math.max(0, offset - 1) : 0;
               const startLineDisplay = startLine + 1;
-              if (startLine >= allLines.length) {
-                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+              const range = await fs2.readTextRange(absolutePath, {
+                offsetLine: startLine,
+                limitLines: limit,
+                maxOutputLines: DEFAULT_MAX_LINES,
+                maxOutputBytes: DEFAULT_MAX_BYTES
+              }, signal);
+              const snapshot = {
+                mtimeMs: range.mtimeMs,
+                size: range.size,
+                contentHash: range.contentHash
+              };
+              const totalFileLines = range.totalLines;
+              if (startLine >= range.totalLines) {
+                throw new Error(`Offset ${offset} is beyond end of file (${range.totalLines} lines total)`);
               }
-              let selectedContent;
               let userLimitedLines;
               if (limit !== void 0) {
-                const endLine = Math.min(startLine + limit, allLines.length);
-                selectedContent = allLines.slice(startLine, endLine).join("\n");
-                userLimitedLines = endLine - startLine;
-              } else {
-                selectedContent = allLines.slice(startLine).join("\n");
+                userLimitedLines = range.selectedLines;
+              }
+              const rangeKey = `${startLineDisplay}:${limit === void 0 ? "all" : limit}`;
+              const truncation = {
+                content: range.content,
+                truncated: range.truncated,
+                truncatedBy: range.truncatedBy,
+                totalLines: range.selectedLines,
+                totalBytes: range.selectedBytes,
+                outputLines: range.outputLines,
+                outputBytes: range.outputBytes,
+                lastLinePartial: false,
+                firstLineExceedsLimit: range.firstLineExceedsLimit,
+                maxLines: DEFAULT_MAX_LINES,
+                maxBytes: DEFAULT_MAX_BYTES
+              };
+              const readStartsAtBeginning = offset === void 0 || offset === 1;
+              const readReachedEndOfFile = startLine + range.selectedLines >= range.totalLines;
+              const isCompleteTextKnown = readStartsAtBeginning && readReachedEndOfFile && !truncation.truncated && !truncation.firstLineExceedsLimit;
+              if (fileObservationState.isUnchangedReadRange(absolutePath, rangeKey, snapshot, range.selectedContentHash)) {
+                if (signal) {
+                  signal.removeEventListener("abort", onAbort);
+                }
+                resolve3({
+                  content: [{
+                    type: "text",
+                    text: "File unchanged since previous read of this range. Use a different offset/limit if you need another section."
+                  }],
+                  details: {
+                    unchangedSincePreviousRead: true,
+                    path: absolutePath,
+                    offset: startLineDisplay,
+                    limit
+                  }
+                });
+                return;
               }
-              const truncation = truncateHead(selectedContent);
               let outputText;
               let details;
               const sourceHeader = `File: ${absolutePath}
@@ -5565,7 +5700,7 @@ Base directory: ${nodePath.dirname(absolutePath)}
 
 `;
               if (truncation.firstLineExceedsLimit) {
-                const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+                const firstLineSize = formatSize(range.firstLineBytes);
                 outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit.]`;
                 details = { truncation };
               } else if (truncation.truncated) {
@@ -5582,8 +5717,8 @@ Base directory: ${nodePath.dirname(absolutePath)}
 [Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
                 }
                 details = { truncation };
-              } else if (userLimitedLines !== void 0 && startLine + userLimitedLines < allLines.length) {
-                const remaining = allLines.length - (startLine + userLimitedLines);
+              } else if (userLimitedLines !== void 0 && startLine + userLimitedLines < range.totalLines) {
+                const remaining = range.totalLines - (startLine + userLimitedLines);
                 const nextOffset = startLine + userLimitedLines + 1;
                 outputText = truncation.content;
                 outputText += `
@@ -5592,13 +5727,20 @@ Base directory: ${nodePath.dirname(absolutePath)}
               } else {
                 outputText = truncation.content;
               }
+              fileObservationState.recordTextRead(
+                absolutePath,
+                rangeKey,
+                snapshot,
+                range.selectedContentHash,
+                isCompleteTextKnown
+              );
               outputText = sourceHeader + outputText;
               const textContent = [{ type: "text", text: outputText }];
               if (aborted) return;
               if (signal) {
                 signal.removeEventListener("abort", onAbort);
               }
-              resolve2({ content: textContent, details });
+              resolve3({ content: textContent, details });
             } catch (error) {
               if (signal) {
                 signal.removeEventListener("abort", onAbort);
@@ -5613,6 +5755,10 @@ Base directory: ${nodePath.dirname(absolutePath)}
     }
   };
 }
+function isSpecialDevicePath(path3) {
+  const normalized = nodePath.resolve(path3).replace(/\\/g, "/");
+  return /^\/dev\/(?:zero|random|urandom|full|stdin|stdout|stderr|tty|console)$/.test(normalized) || /^\/dev\/fd\/[0-2]$/.test(normalized) || /^\/proc\/(?:self|\d+)\/fd\/[0-2]$/.test(normalized);
+}
 function detectUnderstandingKind(filePath) {
   const lower = filePath.toLowerCase();
   if (/\.(mp4|mov|m4v|webm|avi|mkv)$/.test(lower)) {
@@ -5734,6 +5880,8 @@ function parseWebpDimensions(bytes) {
 // ../../packages/shared-headless-capabilities/src/builtin/fs/write.ts
 function createWriteTool(cwd, options) {
   const fs2 = getFileSystem();
+  const usesExternalFileObservationState = !!options?.fileObservationState;
+  const fileObservationState = options?.fileObservationState ?? createFileObservationState();
   const rootSchema = buildRootParameterSchema(cwd, options);
   const writeSchema = Type.Object({
     path: Type.String({ description: "Path to the file to write." }),
@@ -5744,14 +5892,14 @@ function createWriteTool(cwd, options) {
   return {
     name: "write",
     label: "write",
-    description: `Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories. ${pathResolutionDescription}`,
+    description: `Write complete file contents. Use this to create a new file, or to intentionally replace an entire existing file after reading the latest full file with read_file. Do not use for targeted edits to existing files; use edit_file instead. For existing files, omitted content will be deleted. Automatically creates parent directories. ${pathResolutionDescription}`,
     parameters: writeSchema,
     execute: async (_toolCallId, params, signal) => {
       const { path: filePath, root, content } = params;
       const absolutePath = resolveToCwd(filePath, cwd, options, root);
       const dir = fs2.dirname(absolutePath);
       return new Promise(
-        (resolve2, reject) => {
+        (resolve3, reject) => {
           if (signal?.aborted) {
             reject(new Error("Operation aborted"));
             return;
@@ -5768,12 +5916,38 @@ function createWriteTool(cwd, options) {
             try {
               await fs2.mkdir(dir, { recursive: true });
               if (aborted) return;
+              let fileExists = false;
+              try {
+                const stat = await fs2.stat(absolutePath);
+                fileExists = stat.isFile;
+              } catch {
+                fileExists = false;
+              }
+              if (fileExists) {
+                const currentContent = String(await fs2.readFile(absolutePath, "utf-8"));
+                const currentStat = await fs2.stat(absolutePath);
+                const currentSnapshot = snapshotFromStatAndContent(currentStat, currentContent);
+                const observedSnapshot = fileObservationState.getCompleteTextSnapshot(absolutePath);
+                if (!observedSnapshot) {
+                  throw new Error(
+                    usesExternalFileObservationState ? "Read the current full file with read_file before overwriting it, or use edit_file for targeted changes." : "Existing-file overwrite requires write_file to share a fileObservationState with read_file; use createSharedFileSystemTools or pass the same fileObservationState to both tools."
+                  );
+                }
+                if (!snapshotsHaveSameContent(observedSnapshot, currentSnapshot)) {
+                  throw new Error("File changed since it was read. Read the latest file contents before overwriting it.");
+                }
+              }
               await fs2.writeFile(absolutePath, content, "utf-8");
+              const writtenStat = await fs2.stat(absolutePath);
+              fileObservationState.recordCompleteTextWrite(
+                absolutePath,
+                snapshotFromStatAndContent(writtenStat, content)
+              );
               if (aborted) return;
               if (signal) {
                 signal.removeEventListener("abort", onAbort);
               }
-              resolve2({
+              resolve3({
                 content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${filePath}` }],
                 details: void 0
               });
@@ -5839,28 +6013,30 @@ function buildFuzzyIndexMap(text) {
   }
   return { normalized, originalStartByNormalizedIndex, originalEndByNormalizedIndex };
 }
-function countOccurrences(content, needle) {
-  if (needle.length === 0) return 0;
-  let count = 0;
+function collectMatches(content, needle) {
+  if (needle.length === 0) return [];
+  const matches = [];
   let index = 0;
   while (true) {
     const nextIndex = content.indexOf(needle, index);
     if (nextIndex === -1) break;
-    count++;
+    matches.push({ index: nextIndex, matchLength: needle.length });
     index = nextIndex + needle.length;
   }
-  return count;
+  return matches;
 }
 function fuzzyFindText(content, oldText) {
   const exactIndex = content.indexOf(oldText);
   if (exactIndex !== -1) {
+    const matches2 = collectMatches(content, oldText);
     return {
       found: true,
       index: exactIndex,
       matchLength: oldText.length,
       usedFuzzyMatch: false,
       contentForReplacement: content,
-      occurrences: countOccurrences(content, oldText),
+      occurrences: matches2.length,
+      matches: matches2,
       matchKind: "exact"
     };
   }
@@ -5875,6 +6051,7 @@ function fuzzyFindText(content, oldText) {
       usedFuzzyMatch: false,
       contentForReplacement: content,
       occurrences: 0,
+      matches: [],
       matchKind: "none"
     };
   }
@@ -5887,19 +6064,26 @@ function fuzzyFindText(content, oldText) {
       usedFuzzyMatch: false,
       contentForReplacement: content,
       occurrences: 0,
+      matches: [],
       matchKind: "none"
     };
   }
-  const endFuzzyIndex = fuzzyIndex + fuzzyOldText.length - 1;
-  const originalStart = fuzzyMap.originalStartByNormalizedIndex[fuzzyIndex];
-  const originalEnd = fuzzyMap.originalEndByNormalizedIndex[endFuzzyIndex];
+  const fuzzyMatches = collectMatches(fuzzyContent, fuzzyOldText);
+  const matches = fuzzyMatches.map((match) => {
+    const endFuzzyIndex = match.index + match.matchLength - 1;
+    const originalStart = fuzzyMap.originalStartByNormalizedIndex[match.index] ?? match.index;
+    const originalEnd = fuzzyMap.originalEndByNormalizedIndex[endFuzzyIndex] ?? originalStart + match.matchLength;
+    return { index: originalStart, matchLength: originalEnd - originalStart };
+  });
+  const firstMatch = matches[0] ?? { index: -1, matchLength: 0 };
   return {
     found: true,
-    index: originalStart,
-    matchLength: originalEnd - originalStart,
+    index: firstMatch.index,
+    matchLength: firstMatch.matchLength,
     usedFuzzyMatch: true,
     contentForReplacement: content,
-    occurrences: countOccurrences(fuzzyContent, fuzzyOldText),
+    occurrences: matches.length,
+    matches,
     matchKind: "fuzzy"
   };
 }
@@ -5947,7 +6131,7 @@ function generateDiffString(oldContent, newContent, contextLines = 4) {
 }
 
 // ../../packages/shared-headless-capabilities/src/builtin/fs/edit.ts
-function validateEditArgs(path3, oldText, newText) {
+function validateEditArgs(path3, oldText, newText, replaceAll) {
   const filePath = typeof path3 === "string" ? path3.trim() : "";
   if (!filePath) {
     throw new Error("Invalid edit_file arguments: path cannot be empty. Pass the file path in path and the exact text to replace in oldText.");
@@ -5961,11 +6145,14 @@ function validateEditArgs(path3, oldText, newText) {
   if (oldText === newText) {
     throw new Error("Invalid edit_file arguments: oldText and newText are identical, so the edit would make no change.");
   }
+  if (replaceAll !== void 0 && typeof replaceAll !== "boolean") {
+    throw new Error("Invalid edit_file arguments: replaceAll must be a boolean when provided.");
+  }
   if (filePath.includes("<|tool") || oldText.includes("<|tool") || newText.includes("<|tool")) {
     throw new Error("Invalid edit_file arguments: path, oldText, and newText must be real edit values, not tool-call markup.");
   }
 }
-function countOccurrences2(content, needle) {
+function countOccurrences(content, needle) {
   if (needle.length === 0) return 0;
   let count = 0;
   let index = 0;
@@ -5992,6 +6179,8 @@ function createEditErrorResult(params) {
       diff: "",
       oldTextOccurrences: params.oldTextOccurrences,
       newTextOccurrences: params.newTextOccurrences,
+      replaceAll: params.replaceAll,
+      replacedOccurrences: 0,
       errorReason: params.errorReason,
       recoveryHint: params.recoveryHint,
       staleBaseLikely: params.staleBaseLikely,
@@ -6002,12 +6191,14 @@ function createEditErrorResult(params) {
 }
 function createEditTool(cwd, options) {
   const fs2 = getFileSystem();
+  const fileObservationState = options?.fileObservationState ?? createFileObservationState();
   const rootSchema = buildRootParameterSchema(cwd, options);
   const editSchema = Type.Object({
     path: Type.String({ description: "Path to the file to edit." }),
     ...rootSchema ? { root: rootSchema } : {},
     oldText: Type.String({ description: "Exact text to find and replace (must match exactly)" }),
-    newText: Type.String({ description: "New text to replace the old text with" })
+    newText: Type.String({ description: "New text to replace the old text with" }),
+    replaceAll: Type.Optional(Type.Boolean({ description: "Replace every occurrence of oldText. Only set this to true when every matching occurrence should be replaced." }))
   });
   const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
   return {
@@ -6016,10 +6207,11 @@ function createEditTool(cwd, options) {
     description: `Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits. ${pathResolutionDescription}`,
     parameters: editSchema,
     execute: async (_toolCallId, params, signal) => {
-      const { path: path3, root, oldText, newText } = params;
-      validateEditArgs(path3, oldText, newText);
+      const { path: path3, root, oldText, newText, replaceAll } = params;
+      validateEditArgs(path3, oldText, newText, replaceAll);
+      const shouldReplaceAll = replaceAll === true;
       const absolutePath = resolveToCwd(path3, cwd, options, root);
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -6049,50 +6241,57 @@ function createEditTool(cwd, options) {
             const normalizedContent = normalizeToLF(content);
             const normalizedOldText = normalizeToLF(oldText);
             const normalizedNewText = normalizeToLF(newText);
-            const newTextOccurrences = countOccurrences2(normalizedContent, normalizedNewText);
+            const newTextOccurrences = countOccurrences(normalizedContent, normalizedNewText);
             const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
             if (!matchResult.found) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              resolve2(
+              resolve3(
                 createEditErrorResult({
                   message: `Could not find oldText in ${path3}.`,
                   matchKind: "none",
                   errorReason: "old_text_not_found",
                   oldTextOccurrences: 0,
                   newTextOccurrences,
+                  replaceAll: shouldReplaceAll,
                   staleBaseLikely: newTextOccurrences > 0,
                   alreadyAppliedCandidate: newTextOccurrences > 0,
-                  recoveryHint: newTextOccurrences > 0 ? "The replacement text already appears in the current file. Read the current file before retrying; this may be a stale oldText from an earlier edit in the same turn." : "Read the current file and retry with a larger exact block copied from the latest file contents."
+                  recoveryHint: newTextOccurrences > 0 ? "The replacement text already appears in the current file. Read the current file before retrying; this may be a stale oldText from an earlier edit in the same turn." : "Read the current file and retry with exact text copied from the latest file contents."
                 })
               );
               return;
             }
-            if (matchResult.occurrences > 1) {
+            if (matchResult.occurrences > 1 && !shouldReplaceAll) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              resolve2(
+              resolve3(
                 createEditErrorResult({
                   message: `Found ${matchResult.occurrences} occurrences of oldText in ${path3}. The text must be unique.`,
                   matchKind: matchResult.matchKind,
                   errorReason: "old_text_not_unique",
                   oldTextOccurrences: matchResult.occurrences,
                   newTextOccurrences,
-                  recoveryHint: "Read the current file and retry with a larger exact block that uniquely identifies the intended location."
+                  replaceAll: shouldReplaceAll,
+                  recoveryHint: "Read the current file and retry with a larger exact block copied from the latest file contents, or set replaceAll to true if every occurrence should be replaced."
                 })
               );
               return;
             }
             if (aborted) return;
-            const baseContent = normalizedContent;
-            const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
+            const baseContent = matchResult.contentForReplacement;
+            const matchesToReplace = shouldReplaceAll ? matchResult.matches : matchResult.matches.slice(0, 1);
+            let newContent = baseContent;
+            for (const match of [...matchesToReplace].sort((left, right) => right.index - left.index)) {
+              newContent = newContent.substring(0, match.index) + normalizedNewText + newContent.substring(match.index + match.matchLength);
+            }
             if (baseContent === newContent) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              resolve2(
+              resolve3(
                 createEditErrorResult({
                   message: `No changes made to ${path3}. The replacement produced identical content.`,
                   matchKind: matchResult.matchKind,
                   errorReason: "replacement_no_change",
                   oldTextOccurrences: matchResult.occurrences,
                   newTextOccurrences,
+                  replaceAll: shouldReplaceAll,
                   recoveryHint: "Read the current file and verify whether the intended edit is already present or whether oldText/newText need a larger exact block.",
                   alreadyAppliedCandidate: newTextOccurrences > 0
                 })
@@ -6101,16 +6300,17 @@ function createEditTool(cwd, options) {
             }
             const finalContent = bom + restoreLineEndings(newContent, originalEnding);
             await fs2.writeFile(absolutePath, finalContent, "utf-8");
+            fileObservationState.invalidate(absolutePath);
             if (aborted) return;
             if (signal) {
               signal.removeEventListener("abort", onAbort);
             }
             const diffResult = generateDiffString(content, restoreLineEndings(newContent, originalEnding));
-            resolve2({
+            resolve3({
               content: [
                 {
                   type: "text",
-                  text: `Successfully replaced text in ${path3} using ${matchResult.matchKind} match.`
+                  text: `Successfully replaced text in ${path3} using ${matchResult.matchKind} match (${matchesToReplace.length} occurrence${matchesToReplace.length === 1 ? "" : "s"}).`
                 },
                 { type: "text", text: diffResult.diff }
               ],
@@ -6121,7 +6321,9 @@ function createEditTool(cwd, options) {
                 diff: diffResult.diff,
                 firstChangedLine: diffResult.firstChangedLine,
                 oldTextOccurrences: matchResult.occurrences,
-                newTextOccurrences
+                newTextOccurrences,
+                replaceAll: shouldReplaceAll,
+                replacedOccurrences: matchesToReplace.length
               }
             });
           } catch (error) {
@@ -6155,7 +6357,7 @@ function createLsTool(cwd, options) {
     description: `List directory contents. Use this to inspect folders before reading or writing files. Example: list_dir path='Scripts' or list_dir path='Data'. ${pathResolutionDescription} Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
     parameters: lsSchema,
     execute: async (_toolCallId, params, signal) => {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -6205,7 +6407,7 @@ function createLsTool(cwd, options) {
             }
             signal?.removeEventListener("abort", onAbort);
             if (results.length === 0) {
-              resolve2({ content: [{ type: "text", text: "(empty directory)" }], details: void 0 });
+              resolve3({ content: [{ type: "text", text: "(empty directory)" }], details: void 0 });
               return;
             }
             const rawOutput = results.join("\n");
@@ -6226,7 +6428,7 @@ function createLsTool(cwd, options) {
 
 [${notices.join(". ")}]`;
             }
-            resolve2({
+            resolve3({
               content: [{ type: "text", text: output }],
               details: Object.keys(details).length > 0 ? details : void 0
             });
@@ -6402,11 +6604,11 @@ function waitForFileCompletion(requestId) {
   if (existing) {
     return Promise.resolve(existing);
   }
-  return new Promise((resolve2) => {
-    store.waiters.set(requestId, resolve2);
+  return new Promise((resolve3) => {
+    store.waiters.set(requestId, resolve3);
   });
 }
-async function runNativeGrep(searchPath, pattern, globPattern, ignoreCase, literal, contextLines, limit, signal) {
+async function runNativeGrep(searchPath, pattern, globPattern, ignoreCase, literal, contextLines, limit, outputMode, offset, signal) {
   const bridge = getNativeFileBridge();
   if (!bridge) {
     throw new Error("CS.Pie.PieFileBridge not available");
@@ -6418,7 +6620,9 @@ async function runNativeGrep(searchPath, pattern, globPattern, ignoreCase, liter
     !!ignoreCase,
     !!literal,
     contextLines,
-    limit
+    limit,
+    outputMode,
+    offset
   );
   const onAbort = () => bridge.CancelRequest(requestId);
   signal?.addEventListener("abort", onAbort, { once: true });
@@ -6443,6 +6647,45 @@ async function runNativeGrep(searchPath, pattern, globPattern, ignoreCase, liter
     bridge.ReleaseRequest(requestId);
   }
 }
+function normalizeOutputMode(value) {
+  if (value === void 0 || value === null || value === "content") return "content";
+  if (value === "files_with_matches" || value === "count") return value;
+  throw new Error("Invalid grep_text arguments: outputMode must be one of content, files_with_matches, or count.");
+}
+function normalizeNonNegativeInteger(value, fallback, name) {
+  if (value === void 0 || value === null) return fallback;
+  const numberValue = Number(value);
+  if (!Number.isInteger(numberValue) || numberValue < 0) {
+    throw new Error(`Invalid grep_text arguments: ${name} must be a non-negative integer.`);
+  }
+  return numberValue;
+}
+function formatContentMatches(matches, contextLines) {
+  const outputLines = [];
+  let linesTruncated = false;
+  for (const match of matches) {
+    const start = contextLines > 0 ? Math.max(0, match.lineIndex - contextLines) : match.lineIndex;
+    const end = contextLines > 0 ? Math.min(match.lines.length - 1, match.lineIndex + contextLines) : match.lineIndex;
+    for (let c = start; c <= end; c++) {
+      const lineText = match.lines[c];
+      const { text: truncatedText, wasTruncated } = truncateLine(lineText);
+      if (wasTruncated) linesTruncated = true;
+      const currentLineNum = c + 1;
+      if (c === match.lineIndex) {
+        outputLines.push(`${match.relativePath}:${currentLineNum}: ${truncatedText}`);
+      } else {
+        outputLines.push(`${match.relativePath}-${currentLineNum}- ${truncatedText}`);
+      }
+    }
+  }
+  return { lines: outputLines, linesTruncated };
+}
+function sortFileSummariesByMtime(files) {
+  return files.sort((left, right) => {
+    if (right.mtimeMs !== left.mtimeMs) return right.mtimeMs - left.mtimeMs;
+    return left.relativePath.localeCompare(right.relativePath);
+  });
+}
 async function collectFiles(dirPath, globPattern, fs2, isGitignored = () => false) {
   const files = [];
   const queue = [{ dir: dirPath, relPrefix: "" }];
@@ -6502,13 +6745,19 @@ function createGrepTextTool(cwd, options) {
     context: Type.Optional(
       Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })
     ),
+    outputMode: Type.Optional(Type.Union([
+      Type.Literal("content"),
+      Type.Literal("files_with_matches"),
+      Type.Literal("count")
+    ], { description: "Result mode: content returns matching lines, files_with_matches returns matching file paths, count returns per-file match counts." })),
+    offset: Type.Optional(Type.Number({ description: "Number of results to skip before returning output (default: 0)." })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" }))
   });
   const pathResolutionDescription = buildPathResolutionDescription(cwd, options);
   return {
     name: "grep_text",
     label: "grep_text",
-    description: `Search file contents for a pattern. ${pathResolutionDescription} Returns matching lines with file paths and line numbers. Output is truncated to ${DEFAULT_LIMIT2} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
+    description: `Search file contents for a pattern. ${pathResolutionDescription} outputMode='content' returns matching lines with file paths and line numbers, outputMode='files_with_matches' returns matching file paths, and outputMode='count' returns per-file match counts. Output is truncated to ${DEFAULT_LIMIT2} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
     parameters: grepSchema,
     execute: async (_toolCallId, params, signal) => {
       const {
@@ -6519,9 +6768,11 @@ function createGrepTextTool(cwd, options) {
         ignoreCase,
         literal,
         context: contextLines,
+        outputMode: rawOutputMode,
+        offset: rawOffset,
         limit
       } = params;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -6531,6 +6782,8 @@ function createGrepTextTool(cwd, options) {
         (async () => {
           try {
             const searchPath = resolveToCwd(searchDir || ".", cwd, options, root);
+            const outputMode = normalizeOutputMode(rawOutputMode);
+            const offset = normalizeNonNegativeInteger(rawOffset, 0, "offset");
             const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2);
             const ctx = contextLines && contextLines > 0 ? contextLines : 0;
             let isDir;
@@ -6558,6 +6811,8 @@ function createGrepTextTool(cwd, options) {
             let matchCount = 0;
             let matchLimitReached = false;
             let linesTruncated = false;
+            let filesScanned = 0;
+            let totalFilesWithMatches = 0;
             const isGitignored = await loadGitignoreMatcher(searchPath, fs2);
             if (platform === "puerts" && getNativeFileBridge()) {
               const nativeResult = await runNativeGrep(
@@ -6568,12 +6823,16 @@ function createGrepTextTool(cwd, options) {
                 !!literal,
                 ctx,
                 effectiveLimit,
+                outputMode,
+                offset,
                 signal
               );
               outputLines = nativeResult.Lines ?? [];
-              matchCount = nativeResult.MatchCount ?? 0;
+              matchCount = nativeResult.TotalMatches ?? nativeResult.MatchCount ?? 0;
               matchLimitReached = !!nativeResult.MatchLimitReached;
               linesTruncated = !!nativeResult.LinesTruncated;
+              filesScanned = nativeResult.FilesScanned ?? 0;
+              totalFilesWithMatches = nativeResult.TotalFilesWithMatches ?? 0;
               globalThis.pieBridge?.log?.(
                 "info",
                 `[grep_text] path=${searchPath} pattern=${pattern} matches=${matchCount} files=${nativeResult.FilesScanned ?? 0}`
@@ -6586,11 +6845,9 @@ function createGrepTextTool(cwd, options) {
               } else {
                 filePaths = [searchPath];
               }
+              const contentMatches = [];
+              const fileSummaries = /* @__PURE__ */ new Map();
               for (const filePath of filePaths) {
-                if (matchCount >= effectiveLimit) {
-                  matchLimitReached = true;
-                  break;
-                }
                 if (signal?.aborted) {
                   reject(new Error("Operation aborted"));
                   return;
@@ -6603,36 +6860,65 @@ function createGrepTextTool(cwd, options) {
                 }
                 const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
                 const relativePath = isDir ? fs2.relative(searchPath, filePath) : fs2.basename(filePath);
+                filesScanned++;
+                let fileMatchCount = 0;
                 for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-                  if (matchCount >= effectiveLimit) {
-                    matchLimitReached = true;
-                    break;
-                  }
                   regex.lastIndex = 0;
                   if (regex.test(lines[lineIdx])) {
                     matchCount++;
-                    const start = ctx > 0 ? Math.max(0, lineIdx - ctx) : lineIdx;
-                    const end = ctx > 0 ? Math.min(lines.length - 1, lineIdx + ctx) : lineIdx;
-                    for (let c = start; c <= end; c++) {
-                      const lineText = lines[c];
-                      const { text: truncatedText, wasTruncated } = truncateLine(lineText);
-                      if (wasTruncated) linesTruncated = true;
-                      const currentLineNum = c + 1;
-                      if (c === lineIdx) {
-                        outputLines.push(`${relativePath}:${currentLineNum}: ${truncatedText}`);
-                      } else {
-                        outputLines.push(`${relativePath}-${currentLineNum}- ${truncatedText}`);
-                      }
+                    fileMatchCount++;
+                    if (outputMode === "content" && matchCount > offset && matchCount <= offset + effectiveLimit) {
+                      contentMatches.push({ filePath, relativePath, lineIndex: lineIdx, lines });
                     }
                   }
                 }
+                if (fileMatchCount > 0) {
+                  const fileStat = await fs2.stat(filePath);
+                  fileSummaries.set(filePath, {
+                    filePath,
+                    relativePath,
+                    mtimeMs: fileStat.mtime.getTime(),
+                    matchCount: fileMatchCount
+                  });
+                }
+              }
+              totalFilesWithMatches = fileSummaries.size;
+              if (outputMode === "content") {
+                matchLimitReached = matchCount > offset + effectiveLimit;
+                const formatted = formatContentMatches(contentMatches.slice(0, effectiveLimit), ctx);
+                outputLines = formatted.lines;
+                linesTruncated = formatted.linesTruncated;
+              } else {
+                const sortedFiles = sortFileSummariesByMtime([...fileSummaries.values()]);
+                const page = sortedFiles.slice(offset, offset + effectiveLimit);
+                if (offset + effectiveLimit < sortedFiles.length) {
+                  matchLimitReached = true;
+                }
+                if (outputMode === "files_with_matches") {
+                  outputLines = page.map((file) => file.relativePath);
+                } else {
+                  outputLines = [
+                    `Total matches: ${matchCount}`,
+                    `Files with matches: ${sortedFiles.length}`,
+                    ...page.map((file) => `${file.relativePath}: ${file.matchCount}`)
+                  ];
+                }
               }
             }
             signal?.removeEventListener("abort", onAbort);
             if (matchCount === 0) {
-              resolve2({
+              resolve3({
                 content: [{ type: "text", text: "No matches found" }],
-                details: { noMatches: true }
+                details: {
+                  noMatches: true,
+                  outputMode,
+                  totalMatches: 0,
+                  totalFilesWithMatches: 0,
+                  filesScanned,
+                  offset,
+                  limit: effectiveLimit,
+                  resultLimitReached: false
+                }
               });
               return;
             }
@@ -6640,10 +6926,17 @@ function createGrepTextTool(cwd, options) {
             const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
             let output = truncation.content;
             const details = {};
+            details.outputMode = outputMode;
+            details.totalMatches = matchCount;
+            details.totalFilesWithMatches = totalFilesWithMatches;
+            details.filesScanned = filesScanned;
+            details.offset = offset;
+            details.limit = effectiveLimit;
+            details.resultLimitReached = matchLimitReached;
             const notices = [];
             if (matchLimitReached) {
               notices.push(
-                `${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`
+                outputMode === "content" ? `${effectiveLimit} matches limit reached. Use offset=${offset + effectiveLimit} for more, increase limit, or refine pattern` : `${effectiveLimit} results limit reached. Use offset=${offset + effectiveLimit} for more, increase limit, or refine pattern`
               );
               details.matchLimitReached = effectiveLimit;
             }
@@ -6662,7 +6955,7 @@ function createGrepTextTool(cwd, options) {
 
 [${notices.join(". ")}]`;
             }
-            resolve2({
+            resolve3({
               content: [{ type: "text", text: output }],
               details: Object.keys(details).length > 0 ? details : void 0
             });
@@ -6745,8 +7038,8 @@ function waitForFileCompletion2(requestId) {
   if (existing) {
     return Promise.resolve(existing);
   }
-  return new Promise((resolve2) => {
-    store.waiters.set(requestId, resolve2);
+  return new Promise((resolve3) => {
+    store.waiters.set(requestId, resolve3);
   });
 }
 async function runNativeFind(searchPath, pattern, limit, signal) {
@@ -6836,7 +7129,7 @@ function createFindFilesTool(cwd, options) {
     parameters: findSchema,
     execute: async (_toolCallId, params, signal) => {
       const { pattern, path: searchDir, root, limit } = params;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (signal?.aborted) {
           reject(new Error("Operation aborted"));
           return;
@@ -6852,10 +7145,12 @@ function createFindFilesTool(cwd, options) {
               return;
             }
             let results;
+            let resultLimitReached = false;
             const isGitignored = await loadGitignoreMatcher(searchPath, fs2);
             if (platform === "puerts" && getNativeFileBridge2()) {
               const nativeResult = await runNativeFind(searchPath, pattern, effectiveLimit, signal);
               results = (nativeResult.Results ?? []).filter((filePath) => !isGitignored(filePath, false));
+              resultLimitReached = !!nativeResult.LimitReached && results.length >= effectiveLimit;
               globalThis.pieBridge?.log?.(
                 "info",
                 `[find_files] path=${searchPath} pattern=${pattern} matches=${results.length} dirs=${nativeResult.ScannedDirectories ?? 0} files=${nativeResult.ScannedFiles ?? 0}`
@@ -6864,28 +7159,33 @@ function createFindFilesTool(cwd, options) {
               try {
                 const _require = globalThis.require || __require;
                 const { globSync } = _require("glob");
-                results = globSync(pattern, {
+                const allResults = globSync(pattern, {
                   cwd: searchPath,
                   ignore: ["**/node_modules/**", "**/.git/**"],
                   nodir: false,
                   absolute: false,
                   dot: true
-                }).filter((filePath) => !isGitignored(filePath, false)).slice(0, effectiveLimit);
+                }).filter((filePath) => !isGitignored(filePath, false));
+                resultLimitReached = allResults.length > effectiveLimit;
+                results = allResults.slice(0, effectiveLimit);
               } catch {
-                results = await globFiles(searchPath, pattern, fs2, effectiveLimit, signal, isGitignored);
+                const allResults = await globFiles(searchPath, pattern, fs2, effectiveLimit + 1, signal, isGitignored);
+                resultLimitReached = allResults.length > effectiveLimit;
+                results = allResults.slice(0, effectiveLimit);
               }
             } else {
-              results = await globFiles(searchPath, pattern, fs2, effectiveLimit, signal, isGitignored);
+              const allResults = await globFiles(searchPath, pattern, fs2, effectiveLimit + 1, signal, isGitignored);
+              resultLimitReached = allResults.length > effectiveLimit;
+              results = allResults.slice(0, effectiveLimit);
             }
             signal?.removeEventListener("abort", onAbort);
             if (results.length === 0) {
-              resolve2({
+              resolve3({
                 content: [{ type: "text", text: "No files found matching pattern" }],
                 details: { noMatches: true }
               });
               return;
             }
-            const resultLimitReached = results.length >= effectiveLimit;
             const rawOutput = results.join("\n");
             const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
             let resultOutput = truncation.content;
@@ -6902,7 +7202,7 @@ function createFindFilesTool(cwd, options) {
             if (notices.length > 0) {
               resultOutput += "\n\n[" + notices.join(". ") + "]";
             }
-            resolve2({
+            resolve3({
               content: [{ type: "text", text: resultOutput }],
               details: Object.keys(details).length > 0 ? details : void 0
             });
@@ -6918,10 +7218,12 @@ function createFindFilesTool(cwd, options) {
 
 // ../../packages/shared-headless-capabilities/src/builtin/fs/index.ts
 function createSharedFileSystemTools(sandboxRoot, options) {
+  const fileObservationState = options?.fileObservationState ?? createFileObservationState();
+  const sharedOptions = { ...options, fileObservationState };
   return [
-    createReadTool(sandboxRoot, options),
-    createWriteTool(sandboxRoot, options),
-    createEditTool(sandboxRoot, options),
+    createReadTool(sandboxRoot, sharedOptions),
+    createWriteTool(sandboxRoot, sharedOptions),
+    createEditTool(sandboxRoot, sharedOptions),
     createLsTool(sandboxRoot, options),
     createGrepTextTool(sandboxRoot, options),
     createFindFilesTool(sandboxRoot, options)
@@ -7207,6 +7509,70 @@ function summarizeToolResults(value) {
   }
   return { count: value.length, errors, toolNames };
 }
+function collectTextLength(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  let length = 0;
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (typeof block.text === "string") length += block.text.length;
+  }
+  return length;
+}
+function collectArgumentLength(content) {
+  if (!Array.isArray(content)) return 0;
+  let length = 0;
+  for (const block of content) {
+    if (!isRecord(block) || !("arguments" in block)) continue;
+    if (typeof block.arguments === "string") {
+      length += block.arguments.length;
+      continue;
+    }
+    try {
+      length += JSON.stringify(block.arguments).length;
+    } catch {
+      length += String(block.arguments).length;
+    }
+  }
+  return length;
+}
+function summarizeMessages(value) {
+  if (!Array.isArray(value)) return typeof value;
+  const roles = [];
+  const toolNames = [];
+  const stopReasons = [];
+  let errorCount = 0;
+  let contentBlocks = 0;
+  let textLength = 0;
+  let argumentLength = 0;
+  for (const message of value) {
+    if (!isRecord(message)) continue;
+    const role = typeof message.role === "string" ? message.role : void 0;
+    if (role && roles.length < 20) roles.push(role);
+    if (typeof message.stopReason === "string" && stopReasons.length < 20) stopReasons.push(message.stopReason);
+    if (typeof message.errorMessage === "string" && message.errorMessage) errorCount++;
+    if (typeof message.toolName === "string" && toolNames.length < 20) toolNames.push(message.toolName);
+    const content = Array.isArray(message.content) ? message.content : [];
+    contentBlocks += content.length;
+    textLength += collectTextLength(message.content);
+    argumentLength += collectArgumentLength(message.content);
+    for (const block of content) {
+      if (isRecord(block) && typeof block.name === "string" && toolNames.length < 20) {
+        toolNames.push(block.name);
+      }
+    }
+  }
+  return {
+    count: value.length,
+    roles,
+    toolNames: [...new Set(toolNames)].slice(0, 20),
+    stopReasons: [...new Set(stopReasons)].slice(0, 20),
+    errorCount,
+    contentBlocks,
+    textLength,
+    argumentLength
+  };
+}
 function summarizeFailure(value) {
   if (!isRecord(value)) return typeof value;
   return {
@@ -7259,6 +7625,10 @@ function summarizeMeta(meta) {
       summary[key] = Array.isArray(value) ? { count: value.length } : typeof value;
       continue;
     }
+    if (key === "addedMessages") {
+      summary[key] = summarizeMessages(value);
+      continue;
+    }
     if (key === "message") {
       summary[key] = summarizeMessage(value);
       continue;
@@ -8458,8 +8828,8 @@ async function runQueuedSearch(model, fn) {
   const key = `${model.provider}/${model.id}`;
   const previous = SEARCH_PROVIDER_QUEUE.get(key) ?? Promise.resolve();
   let release;
-  const next = new Promise((resolve2) => {
-    release = resolve2;
+  const next = new Promise((resolve3) => {
+    release = resolve3;
   });
   const queued = previous.catch(() => void 0).then(() => next);
   SEARCH_PROVIDER_QUEUE.set(key, queued);
@@ -8830,10 +9200,10 @@ function assistantText(message) {
 async function withAbort(promise, signal) {
   if (!signal) return promise;
   if (signal.aborted) throw signal.reason ?? new Error("operation aborted");
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const onAbort = () => reject(signal.reason ?? new Error("operation aborted"));
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(resolve2, reject).finally(() => signal.removeEventListener("abort", onAbort));
+    promise.then(resolve3, reject).finally(() => signal.removeEventListener("abort", onAbort));
   });
 }
 async function applyPromptWithModel(deps, prompt, url, content, signal) {
@@ -9334,13 +9704,13 @@ async function runWithDeadline(operation, timeoutMs, message, parentSignal) {
   const child = createChildSignal(parentSignal);
   let timer;
   try {
-    return await new Promise((resolve2, reject) => {
+    return await new Promise((resolve3, reject) => {
       timer = setTimeout(() => {
         const error = new Error(message);
         child.abort(error);
         reject(error);
       }, timeoutMs);
-      operation(child.signal).then(resolve2, reject);
+      operation(child.signal).then(resolve3, reject);
     });
   } finally {
     if (timer) clearTimeout(timer);
@@ -9904,6 +10274,7 @@ export {
   buildProjectContextSection,
   createAskUserCapability,
   createPolicyEnforcedTools,
+  createFileObservationState,
   createSharedFileSystemTools,
   buildToolsPromptSection,
   createSharedWebSearchTool,