pi-supernova 0.10.1 → 0.11.0

package/index.js

@@ -10,6 +10,7 @@ import { REFERENCE } from "./src/runtime/reference.js";
 import { errorMessage, isString } from "./src/shared/decode.js";
 import { loadConfig } from "./src/config/config.js";
 import { createHostBridge } from "./src/bridge/host-bridge.js";
+import { NATIVE_NAMES } from "./src/bridge/native-tools.js";
 
 import { runGuestProgram, warmGuestWorker, stopWarmGuestWorker } from "./src/runtime/runtime.js";
 import { renderSupernovaCall, renderSupernovaResult } from "./src/ui/render.js";
@@ -65,14 +66,12 @@ export function registerCodeMode(pi) {
   function makeNovaApi(runBridge, cancel) {
     return {
       call: (name, args, onItem) => runBridge.call(name, args, onItem),
-      callMany: (calls) => runBridge.callMany(calls),
       speculateBegin: () => runBridge.barrier(() => runBridge.beginSpeculation()),
       speculateCommit: () => runBridge.barrier(() => runBridge.commitSpeculation()),
       speculateRollback: () => runBridge.barrier(() => runBridge.rollbackSpeculation()),
-      names: () => ["read", "edit", "write", "bash"],
+      names: () => NATIVE_NAMES,
       describeMemory: () => runBridge.describeMemory?.() ?? null,
       batchRead: runBridge.supportsBatchRead(),
-      nativeArgv: runBridge.supportsNativeArgv?.() === true,
       cancel,
     };
   }
@@ -102,16 +101,18 @@ export function registerCodeMode(pi) {
   }
 
   async function runAndCommit(params, runCwd, runBridge, abortRun, runController, budget) {
+    const started = performance.now();
+    const timeoutMs = params?.timeoutMs === undefined ? config.timeoutMs : Number(params.timeoutMs);
     refreshCatalog(runBridge);
     runBridge.beginSpeculation();
 
-    const outcome = await runGuestProgram({
+    let outcome = await runGuestProgram({
       code: params?.code,
       file: params?.file,
       cwd: runCwd,
       data: params?.data,
       nova: makeNovaApi(runBridge, abortRun),
-      config: { ...config, maxLogLines: Math.max(0,config.maxLogLines-(budget?.logLines ?? 0)), timeoutMs: params?.timeoutMs === undefined ? config.timeoutMs : Number(params.timeoutMs) },
+      config: { ...config, maxLogLines: Math.max(0,config.maxLogLines-(budget?.logLines ?? 0)), timeoutMs },
       signal: runController.signal,
       onTimeout: abortRun,
     });
@@ -119,14 +120,35 @@ export function registerCodeMode(pi) {
     runBridge.close();
 
     if (outcome.ok) {
-      if (runBridge.getOverlayDepth() !== 1) throw new Error("program ended with an unfinished edit checkpoint; await it before returning");
-      await runBridge.commitSpeculation();
+      try {
+        if (runBridge.getOverlayDepth() !== 1) throw new Error("program ended with an unfinished edit checkpoint; await it before returning");
+        await commitBeforeDeadline(runBridge, runController, timeoutMs, started);
+      } catch (error) {
+        abortRun();
+        outcome = {ok:false,error:errorMessage(error),logs:outcome.logs,logTruncated:outcome.logTruncated};
+      }
     }
-    else while (runBridge.getOverlayDepth()) runBridge.rollbackSpeculation();
+
+    if (!outcome.ok) while (runBridge.getOverlayDepth()) runBridge.rollbackSpeculation();
+    outcome.wallMs = Math.round(performance.now() - started);
 
     return outcome;
   }
 
+  async function commitBeforeDeadline(runBridge, controller, requestedTimeout, started) {
+    // The guest has finished, but its public invocation still owns the queued
+    // and on-disk commit. Carry the same admitted timeout through this phase.
+    const timeout = Math.max(1, Math.min(2147483647, Math.floor(requestedTimeout)));
+    const remaining = timeout - (performance.now() - started);
+    const expire = () => controller.abort(new Error("program timed out after " + Math.round(performance.now()-started) + "ms during final commit (timeoutMs=" + timeout + ")"));
+    const timer = remaining > 0 ? setTimeout(expire, remaining) : undefined;
+
+    if (remaining <= 0) expire();
+
+    try { await runBridge.commitSpeculation(); }
+    finally { clearTimeout(timer); }
+  }
+
   function scheduleWarm(runController) {
     cancelWarmTimer();
 
@@ -160,9 +182,9 @@ export function registerCodeMode(pi) {
     const visible = runBridge.ledger.dedupe(bounded, call);
 
     const response = result(visible, {
-      ok: outcome.ok, error: outcome.error, wallMs: outcome.wallMs,
+      ok: outcome.ok, partial: !outcome.ok && outcome.mutations.committed > 0, error: outcome.error, wallMs: outcome.wallMs,
       returnTruncated: outcome.returnTruncated, logTruncated: outcome.logTruncated,
-      logs: outcome.logs, result: outcome.result, trace, mutations: outcome.mutations,
+      logs: outcome.logs, result: outcome.result, trace, mutations: outcome.mutations, savedPaths: outcome.savedPaths,
     });
 
     if (outcome.images?.length) response.content.push(...outcome.images);
@@ -172,6 +194,7 @@ export function registerCodeMode(pi) {
 
   pi.registerTool({
     name: "supernova",
+    exposure: "model-only",
     label: "Supernova",
     description: TOOL_DESCRIPTION,
     promptSnippet: "read, write, edit, bash",
@@ -230,6 +253,12 @@ export function registerCodeMode(pi) {
     },
   });
 
+  // Pi treats resolved execute() calls as successful, ignoring result.isError.
+  // Keep partial batch results/images intact and correct the final host status.
+  pi.on("tool_result", event => {
+    if (event.toolName === "supernova" && event.details?.ok === false) return { isError: true };
+  });
+
   // This is a pre-conversion observation, not a final-payload retention proof.
   // Shipping seenWindow:0 must not subscribe: a no-op listener still runs on every
   // provider context event. Opt-in windows register here.
@@ -263,7 +292,7 @@ export function registerCodeMode(pi) {
     handler: async (_args, ctx) => {
       bridge.bindCallContext(ctx);
       refreshCatalog();
-      const commands = ["read", "edit", "write", "bash"].filter(bridge.isCallable);
+      const commands = NATIVE_NAMES.filter(bridge.isCallable);
 
       const lines = [
         `Supernova CodeMode: ${commands.join(", ")}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "CodeMode for Pi and OMP: read, edit, write and bash, with transactional files, source views and shared-input program batches.",
   "type": "module",
   "author": "AdityaVG13",
@@ -25,7 +25,8 @@
   "files": [
     "index.js",
     "src/",
-    "docs/",
+    "docs/CHANGELOG.md",
+    "docs/TOKEN_COSTS.md",
     "README.md",
     "LICENSE"
   ],
@@ -34,7 +35,7 @@
     "test:hosts": "node tests/hosts/verify.mjs",
     "measure": "node tests/efficiency/measure.mjs",
     "test:tokens": "node tests/efficiency/tokens.mjs",
-    "prepublishOnly": "npm test && node ../../scripts/preflight.mjs"
+    "prepublishOnly": "node ../../scripts/preflight.mjs"
   },
   "pi": {
     "extensions": [

package/src/adapters/bash.js

@@ -1,5 +1,10 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { canonicalNewPath } from "../fs/commit.js";
 import { readResult } from "../shared/result.js";
+import { truncateChars } from "../output/format.js";
+
+const BASH_CAPTURE_CHARS = 2 * 1024 * 1024;
 
 import { normalizeBash } from "../contract/bash.js";
 import { sourceForReferences } from "../fs/source-window.js";
@@ -20,7 +25,7 @@ export function createBash(ctx) {
       const command = String(params.command);
       const literal = Array.isArray(params.args);
       const argv = literal ? [command, ...params.args] : ["bash", "-c", command];
-      const targetCwd = await commandCwd(params, cwd);
+      const targetCwd = await commandCwd(params, cwd, vfs);
 
       const transactionBarrier = await vfs.prepareExternalMutation("bash");
       let res;
@@ -32,7 +37,7 @@ export function createBash(ctx) {
           commandLabel: command,
           timeoutMs: params?.timeoutMs === undefined ? config.timeoutMs : params.timeoutMs,
           signal,
-          maxOutputChars: config.maxCallResultChars,
+          maxOutputChars: BASH_CAPTURE_CHARS,
         });
       } catch (error) {
         if (!signal?.aborted) error.message += await sourceForReferences(cwd, targetCwd, error.message, signal, ledger);
@@ -44,6 +49,8 @@ export function createBash(ctx) {
         hooks.workspaceChanged();
       }
 
+      if (res.outputTruncated) throw new Error("bash output exceeds " + BASH_CAPTURE_CHARS + " character capture limit; redirect output to a file and read it with complete:true or json");
+
       const { stdout, stderr } = res;
       let text = combineBashText(stdout, stderr);
 
@@ -55,11 +62,14 @@ export function createBash(ctx) {
         text += await sourceForReferences(cwd, targetCwd, text, signal, ledger);
       }
 
-      return {
-        content: [{ type: "text", text }],
-        details: { exitCode: res.exitCode, signal: res.signal, outputTruncated: res.outputTruncated, transactionBarrier },
-        isError: res.exitCode !== 0,
-      };
+      // Computation owns the complete captured value; traces/model output get
+      // only a bounded preview. Never feed a clipped JSON string to the guest.
+      const result = readResult(text, { exitCode: res.exitCode, signal: res.signal, outputTruncated: false, transactionBarrier },
+        truncateChars(text, config.maxCallResultChars, "command output").text);
+
+      result.isError = res.exitCode !== 0;
+
+      return result;
   }
 
   async function background(params, signal) {
@@ -71,7 +81,7 @@ export function createBash(ctx) {
 
     if (params.background === true) {
       await manager.validateStart(params, hooks.terminalGeneration);
-      targetCwd = await commandCwd(params, getCwd());
+      targetCwd = await commandCwd(params, getCwd(), vfs);
     } else manager.validateControl(params, owner, hooks.terminalGeneration);
     const transactionBarrier = mutating ? await vfs.prepareExternalMutation("bash") : false;
 
@@ -97,13 +107,33 @@ export function createBash(ctx) {
   return { bash };
 }
 
-async function commandCwd(params, cwd) {
+// Admit only directories that the pending file set will materialize. Checking
+// before the barrier keeps invalid cwd requests from committing unrelated files.
+async function stagedDirectory(target, vfs) {
+  const pending = await vfs.getOverlayPaths();
+
+  if (!pending.length) return false;
+  const directory = await canonicalNewPath(target);
+  let found = false;
+
+  for (const logicalPath of pending) {
+    const file = await canonicalNewPath(logicalPath);
+
+    if (file === directory) return false;
+
+    if (file.startsWith(directory + path.sep)) found = true;
+  }
+
+  return found;
+}
+
+async function commandCwd(params, cwd, vfs) {
   const target = params.cwd ? await resolveWorkspacePath(cwd, params.cwd, "bash cwd", true) : cwd;
 
   if (params.cwd !== undefined) {
     const stat = await fs.stat(target).catch(() => null);
 
-    if (!stat?.isDirectory()) throw new Error("bash cwd is not a directory: " + params.cwd);
+    if (!stat?.isDirectory() && (stat || !await stagedDirectory(target, vfs))) throw new Error("bash cwd is not a directory: " + params.cwd);
   }
 
   return target;

package/src/adapters/edit.js

@@ -7,17 +7,48 @@ import { applyPatchToText } from "../fs/patch.js";
 import { resolveWorkspacePath, relativeSlash } from "../fs/workspace.js";
 import { referencesForNames } from "../context/search.js";
 import {
-  textResult, sourceLines, lineTextRange, applyReplacements, applyViewReplace,
-  shiftDiffLines, contentLineInfo, boundedEditDiff, QUICK_CHECK_MAX_CHARS,
+  textResult, sourceLines, applyReplacements, applyViewReplace,
+  shiftDiffLines, contentLineInfo, boundedEditDiff, QUICK_CHECK_MAX_CHARS, lineStartIndex, lineEndIndex,
 } from "../fs/text-ops.js";
 
 export function createEdit(ctx) {
   const { getCwd, vfs, index, ledger } = ctx;
-  function lineAt(updated, newLines, n) {
-    if (newLines) return newLines[n - 1] ?? "";
-    const { start, end } = lineTextRange(updated, n);
 
-    return updated.slice(start, end).replace(/\r?\n$/, "");
+  async function editTargetPath(cwd, inputPath, command) {
+    try {
+      // Windows can report ENOENT for an oversized component instead of ENAMETOOLONG.
+      if (process.platform === "win32" && isString(inputPath) && inputPath.split(/[\\/]/).some(part => part.length > 255)) {
+        throw Object.assign(new Error("path component exceeds the filesystem limit"), { code: "ENAMETOOLONG" });
+      }
+
+      return await resolveWorkspacePath(cwd, inputPath, command, false);
+    }
+    catch (error) {
+      if (error?.code !== "ENAMETOOLONG") throw error;
+
+      // A plain read value mistaken for a path can contain an entire source
+      // file. Keep the errno, but do not reflect that value in the diagnostic.
+      const failure = new Error(command + " path exceeds the filesystem limit; expected a filename. Ordinary read(path) returns text; use edit(path,oldText,newText), or read(path,{resolve:true}) for an editable view");
+
+      failure.code = error.code;
+
+      throw failure;
+    }
+  }
+
+  function editBlockLines(updated, newLines, start, last) {
+    if (newLines) return newLines.slice(start - 1, last);
+    const lines = [];
+    let from = lineStartIndex(updated, start);
+
+    // Consecutive preview lines share one prefix scan, even in large files.
+    for (let line = start; line <= last; line++) {
+      const end = lineEndIndex(updated, from, 1);
+      lines.push(updated.slice(from, end).replace(/\r?\n$/, ""));
+      from = end;
+    }
+
+    return lines;
   }
 
   function spanEditRange(span, lineCount) {
@@ -39,6 +70,7 @@ export function createEdit(ctx) {
 
     if (explicit) return explicit;
     const ranges = [];
+
     const positions = diff.lines.filter(row => row.type !== "context")
       .map(row => Math.min(lineCount, row.newLineNum ?? row.lineNum)).sort((a, b) => a - b);
 
@@ -53,7 +85,7 @@ export function createEdit(ctx) {
 
     for (const { start, end } of ranges) {
       const last = Math.min(end, start + perRange - 1);
-      const lines = Array.from({ length: Math.max(0, last - start + 1) }, (_, i) => lineAt(updated, newLines, start + i));
+      const lines = editBlockLines(updated, newLines, start, last);
       ledger.recordOrigin(rel, start, lines);
       blocks.push("edited " + rel + ":" + start + "-" + last + "\n" + lines.map((line, i) => String(start + i).padStart(5) + " " + line).join("\n"));
 
@@ -80,21 +112,34 @@ export function createEdit(ctx) {
     return out;
   }
 
-  function lineText(text, lines, number) {
-    if (lines) return lines[number - 1] ?? "";
-    const { start, end } = lineTextRange(text, number);
+  function lineReader(text) {
+    let line = 1, start = 0;
+
+    // Diff rows share a forward cursor per version, not a fresh prefix scan
+    // per row or a second array of every line. Backward coordinates rewind it.
+    return number => {
+      const nextLine = Math.max(1, number);
+
+      if (nextLine < line) { line = 1; start = 0; }
 
-    return text.slice(start, end).replace(/\r?\n$/, "");
+      start = lineEndIndex(text, start, nextLine - line);
+      line = nextLine;
+      const end = lineEndIndex(text, start, 1);
+
+      return text.slice(start, end).replace(/\r?\n$/, "");
+    };
   }
 
-  function nameAtDiffLine(l, original, updated, oldLines, newLines, canMapOwners, target, spans) {
+  function nameAtDiffLine(l, original, updated, readOldLine, readNewLine, canMapOwners, target, spans) {
     const number = l.type === "remove" ? l.lineNum : l.newLineNum ?? l.lineNum;
     const source = l.type === "remove" ? original : updated;
-    const cached = l.type === "remove" ? oldLines : newLines;
-    const name = declaredName(lineText(source, cached, number));
+    const readLine = l.type === "remove" ? readOldLine : readNewLine;
+    const name = declaredName(readLine(number));
 
     if (name) return name;
+
     if (!canMapOwners) return;
+
     if (!spans.has(l.type)) spans.set(l.type, WorkspaceIndex.spansOf(WorkspaceIndex.fromText(target, source)));
 
     return spans.get(l.type).find(span => span.start <= number && number <= span.end)?.name;
@@ -102,16 +147,19 @@ export function createEdit(ctx) {
 
   function collectChangedNames(target, original, updated, diff) {
     const canMapOwners = original.length <= 512 * 1024 && updated.length <= 512 * 1024;
-    const oldLines = canMapOwners ? original.split("\n") : null;
-    const newLines = canMapOwners ? updated.split("\n") : null;
+    const readOldLine = lineReader(original);
+    const readNewLine = lineReader(updated);
     const names = new Set();
     const spans = new Map();
 
     for (const l of diff.lines) {
       if (l.type === "context") continue;
-      const name = nameAtDiffLine(l, original, updated, oldLines, newLines, canMapOwners, target, spans);
+      const name = nameAtDiffLine(l, original, updated, readOldLine, readNewLine, canMapOwners, target, spans);
+
+      // The generic declaration heuristic reads "const auto" as a binding.
+      // In C++ it is a type keyword, not a symbol to search across the repo.
+      if (name && !(name === "auto" && /\.(?:cc|cpp|h|hpp)$/i.test(target))) names.add(name);
 
-      if (name) names.add(name);
       if (names.size >= 3) break;
     }
 
@@ -137,8 +185,10 @@ export function createEdit(ctx) {
     if (names.size === 0) return "";
 
     try {
+      const excludePath = path.resolve(cwd, path.relative(await vfs.resolvePath(cwd), await vfs.resolvePath(target)));
+
       const { references, incomplete } = await referencesForNames({ root: cwd, names: [...names].slice(0, 3),
-        excludePath: target, overlayText: file => vfs.getOverlay(file), pendingPaths: vfs.getOverlayPaths(), signal });
+        excludePath, overlayText: file => vfs.getOverlay(file), pendingPaths: await vfs.getOverlayPaths(cwd), signal });
 
       return formatNameRefs(references, incomplete);
     } catch (error) {
@@ -159,9 +209,11 @@ export function createEdit(ctx) {
   async function applyViewEdit(cwd, target, content, params, signal) {
     const viewText = String(params.viewText);
     const nextText = String(params.newText);
+
     const windowNext = isString(params.oldText)
       ? applyReplacements(target, viewText, [{ oldText: String(params.oldText), newText: nextText }]).updated
       : nextText;
+
     const { updated } = applyViewReplace(target, content, params.viewStart, params.viewEnd, viewText, windowNext);
     const diffFrom = isString(params.oldText) ? String(params.oldText) : viewText;
     const diff = shiftDiffLines(buildEditDiff(target, viewText, diffFrom, isString(params.oldText) ? nextText : windowNext), params.viewStart - 1);
@@ -172,6 +224,7 @@ export function createEdit(ctx) {
 
   function diffForMatches(target, content, updated, matches) {
     if (content.length > 512 * 1024 || updated.length > 512 * 1024) return boundedEditDiff(target, content, matches);
+
     if (matches.length === 1) return buildEditDiff(target, content, matches[0].oldText, matches[0].newText);
 
     return buildMultiEditDiff(target, content, matches);
@@ -179,10 +232,10 @@ export function createEdit(ctx) {
 
   async function edit(params, signal) {
       const cwd = getCwd();
-      const target = await resolveWorkspacePath(cwd, params?.path, "edit", false);
+      const target = await editTargetPath(cwd, params?.path, "edit");
 
       if (signal?.aborted) throw new Error("aborted");
-      const content = await vfs.read(target, { maxBytes: 64 * 1024 * 1024 });
+      const content = await vfs.read(target, { maxBytes: 64 * 1024 * 1024, forWrite: true });
 
       if (isNumber(params?.viewStart) && isNumber(params?.viewEnd) && isString(params?.viewText) && isString(params?.newText)) {
         return applyViewEdit(cwd, target, content, params, signal);
@@ -210,7 +263,7 @@ export function createEdit(ctx) {
 
   async function readPatchOriginal(target) {
     try {
-      return await vfs.read(target, { maxBytes: 64 * 1024 * 1024, preserveRead: true });
+      return await vfs.read(target, { maxBytes: 64 * 1024 * 1024, forWrite: true });
     } catch (error) {
       if (error?.code !== "ENOENT") throw error;
 
@@ -220,7 +273,7 @@ export function createEdit(ctx) {
 
   async function apply_patch(params, signal) {
       const cwd = getCwd();
-      const target = await resolveWorkspacePath(cwd, patchInputPath(params), "apply_patch", false);
+      const target = await editTargetPath(cwd, patchInputPath(params), "apply_patch");
 
       if (!isString(params?.patch) || !params.patch.trim()) {
         throw new Error("apply_patch requires patch");
@@ -228,6 +281,7 @@ export function createEdit(ctx) {
 
       if (signal?.aborted) throw new Error("aborted");
       const original = await readPatchOriginal(target);
+
       if (original.length > 2 * 1024 * 1024) throw new Error("apply_patch input exceeds 2 MiB; use edit() for targeted replacements");
       const { resultText, hunkCount, relocations } = applyPatchToText(original, params.patch);
       const { speculative } = await vfs.write(target, resultText);

package/src/adapters/errors.js

@@ -1,8 +1,11 @@
 export const IMAGE_MAX_BYTES = 20 * 1024 * 1024;
+
 export const LARGE_FILE_BYTES = 512 * 1024;
+
 export const TEXT_MAX_BYTES = 64 * 1024 * 1024;
 
 export const ABOUT_TOKEN_MAX = 16;
+
 export const IMAGE_MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -19,5 +22,6 @@ export function imageTooLarge(rel, size) {
 export function missingFile(targetPath) {
   const error = new Error("no such file: " + targetPath + " (locate it with read using a directory path or source question; use Promise.allSettled for optional reads to retain successful siblings)");
   error.code = "ENOENT";
+
   return error;
 }

package/src/adapters/index.js

@@ -14,6 +14,7 @@ export function createNativeAdapters(getCwd, vfs, config, index, ledger, hooks)
   const bash = createBash(ctx);
   const list = createList(ctx);
   hooks.summarizeEdit = edit.editSummary;
+
   return {
     read: read.read,
     write: write.write,

package/src/adapters/list.js

@@ -48,7 +48,7 @@ export function createList(ctx) {
     if (signal?.aborted) throw new Error("aborted");
     const searchDir = await resolveListDir(op, params, cwd);
     const globPattern = globPatternOf(op, params);
-    const pending = vfs.getOverlayPaths();
+    const pending = await vfs.getOverlayPaths(searchDir);
     const cached = await listFromCache(searchDir, cwd, globPattern, pending);
 
     if (cached !== null) return cached;
@@ -72,9 +72,10 @@ export function createList(ctx) {
 
       if (!pattern) throw new Error("grep requires pattern");
       const searchPath = params?.path ? await resolveWorkspacePath(cwd, params.path, "grep", true) : cwd;
-      const indexed = await grepIndexed(index, pattern, params, searchPath, cwd, file => vfs.getOverlay(file), vfs.getOverlayPaths());
+      const indexed = await grepIndexed(index, pattern, params, searchPath, cwd, file => vfs.getOverlay(file), await vfs.getOverlayPaths(searchPath));
 
       if (indexed !== null) return textResult(indexed, { exitCode: indexed ? 0 : 1, via: "index" });
+
       // Large tree: real rg keeps its own output format.
       return grepWithRg(pattern, params, searchPath, cwd, signal);
   }
@@ -82,13 +83,15 @@ export function createList(ctx) {
   async function glob(params, signal) {
     return listFiles(params, signal, "glob", getCwd());
   }
+
   async function find(params, signal) {
     return listFiles(params, signal, "find", getCwd());
   }
+
   async function ls(params, signal) {
       const cwd = getCwd();
       const dirPath = params?.path ? await resolveWorkspacePath(cwd, params.path, "ls", true) : cwd;
-      const pending = vfs.getOverlay(dirPath);
+      const pending = await vfs.getOverlay(dirPath);
 
       if (pending !== undefined) return fileListing(dirPath, Buffer.byteLength(pending, "utf8"));
       const stat = await fs.stat(dirPath).catch(() => null);

package/src/adapters/read-focus.js

@@ -4,6 +4,7 @@ import {tokenizeQuery,stem} from '../context/snap.js';
 import {runCommand} from '../fs/workspace.js';
 import {lineStartIndex,lineTextRange} from '../fs/lines.js';
 import {textResult} from '../shared/result.js';
+
 export function createFocusedReader(vfs, readBudget) {
   function aboutStems(about, requireStem) {
     const tokens = tokenizeQuery(about).tokens;
@@ -29,6 +30,7 @@ export function createFocusedReader(vfs, readBudget) {
 
       if (stems.some(st => row.includes(st))) {
         hits.push(line);
+
         if (hits.length >= 200) break;
       }
 
@@ -53,6 +55,7 @@ export function createFocusedReader(vfs, readBudget) {
       const body = overlay.slice(first, last);
 
       if (used + body.length > budget) { truncated = true; break; }
+
       if (out.length && from > cursor) out.push("...");
       out.push(`// ${rel}:${from}\n${body}`);
       used += body.length;
@@ -71,7 +74,9 @@ export function createFocusedReader(vfs, readBudget) {
     const res = await runCommand(args, { cwd: path.dirname(targetPath), timeoutMs: 15000, maxOutputChars: budget, signal });
 
     if (res.exitCode === 0 || res.exitCode === 1) await vfs.recordExpected(targetPath, observed);
+
     if (res.exitCode === 1) return textResult("// " + rel + " · no matching text\n", { path: targetPath, outputTruncated: false, complete: false });
+
     if (res.exitCode !== 0) throw new Error(res.stderr.trim() || `rg exited ${res.exitCode}`);
     const marker = res.outputTruncated ? "\n[focused read truncated; narrow about or use read(path, line, count)]" : "";
 
@@ -94,5 +99,6 @@ export function createFocusedReader(vfs, readBudget) {
 
     return textResult("// " + rel + " · focused staged text windows (not a complete file)\n" + out.join("\n") + marker, { path: targetPath, outputTruncated: truncated, complete: false });
   }
+
   return focusAbout;
 }

package/src/adapters/read-image.js

@@ -2,10 +2,12 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import {assertModelImageMime} from '../shared/decode.js';
 import {validateImageBytes} from '../shared/image.js';
+import {readLimitedBytes} from '../fs/file-io.js';
 import {IMAGE_MIME,IMAGE_MAX_BYTES,imageTooLarge,missingFile} from './errors.js';
+
 export function createImageReader(vfs) {
-  async function readImage(rel, targetPath, mime, signal) {
-    const staged = vfs.getOverlay(targetPath);
+  async function readImage(rel, targetPath, signal) {
+    const staged = await vfs.getOverlay(targetPath);
 
     if (staged !== undefined) {
       const size = Buffer.byteLength(staged, "utf8");
@@ -23,16 +25,22 @@ export function createImageReader(vfs) {
       throw error;
     }
 
+    let stat, bytes;
+
     try {
-      const stat = await file.stat();
+      stat = await file.stat();
 
       if (!stat.isFile()) throw new Error("image read requires a regular file: " + targetPath);
-      if (stat.size > IMAGE_MAX_BYTES) throw imageTooLarge(rel, stat.size);
-      const bytes = await file.readFile({ signal });
-      await vfs.recordExpected(targetPath, stat);
 
-      return bytes;
+      if (stat.size > IMAGE_MAX_BYTES) throw imageTooLarge(rel, stat.size);
+      bytes = await readLimitedBytes(file, stat, IMAGE_MAX_BYTES, "image", signal,
+        () => new Error("image read limit exceeded: " + rel + "; maximum " + IMAGE_MAX_BYTES + " bytes (20 MiB); resize or select fewer/smaller images"));
     } finally { await file.close(); }
+
+    // Recovery must be able to replace the destination before we await it.
+    await vfs.recordExpected(targetPath, stat, bytes);
+
+    return bytes;
   }
 
   async function maybeImage(rel, targetPath, signal) {
@@ -40,12 +48,12 @@ export function createImageReader(vfs) {
 
     if (!mime) return null;
     assertModelImageMime(mime);
-    const bytes = await readImage(rel, targetPath, mime, signal);
+    const bytes = await readImage(rel, targetPath, signal);
 
-    if (bytes.length > IMAGE_MAX_BYTES) throw imageTooLarge(rel, bytes.length);
     await validateImageBytes(bytes,mime,rel,signal);
 
     return { content: [{ type: "image", mimeType: mime, data: bytes.toString("base64") }], details: { path: targetPath } };
   }
+
   return maybeImage;
 }