pi-supernova 0.5.0 → 0.7.0

package/index.js

@@ -25,6 +25,7 @@ try {
     Array: (items, opts) => ({ type: "array", items, ...opts }),
     Integer: (opts) => ({ type: "integer", ...opts }),
     Optional: (s) => ({ ...s }),
+    Boolean: (opts) => ({ type: "boolean", ...opts }),
   };
 }
 
@@ -67,7 +68,10 @@ export function progressEmitter(onUpdate) {
     const wait = PROGRESS_FRAME_MS - (performance.now() - lastSent);
 
     if (wait <= 0) send();
-    else timer = setTimeout(send, wait);
+    else {
+      timer = setTimeout(send, wait);
+      timer.unref?.();
+    }
   };
 
   emit.flush = () => {
@@ -124,8 +128,10 @@ error: ${outcome.error}${logsBlock(outcome)}`;
 function successText(outcome, call) {
   const truncated = outcome.returnTruncated ? " [return truncated]" : "";
   const hint = outcome.undefinedReturn ? " (no return statement; add `return` to get a value)" : "";
+  const m = outcome.mutations;
+  const showMutations = m && (m.committed || m.rolledBack || m.external || m.pendingCommits || m.recoveryFailed) ? mutationText(outcome) : "";
 
-  return `ok #${call} ${outcome.wallMs}ms${truncated}${outcome.mutations?.committed || outcome.mutations?.rolledBack || outcome.mutations?.external ? mutationText(outcome) : ""}${splitTurnHint(outcome)}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
+  return `ok #${call} ${outcome.wallMs}ms${truncated}${showMutations}${splitTurnHint(outcome)}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
 }
 
 function fitOutput(outcome, call, limit, format) {
@@ -197,12 +203,119 @@ export function registerCodeMode(pi) {
       speculateCommit: () => runBridge.barrier(() => runBridge.commitSpeculation()),
       speculateRollback: () => runBridge.barrier(() => runBridge.rollbackSpeculation()),
       names: () => ["read", "edit", "write", "bash"],
+      describeMemory: () => runBridge.describeMemory?.() ?? null,
       batchRead: runBridge.supportsBatchRead(),
       nativeArgv: runBridge.supportsNativeArgv?.() === true,
       cancel,
     };
   }
 
+  function rejectLoneParallel(params) {
+    if (params?.parallel !== undefined) throw new Error("parallel applies to the programs array; no commands ran");
+  }
+
+  function bindRunSignal(signal) {
+    const runController = new AbortController();
+    const abortRun = () => runController.abort(signal?.reason);
+
+    if (signal?.aborted) abortRun();
+    else signal?.addEventListener("abort", abortRun, { once: true });
+
+    return { runController, abortRun };
+  }
+
+  function openRunBridge(ctx, runCwd, budget, runController) {
+    const runBridge = bridge.fork({ getCwd: () => runCwd, budget });
+    runBridge.bindCallContext(ctx, runController.signal);
+    runBridge.resetCallBudget();
+
+    return runBridge;
+  }
+
+  async function runAndCommit(params, runCwd, runBridge, abortRun, runController, budget) {
+    refreshCatalog(runBridge);
+    runBridge.beginSpeculation();
+    const 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) },
+      signal: runController.signal,
+      onTimeout: abortRun,
+    });
+    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();
+    }
+    else while (runBridge.getOverlayDepth()) runBridge.rollbackSpeculation();
+
+    return outcome;
+  }
+
+  function scheduleWarm(runController) {
+    cancelWarmTimer();
+
+    if (!stopped && !runController.signal.aborted) {
+      // Deliver the result before paying for another Worker constructor.
+      warmTimer = setImmediate(() => {
+        warmTimer = undefined;
+
+        if (!stopped && !runController.signal.aborted) warmGuestWorker(config).catch(() => {});
+      });
+      warmTimer.unref?.();
+    }
+  }
+
+  function finishRun(runBridge, emitProgress, signal, abortRun, runController) {
+    runBridge.setCallListener(null);
+    emitProgress.flush();
+    signal?.removeEventListener("abort", abortRun);
+    // Prepare one pristine worker during the model's next decision. Never
+    // recycle a worker that has executed arbitrary guest JavaScript.
+    scheduleWarm(runController);
+  }
+
+  function attachReceipts(outcome, trace) {
+    if (outcome.ok && outcome.result === undefined) {
+      const receipts = mutationReceipts(trace);
+
+      if (receipts) {
+        outcome.resultText = receipts;
+        outcome.undefinedReturn = false;
+      }
+    }
+  }
+
+  function throwIfFailed(outcome, visible, response) {
+    if (outcome.ok) return response;
+    const error = new Error(visible);
+    Object.defineProperty(error,"supernovaResult",{value:response});
+    throw error;
+  }
+
+  function packExecuteResult(outcome, call, runBridge, budget, runOpts, peakSeen) {
+    if (budget) budget.logLines += outcome.logs?.length ?? 0;
+    outcome.overlappedTurn = !runOpts?.parallel && peakSeen > 1 ? peakSeen : 0;
+    outcome.mutations = runBridge.getMutations();
+    const trace = runBridge.getTrace();
+    attachReceipts(outcome, trace);
+    const bounded = fitOutput(outcome, call, config.maxReturnChars, outcome.ok ? successText : errorText);
+    const visible = runBridge.ledger.dedupe(bounded, call);
+    const response = result(visible, {
+      ok: outcome.ok, error: outcome.error, wallMs: outcome.wallMs,
+      returnTruncated: outcome.returnTruncated, logTruncated: outcome.logTruncated,
+      logs: outcome.logs, result: outcome.result, trace, mutations: outcome.mutations,
+    });
+
+    if (outcome.images?.length) response.content.push(...outcome.images);
+
+    return throwIfFailed(outcome, visible, response);
+  }
+
   pi.registerTool({
     name: "supernova",
     label: "Supernova",
@@ -218,6 +331,7 @@ export function registerCodeMode(pi) {
         file: Type.Optional(Type.String({ minLength: 1 })),
         data: Type.Optional(Type.Unknown()),
       }, {additionalProperties:false}), {minItems:1,maxItems:32})),
+      parallel: Type.Optional(Type.Boolean()),
     }),
     // One self-owned result frame is shared by Pi and OMP; renderCall stays empty
     // so separate call/result slots cannot duplicate the lifecycle card.
@@ -225,50 +339,26 @@ export function registerCodeMode(pi) {
     mergeCallAndResult: true,
     renderCall: renderSupernovaCall,
     renderResult: renderSupernovaResult,
-    execute: async function execute(_id, params, signal, onUpdate, ctx, budget) {
+    execute: async function execute(_id, params, signal, onUpdate, ctx, budget, runOpts) {
       if (params?.programs !== undefined) return runProgramBatch(_id,params,signal,onUpdate,ctx,config,execute);
+      rejectLoneParallel(params);
       cancelWarmTimer();
-      const runCwd = ctx?.cwd || cwd;
-      const runController = new AbortController();
-      const abortRun = () => runController.abort(signal?.reason);
-
-      if (signal?.aborted) abortRun();
-      else signal?.addEventListener("abort", abortRun, { once: true });
-      const runBridge = bridge.fork({ getCwd: () => runCwd, budget });
-      runBridge.bindCallContext(ctx, runController.signal);
-      runBridge.resetCallBudget();
-
+      const runCwd = isString(ctx?.cwd) && ctx.cwd ? ctx.cwd : cwd;
+      const { runController, abortRun } = bindRunSignal(signal);
+      const runBridge = openRunBridge(ctx, runCwd, budget, runController);
       const call = ++programSeq;
       runBridge.ledger.beginProgram(call);
       const emitProgress = progressEmitter(onUpdate);
       runBridge.setCallListener((_record, trace) => emitProgress(trace));
       emitProgress([]);
       const started = performance.now();
-      let outcome;
       inFlight += 1;
       overlapPeak = Math.max(overlapPeak, inFlight);
       let peakSeen = overlapPeak;
+      let outcome;
 
       try {
-        refreshCatalog(runBridge);
-        runBridge.beginSpeculation();
-        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: Number.isInteger(params?.timeoutMs) ? params.timeoutMs : config.timeoutMs },
-          signal: runController.signal,
-          onTimeout: abortRun,
-        });
-        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();
-        }
-        else while (runBridge.getOverlayDepth()) runBridge.rollbackSpeculation();
+        outcome = await runAndCommit(params, runCwd, runBridge, abortRun, runController, budget);
       } catch (error) {
         abortRun();
         runBridge.close();
@@ -279,56 +369,10 @@ export function registerCodeMode(pi) {
         peakSeen = Math.max(peakSeen, overlapPeak);
         inFlight -= 1;
         if (inFlight === 0) overlapPeak = 0;
-        runBridge.setCallListener(null);
-        emitProgress.flush();
-        signal?.removeEventListener("abort", abortRun);
-        // Prepare one pristine worker during the model's next decision. Never
-        // recycle a worker that has executed arbitrary guest JavaScript.
-        cancelWarmTimer();
-
-        if (!stopped && !runController.signal.aborted) {
-          // Deliver the result before paying for another Worker constructor.
-          warmTimer = setImmediate(() => {
-            warmTimer = undefined;
-
-            if (!stopped && !runController.signal.aborted) warmGuestWorker(config).catch(() => {});
-          });
-          warmTimer.unref?.();
-        }
-      }
-
-      if (budget) budget.logLines += outcome.logs?.length ?? 0;
-      outcome.overlappedTurn = peakSeen > 1 ? peakSeen : 0;
-      outcome.mutations = runBridge.getMutations();
-      const trace = runBridge.getTrace();
-
-      if (outcome.ok && outcome.result === undefined) {
-        const receipts = mutationReceipts(trace);
-
-        if (receipts) {
-          outcome.resultText = receipts;
-          outcome.undefinedReturn = false;
-        }
-      }
-      const format = outcome.ok ? successText : errorText;
-      const bounded = fitOutput(outcome, call, config.maxReturnChars, format);
-      const visible = runBridge.ledger.dedupe(bounded, call);
-
-      const response = result(visible, {
-        ok: outcome.ok, error: outcome.error, wallMs: outcome.wallMs,
-        returnTruncated: outcome.returnTruncated, logTruncated: outcome.logTruncated,
-        logs: outcome.logs, result: outcome.result, trace, mutations: outcome.mutations,
-      });
-
-      if (outcome.images?.length) response.content.push(...outcome.images);
-
-      if (!outcome.ok) {
-        const error = new Error(visible);
-        Object.defineProperty(error,"supernovaResult",{value:response});
-        throw error;
+        finishRun(runBridge, emitProgress, signal, abortRun, runController);
       }
 
-      return response;
+      return packExecuteResult(outcome, call, runBridge, budget, runOpts, peakSeen);
     },
   });
 
@@ -347,7 +391,7 @@ export function registerCodeMode(pi) {
   pi.on("session_start", (_event, ctx) => {
     stopped = false;
 
-    if (ctx && isString(ctx.cwd) && ctx.cwd) cwd = ctx.cwd;
+    cwd = ctx && isString(ctx.cwd) && ctx.cwd ? ctx.cwd : process.cwd();
     // A new session is a new model context: nothing has been seen yet.
     bridge.bindCallContext(ctx);
     bridge.ledger.reset();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-supernova",
-  "version": "0.5.0",
-  "description": "One CodeMode invocation for Pi and OMP, with four guest commands, automatic read batching and source context.",
+  "version": "0.7.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",
   "license": "MIT",

package/src/adapters/bash.js

@@ -0,0 +1,73 @@
+import { isString } from "../shared/decode.js";
+import { unwrapIfFullyQuoted } from "../fs/text-ops.js";
+import { sourceForReferences } from "../fs/source-window.js";
+import { resolveWorkspacePath, runCommand, clearPathCache } from "../fs/workspace.js";
+
+export function createBash(ctx) {
+  const { getCwd, vfs, config, index, ledger, hooks } = ctx;
+  function combineBashText(stdout, stderr) {
+    return stdout && stderr ? stdout + (stdout.endsWith("\n") ? "" : "\n") + stderr : stdout || stderr;
+  }
+
+  function isLiteralArgv(params) {
+    return Array.isArray(params?.args) && process.platform !== "win32" && params.args.length === Object.keys(params.args).length && params.args.every(isString);
+  }
+
+  function bashCommand(params, literal) {
+    if (params?.command !== undefined && !isString(params.command)) throw new Error("bash command must be a string");
+    if (literal && (!isString(params.command) || params.args.some(arg => !isString(arg)))) throw new Error("bash argv requires a command string and an array of string args");
+    const command = literal ? String(params.command) : unwrapIfFullyQuoted(String(params?.command ?? "").trim());
+
+    if (!command.trim()) throw new Error("bash requires command");
+
+    return command;
+  }
+
+  function parseBash(params) {
+    const literal = isLiteralArgv(params);
+    const command = bashCommand(params, literal);
+
+    return { literal, command, argv: literal ? [command, ...params.args] : ["bash", "-c", command] };
+  }
+
+  async function bash(params, signal) {
+      const cwd = getCwd();
+      const { literal, command, argv } = parseBash(params);
+      const targetCwd = params?.cwd ? await resolveWorkspacePath(cwd, params.cwd, "bash cwd", true) : cwd;
+
+      const transactionBarrier = await vfs.prepareExternalMutation("bash");
+      let res;
+
+      try {
+        res = await runCommand(argv, {
+          cwd: targetCwd,
+          env: hooks.commandEnv(),
+          commandLabel: literal ? command : undefined,
+          timeoutMs: params?.timeoutMs,
+          signal,
+          maxOutputChars: config.maxCallResultChars,
+        });
+      } catch (error) {
+        if (!signal?.aborted) error.message += await sourceForReferences(cwd, targetCwd, error.message, signal, ledger);
+        throw error;
+      } finally {
+        vfs.invalidateObserved();
+        index.invalidate();
+        clearPathCache();
+        hooks.workspaceChanged();
+      }
+
+      const { stdout, stderr } = res;
+      let text = combineBashText(stdout, stderr);
+
+      if (res.exitCode !== 0) 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,
+      };
+  }
+
+  return { bash };
+}

package/src/adapters/edit.js

@@ -0,0 +1,249 @@
+import * as path from "node:path";
+import { isString, isNumber } from "../shared/decode.js";
+import { buildEditDiff, buildMultiEditDiff, buildPatchDiff, MAX_DIFF_MATCHES } from "../fs/diff.js";
+import { declaredName, WorkspaceIndex } from "../context/repo-index.js";
+import { quickCheck } from "../fs/check.js";
+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,
+} 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$/, "");
+  }
+
+  function spanEditRange(span, lineCount) {
+    if (!span || !Number.isInteger(span.start) || !Number.isInteger(span.end) || span.start < 1 || span.end < span.start) return null;
+    const end = Math.min(lineCount, span.end);
+
+    return span.start <= end ? [{ start: span.start, end }] : [];
+  }
+
+  function mergeEditRange(ranges, line, lineCount) {
+    const start = Math.max(1, line - 2), end = Math.min(lineCount, line + 2);
+
+    if (ranges.length && start <= ranges.at(-1).end + 1) ranges.at(-1).end = Math.max(ranges.at(-1).end, end);
+    else ranges.push({ start, end });
+  }
+
+  function collectEditRanges(span, diff, lineCount) {
+    const explicit = spanEditRange(span, lineCount);
+
+    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);
+
+    for (const line of positions) mergeEditRange(ranges, line, lineCount);
+
+    return ranges;
+  }
+
+  function formatEditBlocks(rel, updated, newLines, ranges) {
+    const perRange = Math.max(1, Math.floor(40 / Math.max(1, ranges.length)));
+    const blocks = [];
+
+    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));
+      ledger.recordOrigin(rel, start, lines);
+      blocks.push("edited " + rel + ":" + start + "-" + last + "\n" + lines.map((line, i) => String(start + i).padStart(5) + " " + line).join("\n"));
+
+      if (last < end) blocks.push("[continue with read({path:" + JSON.stringify(rel) + ",offset:" + (last + 1) + ",limit:" + (end - last) + "})]");
+    }
+
+    return blocks.join("\n");
+  }
+
+  async function editSummary(cwd, target, original, updated, diff, signal, span) {
+    const rel = relativeSlash(cwd, target);
+    const newLines = updated.length <= 512 * 1024 ? updated.split("\n") : null;
+    const lineCount = newLines ? newLines.length : contentLineInfo(updated).count;
+    let out = formatEditBlocks(rel, updated, newLines, collectEditRanges(span, diff, lineCount));
+
+    if (diff?.omittedMatches) out += `\n…${diff.omittedMatches} more matches (receipt shows the first ${MAX_DIFF_MATCHES})`;
+    const check = updated.length <= QUICK_CHECK_MAX_CHARS ? quickCheck(updated, path.extname(target)) : null;
+
+    if (check && !check.ok) out += `\ncheck: ${check.message}`;
+    const refs = await changedDeclarationRefs(cwd, target, original, updated, diff, signal);
+
+    if (refs) out += `\n${refs}`;
+
+    return out;
+  }
+
+  function lineText(text, lines, number) {
+    if (lines) return lines[number - 1] ?? "";
+    const { start, end } = lineTextRange(text, number);
+
+    return text.slice(start, end).replace(/\r?\n$/, "");
+  }
+
+  function nameAtDiffLine(l, original, updated, oldLines, newLines, 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));
+
+    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;
+  }
+
+  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 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);
+
+      if (name) names.add(name);
+      if (names.size >= 3) break;
+    }
+
+    return names;
+  }
+
+  function formatNameRefs(references, incomplete) {
+    const parts = [];
+
+    for (const [name, refs] of references) {
+      if (refs.length) parts.push(name + " also referenced in " + refs.slice(0, 6).join(", ") + (refs.length > 6 ? " (more matches)" : ""));
+    }
+
+    if (incomplete) parts.push("references incomplete: search budget reached");
+
+    return parts.join("\n");
+  }
+
+  async function changedDeclarationRefs(cwd, target, original, updated, diff, signal) {
+    const names = collectChangedNames(target, original, updated, diff);
+
+    if (names.size === 0) return "";
+
+    try {
+      const { references, incomplete } = await referencesForNames({ root: cwd, names: [...names].slice(0, 3),
+        excludePath: target, overlayText: file => vfs.getOverlay(file), pendingPaths: vfs.getOverlayPaths(), signal });
+
+      return formatNameRefs(references, incomplete);
+    } catch (error) {
+      signal?.throwIfAborted();
+
+      return "references unavailable: " + error.message;
+    }
+  }
+
+  async function commitEdit(cwd, target, original, updated, diff, signal, span) {
+    const { speculative } = await vfs.write(target, updated);
+    index.touch(relativeSlash(cwd, target));
+    const summary = await editSummary(cwd, target, original, updated, diff, signal, span);
+
+    return textResult(summary, { path: target, speculative, diff });
+  }
+
+  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);
+    const spanEnd = params.viewStart + Math.max(sourceLines(windowNext).length, 1) - 1;
+
+    return commitEdit(cwd, target, content, updated, diff, signal, { start: params.viewStart, end: spanEnd });
+  }
+
+  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);
+  }
+
+  async function edit(params, signal) {
+      const cwd = getCwd();
+      const target = await resolveWorkspacePath(cwd, params?.path, "edit", false);
+
+      if (signal?.aborted) throw new Error("aborted");
+      const content = await vfs.read(target, { maxBytes: 64 * 1024 * 1024 });
+
+      if (isNumber(params?.viewStart) && isNumber(params?.viewEnd) && isString(params?.viewText) && isString(params?.newText)) {
+        return applyViewEdit(cwd, target, content, params, signal);
+      }
+
+      const requestedEdits = Array.isArray(params?.edits) ? params.edits : [{ oldText: params?.oldText, newText: params?.newText }];
+      const { updated, matches } = applyReplacements(target, content, requestedEdits);
+
+      return commitEdit(cwd, target, content, updated, diffForMatches(target, content, updated, matches), signal);
+  }
+
+  function patchInputPath(params) {
+    let inputPath = params?.path;
+
+    if (!inputPath && isString(params?.patch)) {
+      for (const match of params.patch.matchAll(/^(?:---|\+\+\+)\s+([^\t\n]+)/gm)) {
+        const candidate = match[1].trim().replace(/^[ab]\//, "");
+
+        if (candidate !== "/dev/null") return candidate;
+      }
+    }
+
+    return inputPath;
+  }
+
+  async function readPatchOriginal(target) {
+    try {
+      return await vfs.read(target, { maxBytes: 64 * 1024 * 1024, preserveRead: true });
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+
+      return "";
+    }
+  }
+
+  async function apply_patch(params, signal) {
+      const cwd = getCwd();
+      const target = await resolveWorkspacePath(cwd, patchInputPath(params), "apply_patch", false);
+
+      if (!isString(params?.patch) || !params.patch.trim()) {
+        throw new Error("apply_patch requires patch");
+      }
+
+      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);
+      const diff = buildPatchDiff(target, params.patch, relocations);
+      index.touch(relativeSlash(cwd, target));
+      let summary = await editSummary(cwd, target, original, resultText, diff, signal);
+
+      if (relocations.length) summary += "\nrelocated " + relocations.map(entry => "#" + entry.hunk + " " + (entry.offset > 0 ? "+" : "") + entry.offset + " lines").join(", ");
+
+      return textResult(summary, {
+        path: target,
+        hunks: hunkCount,
+        speculative,
+        diff,
+        relocated: relocations,
+      });
+  }
+
+  return { edit, apply_patch, editSummary };
+}

package/src/adapters/errors.js

@@ -0,0 +1,31 @@
+export const IMAGE_MAX_BYTES = 20 * 1024 * 1024;
+export const LARGE_FILE_BYTES = 512 * 1024;
+
+/** Raw path-only reads above these must use json/about/offset/complete. */
+export const RAW_JSON_CHARS = 4096;
+
+export const RAW_SOURCE_CHARS = 8192;
+
+export const RAW_SOURCE_LINES = 160;
+
+/** Routing responses above this fall back to the bound error instead of dumping. */
+export const ROUTING_MAX_CHARS = 4096;
+export const ABOUT_TOKEN_MAX = 16;
+export const IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+};
+
+export function imageTooLarge(rel, size) {
+  return new Error("image " + rel + " is " + size + " bytes (" + (size / 1024 / 1024).toFixed(1) + " MiB); the image read limit is " + IMAGE_MAX_BYTES + " bytes (20 MiB); resize or select fewer/smaller images");
+}
+
+export function missingFile(targetPath) {
+  const error = new Error("no such file: " + targetPath + " (locate it with read using a directory path or source question)");
+  error.code = "ENOENT";
+  return error;
+}

package/src/adapters/index.js

@@ -0,0 +1,31 @@
+import { createNativeScheduler } from "../runtime/parallel.js";
+import { createRead } from "./read.js";
+import { createWrite } from "./write.js";
+import { createEdit } from "./edit.js";
+import { createBash } from "./bash.js";
+import { createList } from "./list.js";
+
+export function createNativeAdapters(getCwd, vfs, config, index, ledger, hooks) {
+  const ctx = { getCwd, vfs, config, index, ledger, hooks, reads: createNativeScheduler() };
+  const read = createRead(ctx);
+  ctx.readDirectory = read.readDirectory;
+  const write = createWrite(ctx);
+  const edit = createEdit(ctx);
+  const bash = createBash(ctx);
+  const list = createList(ctx);
+  hooks.summarizeEdit = edit.editSummary;
+  return {
+    read: read.read,
+    write: write.write,
+    edit: edit.edit,
+    apply_patch: edit.apply_patch,
+    snap: read.snap,
+    evidence: read.evidence,
+    surface: read.surface,
+    bash: bash.bash,
+    grep: list.grep,
+    glob: list.glob,
+    find: list.find,
+    ls: list.ls,
+  };
+}