@theokit/sdk-tools 0.19.0 → 0.20.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.20.1
+
+### Patch Changes
+
+- apply_patch (V4A) M18 review fixes — a security-critical writing tool hardened after adversarial review:
+  - **Security:** the forbidden-secret guard now blocks `.env`/`.git`/`node_modules`/`.theo` at ANY path
+    depth (not just the first segment) and defeats absolute-path spelling (`<root>/.env`) — closing a hole
+    where a nested `sub/.git/hooks/…` or an absolute secret path could be written.
+  - **Contract:** every fs error (`EISDIR`/`ENOTDIR`/`EACCES`/…) maps to a typed `{ ok: false, error: 'io_error' }`
+    instead of throwing out of the handler (the "always JSON" contract now holds).
+  - **Atomicity:** a file touched by two hunks is rejected (`duplicate_target`) — no silent lost-update.
+  - **Safety:** Add over an existing file is rejected (`file_exists`); Delete of a missing file is `not_found`.
+  - **Matching:** `*** End of File` edits of the last line now apply (eof anchoring made a hint with a
+    general-search fallback, fixing the phantom-trailing-newline case).
+
+## 0.20.0
+
+### Minor Changes
+
+- 68d0e7f: `createApplyPatchTool` now parses Codex's **V4A patch grammar** (`*** Begin Patch` … `*** End Patch`;
+  `*** Add/Update/Delete File:`, optional `*** Move to:`, `@@`-anchored `+`/`-`/context hunks) instead of a
+  unified diff — the format the model actually emits in a Codex-style agent. **BREAKING:** the `{ patch }`
+  input is now a V4A patch, not a unified diff. Matching uses a context-tolerant ladder (exact → rstrip →
+  trim → unicode) mirroring Codex `seek_sequence`; `@@ <ctx>` anchors the search; `*** End of File` anchors
+  to the tail. Applied **strictly atomically** — the whole patch is planned (every file read + new content
+  computed + path security-checked) before any write, so a parse error / context mismatch / path violation
+  anywhere yields a typed error and ZERO writes (stronger than Codex, which can leave partial writes).
+  Add File strips one `+` and always ends with a trailing newline; Update+Move transforms the old content
+  and renames. New `internal/v4a-patch.ts` parser/matcher.
+
 ## 0.19.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -64,8 +64,8 @@ function realpathOfDeepestExisting(path$1) {
   } catch {
   }
   try {
-    const stat2 = fs.lstatSync(path$1);
-    if (stat2.isSymbolicLink()) {
+    const stat3 = fs.lstatSync(path$1);
+    if (stat3.isSymbolicLink()) {
       const target = fs.readlinkSync(path$1);
       const parentReal = realpathOfDeepestExisting(path.dirname(path$1));
       const parentBase = parentReal ?? path.dirname(path$1);
@@ -104,129 +104,360 @@ function isForbiddenPath(input) {
   return false;
 }
 
+// src/internal/v4a-patch.ts
+var BEGIN = "*** Begin Patch";
+var END = "*** End Patch";
+var ADD = "*** Add File: ";
+var DELETE = "*** Delete File: ";
+var UPDATE = "*** Update File: ";
+var MOVE = "*** Move to: ";
+var EOF_MARK = "*** End of File";
+var CTX = "@@ ";
+var CTX_EMPTY = "@@";
+var V4APatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "V4APatchError";
+  }
+};
+function parseV4A(patch) {
+  const lines = patch.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
+  let i = 0;
+  while (i < lines.length && lines[i].trim() !== BEGIN) i++;
+  if (i >= lines.length) throw new V4APatchError("Invalid patch: missing '*** Begin Patch'");
+  i++;
+  const hunks = [];
+  while (i < lines.length) {
+    if (lines[i].trim() === END) return hunks;
+    const step = parseNextHunk(lines, i);
+    if (step.hunk) hunks.push(step.hunk);
+    i = step.next;
+  }
+  throw new V4APatchError("Invalid patch: missing '*** End Patch'");
+}
+function parseNextHunk(lines, i) {
+  const line = lines[i];
+  if (line.startsWith(ADD)) {
+    const [hunk, next] = parseAdd(lines, i);
+    return { hunk, next };
+  }
+  if (line.startsWith(DELETE)) {
+    return { hunk: { kind: "delete", path: line.slice(DELETE.length).trim() }, next: i + 1 };
+  }
+  if (line.startsWith(UPDATE)) {
+    const [hunk, next] = parseUpdate(lines, i);
+    return { hunk, next };
+  }
+  if (line.trim() === "") return { next: i + 1 };
+  throw new V4APatchError(`Invalid patch hunk on line ${i + 1}: unexpected '${line}'`);
+}
+function parseAdd(lines, start) {
+  const path = lines[start].slice(ADD.length).trim();
+  let i = start + 1;
+  const body = [];
+  while (i < lines.length && lines[i].startsWith("+")) {
+    body.push(lines[i].slice(1));
+    i++;
+  }
+  const content = body.length > 0 ? `${body.join("\n")}
+` : "";
+  return [{ kind: "add", path, content }, i];
+}
+function parseUpdate(lines, start) {
+  const path = lines[start].slice(UPDATE.length).trim();
+  let i = start + 1;
+  let movePath = null;
+  if (i < lines.length && lines[i].startsWith(MOVE)) {
+    movePath = lines[i].slice(MOVE.length).trim();
+    i++;
+  }
+  const chunks = [];
+  let cur = null;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (isHunkBoundary(line)) break;
+    cur = feedLine(chunks, cur, line, path, i + 1);
+  }
+  pushChunk(chunks, cur, path);
+  if (chunks.length === 0) throw new V4APatchError(`Update file hunk for '${path}' is empty`);
+  return [{ kind: "update", path, movePath, chunks }, i];
+}
+function isHunkBoundary(line) {
+  return line.trim() === END || line.startsWith(ADD) || line.startsWith(DELETE) || line.startsWith(UPDATE);
+}
+function emptyChunk() {
+  return { context: null, oldLines: [], newLines: [], eof: false };
+}
+function pushChunk(chunks, cur, path) {
+  if (!cur) return;
+  if (cur.oldLines.length === 0 && cur.newLines.length === 0) {
+    throw new V4APatchError(`Update hunk for '${path}' has an empty change block`);
+  }
+  chunks.push(cur);
+}
+function feedLine(chunks, cur, line, path, lineNum) {
+  if (line === CTX_EMPTY || line.startsWith(CTX)) {
+    pushChunk(chunks, cur, path);
+    return {
+      context: line === CTX_EMPTY ? null : line.slice(CTX.length),
+      oldLines: [],
+      newLines: [],
+      eof: false
+    };
+  }
+  if (line.trim() === EOF_MARK) {
+    if (!cur) throw new V4APatchError(`'*** End of File' before any change in '${path}'`);
+    cur.eof = true;
+    return cur;
+  }
+  return appendChangeLine(cur, line, path, lineNum);
+}
+function appendChangeLine(cur, line, path, lineNum) {
+  const c = cur ?? emptyChunk();
+  if (line.startsWith("+")) {
+    c.newLines.push(line.slice(1));
+    return c;
+  }
+  if (line.startsWith("-")) {
+    c.oldLines.push(line.slice(1));
+    return c;
+  }
+  if (line === "" || line.startsWith(" ")) {
+    const content = line === "" ? "" : line.slice(1);
+    c.oldLines.push(content);
+    c.newLines.push(content);
+    return c;
+  }
+  throw new V4APatchError(
+    `Unexpected line in update hunk for '${path}' (line ${lineNum}): every line must start with ' ', '+', or '-': '${line}'`
+  );
+}
+var UNICODE_MAP = {
+  "\u2010": "-",
+  "\u2011": "-",
+  "\u2012": "-",
+  "\u2013": "-",
+  "\u2014": "-",
+  "\u2015": "-",
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201C": '"',
+  "\u201D": '"',
+  "\xA0": " ",
+  "\u2007": " ",
+  "\u202F": " "
+};
+function normalise(s) {
+  let out = "";
+  for (const ch of s) out += UNICODE_MAP[ch] ?? ch;
+  return out.trim();
+}
+var LADDER = [
+  (a, b) => a === b,
+  (a, b) => a.replace(/\s+$/, "") === b.replace(/\s+$/, ""),
+  (a, b) => a.trim() === b.trim(),
+  (a, b) => normalise(a) === normalise(b)
+];
+function matchesAt(lines, pattern, at, eq) {
+  for (let k = 0; k < pattern.length; k++) {
+    if (!eq(lines[at + k], pattern[k])) return false;
+  }
+  return true;
+}
+function seekSequence(lines, pattern, searchStart, eof) {
+  if (pattern.length === 0) return searchStart;
+  if (pattern.length > lines.length) return null;
+  const starts = eof ? [Math.max(searchStart, lines.length - pattern.length), searchStart] : [searchStart];
+  for (const start of starts) {
+    const hit = searchFrom(lines, pattern, start);
+    if (hit !== null) return hit;
+  }
+  return null;
+}
+function searchFrom(lines, pattern, start) {
+  for (const eq of LADDER) {
+    for (let i = start; i <= lines.length - pattern.length; i++) {
+      if (matchesAt(lines, pattern, i, eq)) return i;
+    }
+  }
+  return null;
+}
+function applyUpdateChunks(content, path, chunks) {
+  const lines = content.split("\n");
+  const edits = [];
+  let cursor = 0;
+  for (const chunk of chunks) {
+    if (chunk.context !== null) {
+      const ctxAt = seekSequence(lines, [chunk.context], cursor, false);
+      if (ctxAt === null) {
+        throw new V4APatchError(`Failed to find context '${chunk.context}' in ${path}`);
+      }
+      cursor = ctxAt + 1;
+    }
+    const at = seekSequence(lines, chunk.oldLines, cursor, chunk.eof);
+    if (at === null) {
+      throw new V4APatchError(
+        `Failed to find expected lines in ${path}:
+${chunk.oldLines.join("\n")}`
+      );
+    }
+    edits.push({ start: at, oldLen: chunk.oldLines.length, newLines: chunk.newLines });
+    cursor = at + chunk.oldLines.length;
+  }
+  edits.sort((a, b) => b.start - a.start);
+  for (const e of edits) {
+    lines.splice(e.start, e.oldLen, ...e.newLines);
+  }
+  return lines.join("\n");
+}
+
 // src/apply-patch.ts
 function createApplyPatchTool(opts) {
   const { projectRoot } = opts;
   return sdk.Tool.create({
     name: "apply_patch",
-    description: "Apply a unified diff patch to project files. Each file in the diff is security-checked against the project root. Creates .bak backups before modifying. Returns { ok, files_patched } or { ok: false, error }.",
+    description: "Apply a Codex-style V4A patch. The patch is `*** Begin Patch` \u2026 `*** End Patch` wrapping one or more hunks: `*** Add File: <path>` (then `+`lines), `*** Delete File: <path>`, or `*** Update File: <path>` (optional `*** Move to: <path>`) with `@@`-anchored `+` (add) / `-` (remove) / ` ` (context) lines. Read a file first so your context/removed lines match. Applied atomically \u2014 a mismatch anywhere aborts the whole patch with zero writes; each path is security-checked. Returns { ok, files_patched } or { ok: false, error }.",
     inputSchema: zod.z.object({
-      patch: zod.z.string().min(1).describe("Unified diff content.")
+      patch: zod.z.string().min(1).describe("V4A patch: *** Begin Patch \u2026 *** End Patch.")
     }),
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: unified diff parsing is inherently complex
-    handler: async ({ patch }) => {
-      const hunks = parsePatch(patch);
-      if (hunks.length === 0) {
-        return JSON.stringify({ ok: false, error: "parse_error", detail: "no file hunks found" });
-      }
-      for (const hunk of hunks) {
-        if (isForbiddenPath(hunk.file)) {
-          return JSON.stringify({ ok: false, error: "forbidden_path", path: hunk.file });
-        }
-        try {
-          const abs = safePathJoin(projectRoot, hunk.file);
-          assertNoSymlinkEscape(abs, projectRoot);
-        } catch (err) {
-          if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
-            return JSON.stringify({ ok: false, error: "path_traversal", path: hunk.file });
-          }
-          throw err;
-        }
-      }
-      const patched = [];
-      for (const hunk of hunks) {
-        const absolutePath = safePathJoin(projectRoot, hunk.file);
-        let content;
-        try {
-          content = await promises.readFile(absolutePath, "utf-8");
-        } catch (err) {
-          const e = err;
-          if (e.code === "ENOENT") {
-            content = "";
-          } else {
-            throw err;
-          }
-        }
-        const result = applyHunks(content, hunk.changes);
-        if (result === null) {
-          return JSON.stringify({
-            ok: false,
-            error: "patch_failed",
-            path: hunk.file,
-            detail: "hunk context mismatch"
-          });
-        }
-        if (content !== "") {
-          await promises.copyFile(absolutePath, `${absolutePath}.bak`);
-        }
-        await promises.mkdir(path.dirname(absolutePath), { recursive: true });
-        await promises.writeFile(absolutePath, result, "utf-8");
-        patched.push(hunk.file);
-      }
-      return JSON.stringify({ ok: true, files_patched: patched });
-    }
+    handler: async ({ patch }) => applyV4APatch(projectRoot, patch)
   });
 }
-function parsePatch(patch) {
-  const lines = patch.split("\n");
-  const hunks = [];
-  let current = null;
-  for (const line of lines) {
-    if (line.startsWith("+++ ")) {
-      const filePath = line.slice(4).replace(/^b\//, "").trim();
-      if (filePath && filePath !== "/dev/null") {
-        current = { file: filePath, changes: [] };
-        hunks.push(current);
-      }
-      continue;
+async function applyV4APatch(projectRoot, patch) {
+  let hunks;
+  try {
+    hunks = parseV4A(patch);
+  } catch (err) {
+    const detail = err instanceof V4APatchError ? err.message : String(err);
+    return JSON.stringify({ ok: false, error: "parse_error", detail });
+  }
+  try {
+    const plan = await buildPlan(projectRoot, hunks);
+    if ("error" in plan) return plan.error;
+    await executePlan(plan.ops);
+    return JSON.stringify({ ok: true, files_patched: plan.patched });
+  } catch (err) {
+    return JSON.stringify({
+      ok: false,
+      error: "io_error",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function hunkTargets(hunk) {
+  if (hunk.kind === "update" && hunk.movePath) return [hunk.path, hunk.movePath];
+  return [hunk.path];
+}
+async function buildPlan(projectRoot, hunks) {
+  const dup = firstDuplicateTarget(hunks);
+  if (dup !== null) {
+    return { error: JSON.stringify({ ok: false, error: "duplicate_target", path: dup }) };
+  }
+  const ops = [];
+  const patched = [];
+  for (const hunk of hunks) {
+    const planned = await planHunk(projectRoot, hunk);
+    if ("error" in planned) return planned;
+    ops.push(...planned.ops);
+    patched.push(hunk.kind === "update" ? hunk.movePath ?? hunk.path : hunk.path);
+  }
+  return { ops, patched };
+}
+function firstDuplicateTarget(hunks) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const hunk of hunks) {
+    for (const t of hunkTargets(hunk)) {
+      if (seen.has(t)) return t;
+      seen.add(t);
     }
-    if (line.startsWith("--- ")) continue;
-    if (line.startsWith("@@ ")) continue;
-    if (current === null) continue;
-    if (line.startsWith("+")) {
-      current.changes.push({ type: "add", content: line.slice(1) });
-    } else if (line.startsWith("-")) {
-      current.changes.push({ type: "remove", content: line.slice(1) });
-    } else if (line.startsWith(" ")) {
-      current.changes.push({ type: "context", content: line.slice(1) });
+  }
+  return null;
+}
+async function executePlan(ops) {
+  for (const op of ops) {
+    if ("rm" in op) {
+      await promises.rm(op.rm, { force: true });
+    } else {
+      await promises.mkdir(path.dirname(op.write.abs), { recursive: true });
+      await promises.writeFile(op.write.abs, op.write.content, "utf-8");
     }
   }
-  return hunks;
 }
-function applyHunks(content, changes) {
-  const originalLines = content.split("\n");
-  const result = [];
-  let origIdx = 0;
-  const firstContext = changes.find((c) => c.type === "context" || c.type === "remove");
-  if (firstContext) {
-    const startIdx = originalLines.indexOf(firstContext.content, origIdx);
-    if (startIdx === -1) return null;
-    for (let i = 0; i < startIdx; i++) {
-      result.push(originalLines[i]);
-    }
-    origIdx = startIdx;
-  }
-  for (const change of changes) {
-    if (change.type === "context") {
-      if (origIdx >= originalLines.length || originalLines[origIdx] !== change.content) {
-        return null;
-      }
-      result.push(change.content);
-      origIdx++;
-    } else if (change.type === "remove") {
-      if (origIdx >= originalLines.length || originalLines[origIdx] !== change.content) {
-        return null;
-      }
-      origIdx++;
-    } else if (change.type === "add") {
-      result.push(change.content);
+async function pathExists(abs) {
+  try {
+    await promises.stat(abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function planHunk(projectRoot, hunk) {
+  const scope = v4aScope(projectRoot, hunk.path);
+  if ("error" in scope) return scope;
+  if (hunk.kind === "add") {
+    if (await pathExists(scope.abs)) {
+      return { error: JSON.stringify({ ok: false, error: "file_exists", path: hunk.path }) };
     }
+    return { ops: [{ write: { abs: scope.abs, content: hunk.content } }] };
   }
-  while (origIdx < originalLines.length) {
-    result.push(originalLines[origIdx]);
-    origIdx++;
+  if (hunk.kind === "delete") {
+    if (!await pathExists(scope.abs)) {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path: hunk.path }) };
+    }
+    return { ops: [{ rm: scope.abs }] };
+  }
+  return planUpdate(projectRoot, hunk, scope.abs);
+}
+async function planUpdate(projectRoot, hunk, abs) {
+  let content;
+  try {
+    content = await promises.readFile(abs, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { error: JSON.stringify({ ok: false, error: "not_found", path: hunk.path }) };
+    }
+    throw err;
+  }
+  let updated;
+  try {
+    updated = applyUpdateChunks(content, hunk.path, hunk.chunks);
+  } catch (err) {
+    if (err instanceof V4APatchError) {
+      return {
+        error: JSON.stringify({
+          ok: false,
+          error: "patch_failed",
+          path: hunk.path,
+          detail: err.message
+        })
+      };
+    }
+    throw err;
+  }
+  if (!hunk.movePath) return { ops: [{ write: { abs, content: updated } }] };
+  const dest = v4aScope(projectRoot, hunk.movePath);
+  if ("error" in dest) return dest;
+  return { ops: [{ write: { abs: dest.abs, content: updated } }, { rm: abs }] };
+}
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set([".env", ".git", "node_modules", ".theo"]);
+function isForbiddenRel(rel) {
+  return rel.split(/[/\\]/).filter(Boolean).some((s) => s !== ".env.example" && (FORBIDDEN_SEGMENTS.has(s) || /^\.env\./.test(s)));
+}
+function v4aScope(projectRoot, file) {
+  let abs;
+  try {
+    abs = safePathJoin(projectRoot, file);
+    assertNoSymlinkEscape(abs, projectRoot);
+  } catch (err) {
+    if (err instanceof PathTraversalError || err instanceof ForbiddenPathError) {
+      return { error: JSON.stringify({ ok: false, error: "path_traversal", path: file }) };
+    }
+    throw err;
+  }
+  if (isForbiddenPath(file) || isForbiddenRel(path.relative(projectRoot, abs))) {
+    return { error: JSON.stringify({ ok: false, error: "forbidden_path", path: file }) };
   }
-  return result.join("\n");
+  return { abs };
 }
 function createSessionArtifactStore(options) {
   const { dir } = options;
@@ -330,7 +561,7 @@ var LINE_MATCH_LADDER = [
   (s) => normalizeUnicode(s).trim()
   // unicode + trim (loosest)
 ];
-function matchesAt(lines, pattern, i, norm) {
+function matchesAt2(lines, pattern, i, norm) {
   for (let p = 0; p < pattern.length; p++) {
     const lineAt = lines[i + p];
     const patAt = pattern[p];
@@ -341,7 +572,7 @@ function matchesAt(lines, pattern, i, norm) {
 function findHits(lines, pattern, norm) {
   const hits = [];
   for (let i = 0; i + pattern.length <= lines.length; i++) {
-    if (matchesAt(lines, pattern, i, norm)) hits.push(i);
+    if (matchesAt2(lines, pattern, i, norm)) hits.push(i);
   }
   return hits;
 }
@@ -1373,29 +1604,29 @@ function createListDirTool(opts) {
       path: zod.z.string().min(1).describe("Project-relative directory path. Use '.' for root.")
     }),
     handler: async ({ path }, ctx) => {
-      const relative2 = path === "" || path === "." ? "." : path;
-      if (relative2 !== "." && isForbiddenPath(relative2)) {
+      const relative3 = path === "" || path === "." ? "." : path;
+      if (relative3 !== "." && isForbiddenPath(relative3)) {
         return JSON.stringify({ ok: false, error: "forbidden_path", path });
       }
       if (filesystem$1) {
         const backend = await filesystem.resolveFilesystem(filesystem$1, ctx ?? {});
-        return listViaBackend(backend, relative2, path, max);
+        return listViaBackend(backend, relative3, path, max);
       }
-      return listViaLocalFs(projectRoot, relative2, path, max);
+      return listViaLocalFs(projectRoot, relative3, path, max);
     }
   });
 }
-async function listViaLocalFs(projectRoot, relative2, originalPath, max) {
-  const boundary = resolveDirBoundary(relative2, projectRoot, originalPath);
+async function listViaLocalFs(projectRoot, relative3, originalPath, max) {
+  const boundary = resolveDirBoundary(relative3, projectRoot, originalPath);
   if ("error" in boundary) return boundary.error;
   const readResult = await readDirSafe(boundary.absolutePath, originalPath);
   if ("error" in readResult) return readResult.error;
   return formatListing(readResult.dirents, max);
 }
-async function listViaBackend(backend, relative2, originalPath, max) {
+async function listViaBackend(backend, relative3, originalPath, max) {
   let names;
   try {
-    names = await backend.list(relative2);
+    names = await backend.list(relative3);
   } catch (err) {
     if (err instanceof filesystem.FileNotFoundError) {
       return JSON.stringify({ ok: false, error: "not_found", path: originalPath });
@@ -1409,7 +1640,7 @@ async function listViaBackend(backend, relative2, originalPath, max) {
   const windowed = names.slice(0, max);
   const entries = await Promise.all(
     windowed.map(async (name) => {
-      const child = relative2 === "." ? name : `${relative2}/${name}`;
+      const child = relative3 === "." ? name : `${relative3}/${name}`;
       let type = "file";
       try {
         type = (await backend.stat(child)).isDirectory ? "directory" : "file";
@@ -1420,9 +1651,9 @@ async function listViaBackend(backend, relative2, originalPath, max) {
   );
   return JSON.stringify({ ok: true, entries, truncated: totalCount > max, totalCount });
 }
-function resolveDirBoundary(relative2, projectRoot, originalPath) {
+function resolveDirBoundary(relative3, projectRoot, originalPath) {
   try {
-    const absolutePath = relative2 === "." ? projectRoot : safePathJoin(projectRoot, relative2);
+    const absolutePath = relative3 === "." ? projectRoot : safePathJoin(projectRoot, relative3);
     assertNoSymlinkEscape(absolutePath, projectRoot);
     return { absolutePath };
   } catch (err) {
@@ -1644,22 +1875,22 @@ function createReadFileTool(opts) {
 }
 async function readViaBackend(backend, path, view, onRead) {
   try {
-    const stat2 = await backend.stat(path);
-    if (stat2.size > MAX_FILE_SIZE) {
+    const stat3 = await backend.stat(path);
+    if (stat3.size > MAX_FILE_SIZE) {
       return JSON.stringify({
         ok: false,
         error: "too_large",
         path,
-        size: stat2.size,
+        size: stat3.size,
         limit: MAX_FILE_SIZE
       });
     }
     const raw = await backend.readFile(path);
     if (raw.includes("\0")) {
-      return JSON.stringify({ ok: false, error: "binary_file", path, size: stat2.size });
+      return JSON.stringify({ ok: false, error: "binary_file", path, size: stat3.size });
     }
-    onRead?.(stat2.mtimeMs);
-    return JSON.stringify({ ok: true, content: renderView(raw, view), size: stat2.size });
+    onRead?.(stat3.mtimeMs);
+    return JSON.stringify({ ok: true, content: renderView(raw, view), size: stat3.size });
   } catch (err) {
     if (err instanceof filesystem.FileNotFoundError) {
       return JSON.stringify({ ok: false, error: "not_found", path });
@@ -1698,22 +1929,22 @@ async function openHandleSafe(absolutePath, path) {
   }
 }
 async function readContent(handle, path, view, onRead) {
-  const stat2 = await handle.stat();
-  if (stat2.size > MAX_FILE_SIZE) {
+  const stat3 = await handle.stat();
+  if (stat3.size > MAX_FILE_SIZE) {
     return JSON.stringify({
       ok: false,
       error: "too_large",
       path,
-      size: stat2.size,
+      size: stat3.size,
       limit: MAX_FILE_SIZE
     });
   }
-  if (await isBinaryProbe(handle, Number(stat2.size))) {
-    return JSON.stringify({ ok: false, error: "binary_file", path, size: stat2.size });
+  if (await isBinaryProbe(handle, Number(stat3.size))) {
+    return JSON.stringify({ ok: false, error: "binary_file", path, size: stat3.size });
   }
   const raw = await handle.readFile({ encoding: "utf-8" });
-  onRead?.(stat2.mtimeMs);
-  return JSON.stringify({ ok: true, content: renderView(raw, view), size: stat2.size });
+  onRead?.(stat3.mtimeMs);
+  return JSON.stringify({ ok: true, content: renderView(raw, view), size: stat3.size });
 }
 async function isBinaryProbe(handle, size) {
   const probeLen = Math.min(BINARY_PROBE_BYTES, size);
@@ -2629,12 +2860,12 @@ async function writeViaBackend(backend, path, content, guard) {
       if (rbw) return rbw;
       expectedMtime = current ?? void 0;
     }
-    const stat2 = await backend.writeFile(
+    const stat3 = await backend.writeFile(
       path,
       content,
       expectedMtime !== void 0 ? { expectedMtime } : void 0
     );
-    return JSON.stringify({ ok: true, path, bytes: stat2.size });
+    return JSON.stringify({ ok: true, path, bytes: stat3.size });
   } catch (err) {
     return backendErrorToJson(err, path);
   }
@@ -2662,8 +2893,8 @@ async function isBinaryFile(absolutePath) {
     return false;
   }
   try {
-    const stat2 = await handle.stat();
-    const probeLen = Math.min(BINARY_PROBE_BYTES3, Number(stat2.size));
+    const stat3 = await handle.stat();
+    const probeLen = Math.min(BINARY_PROBE_BYTES3, Number(stat3.size));
     if (probeLen <= 0) return false;
     const probe = Buffer.alloc(probeLen);
     const { bytesRead } = await handle.read(probe, 0, probeLen, 0);