pi-supernova 0.0.11 → 0.1.0

package/host-bridge.js

@@ -1,7 +1,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { packageHostResult } from "./bottleneck.js";
+import { packageHostResult, hostResultFailed } from "./bottleneck.js";
 import { isString, isNumber, isFunction, isObject } from "./decode.js";
 import { isMutatingTool, runParallelWave } from "./parallel.js";
 import { unknownToolMessage } from "./catalog.js";
@@ -9,10 +9,15 @@ import { extractStructuralSurface } from "./surface.js";
 import { buildEditDiff, buildMultiEditDiff, buildPatchDiff, buildWriteDiff } from "./diff.js";
 import { executeSnap } from "./snap.js";
 import { selectEvidence } from "./evidence.js";
-import { WorkspaceIndex, globToRegExp } from "./repo-index.js";
+import { WorkspaceIndex } from "./repo-index.js";
+import { outlineFile } from "./outline.js";
+import { SeenLedger } from "./ledger.js";
+import { quickCheck } from "./check.js";
+import { declaredName } from "./repo-index.js";
 import { CausalVfs } from "./vfs.js";
 import { applyPatchToText } from "./patch.js";
-import { resolveWorkspacePath, runCommand, clearPathCache } from "./workspace.js";
+import { resolveWorkspacePath, runCommand, clearPathCache, relativeSlash } from "./workspace.js";
+import { fuzzyFind, grepIndexed, listIndexed, listWithTools, rgGrepArgs } from "./search.js";
 
 function textResult(text, details) {
   return {
@@ -63,15 +68,6 @@ async function probeExistingFile(cwd, targetParam, vfs) {
   }
 }
 
-function patchModeOf(params) {
-  return (
-    isString(params?.patch) ||
-    (params?.newText === undefined &&
-      isString(params?.oldText) &&
-      (params.oldText.includes("@@ -") || params.oldText.startsWith("---")))
-  );
-}
-
 function applyReplacements(target, content, requestedEdits) {
   if (requestedEdits.length === 0) throw new Error("edit requires at least one replacement");
   const matches = requestedEdits.map((replacement) => {
@@ -83,7 +79,7 @@ function applyReplacements(target, content, requestedEdits) {
     if (index < 0) {
       throw new Error(`edit target not found in ${target}: oldText must match the file byte-for-byte (read() it first; check whitespace and quotes)`);
     }
-    if (content.indexOf(replacement.oldText, index + replacement.oldText.length) >= 0) {
+    if (content.indexOf(replacement.oldText, index + 1) >= 0) {
       throw new Error(`edit target is not unique in ${target}: include more surrounding lines in oldText, or pass edits:[{oldText,newText},…]`);
     }
     return { ...replacement, index, end: index + replacement.oldText.length };
@@ -115,84 +111,27 @@ async function formatLsEntry(dirPath, entry) {
   return `${entry.name}${isDir ? "/" : ""} (${typeLabel}${sizeSuffix})`;
 }
 
-function rgGrepArgs(pattern, params, searchPath) {
-  const args = ["--line-number", "--no-heading", "--color", "never"];
-  if (params?.caseSensitive !== true) args.push("--ignore-case");
-  if (params?.glob) args.push("--glob", String(params.glob));
-  args.push("--", pattern, searchPath);
-  return args;
-}
-
-/** rg --files, then find(1) when rg is unavailable; both accept an optional glob/name pattern. */
-async function listWithTools(searchDir, pattern, cwd, signal) {
-  const args = ["--files"];
-  if (pattern) args.push("-g", pattern);
-  const res = await runCommand(["rg", ...args, searchDir], { cwd, timeoutMs: 30_000, signal }).catch(() => null);
-  if (res && (res.exitCode === 0 || res.exitCode === 1)) return textResult(res.stdout, { via: "rg" });
-  const findArgs = [searchDir];
-  if (pattern) findArgs.push("-name", pattern);
-  const findRes = await runCommand(["find", ...findArgs], { cwd, timeoutMs: 30_000, signal });
-  return textResult(findRes.stdout, { via: "find" });
-}
-
-/** rg-compatible grep served from the index; null when the pattern or tree needs real rg. */
-async function grepIndexed(index, pattern, params, searchPath, cwd) {
-  let regex;
-  try {
-    regex = new RegExp(pattern, params?.caseSensitive === true ? "" : "i");
-  } catch {
-    return null;
-  }
-  let files = await index.files(searchPath);
-  if (!index.canScan(files)) return null;
-  if (params?.glob) {
-    const matcher = globToRegExp(String(params.glob));
-    files = files.filter((f) => matcher.test(path.relative(cwd, f).split(path.sep).join("/")));
-  }
-  const rows = index.grep(files, regex, cwd);
-  return rows.length ? rows.join("\n") + "\n" : "";
-}
-
-/** rg --files [-g pattern] served from the index; null when the tree is too large. */
-async function listIndexed(index, root, cwd, pattern) {
-  const files = await index.files(root);
-  if (!index.canScan(files)) return null;
-  const rel = files.map((f) => path.relative(cwd, f).split(path.sep).join("/"));
-  if (!pattern) return rel.length ? rel.join("\n") + "\n" : "";
-  let matcher;
-  try {
-    matcher = globToRegExp(pattern);
-  } catch {
-    return null;
-  }
-  const hits = rel.filter((f) => matcher.test(f));
-  return hits.length ? hits.join("\n") + "\n" : "";
-}
-
-function createNativeAdapters(getCwd, vfs, config, index) {
+function createNativeAdapters(getCwd, vfs, config, index, ledger) {
   async function readAdapter(params, signal) {
+      signal?.throwIfAborted();
       const cwd = getCwd();
       const targetParam = params?.path ?? params?.target;
 
       if (Array.isArray(targetParam)) {
         const results = await Promise.all(
-          targetParam.map((p) => readAdapter({ path: p, offset: params?.offset, limit: params?.limit }, signal)),
+          targetParam.map((p) => readAdapter({ ...params, path: p }, signal)),
         );
         const items = results.map((r) => r.content[0].text);
-        return textResult(items.join("\n---\n"), { count: results.length, batch: true, items });
+        return textResult("", { count: results.length, batch: true, items });
       }
 
       if (looksLikePath(targetParam)) {
         const targetPath = await resolveWorkspacePath(cwd, targetParam, "read", false);
-        const text = await vfs.read(targetPath);
-        return textResult(sliceLines(text, params?.offset, params?.limit), { path: targetPath });
+        return readFile(targetPath, params);
       }
 
       const existing = await probeExistingFile(cwd, targetParam, vfs);
-      if (existing) {
-        const text = await vfs.read(existing);
-        return textResult(sliceLines(text, params?.offset, params?.limit), { path: existing });
-      }
+      if (existing) return readFile(existing, params);
 
       if (isString(targetParam) && targetParam.trim()) {
         try {
@@ -208,8 +147,133 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       }
 
       const targetPath = await resolveWorkspacePath(cwd, targetParam, "read", false);
-      const text = await vfs.read(targetPath);
-      return textResult(sliceLines(text, params?.offset, params?.limit), { path: targetPath });
+      return readFile(targetPath, params);
+  }
+
+  /** Plain text, a line window, or (with `about`) a relevance-folded outline of the whole file. */
+  async function readFile(targetPath, params) {
+    const cwd = getCwd();
+    const rel = relativeSlash(cwd, targetPath);
+    const text = await vfs.read(targetPath);
+    index.touch(rel);
+    if (isString(params?.about)) {
+      const pending = vfs.getOverlay(targetPath);
+      const entry = pending === undefined ? index.entry(targetPath) : WorkspaceIndex.fromText(targetPath, pending);
+      const outline = entry && outlineFile(entry, rel, params.about, outlineOptions(params, await referenceFinder(cwd, targetPath)));
+      if (outline) {
+        recordOutlineOrigins(rel, outline.text);
+        return textResult(outline.text, { path: targetPath, outline: true, expanded: outline.expanded, declarations: outline.declarations });
+      }
+    }
+    const explicit = isNumber(params?.offset) || isNumber(params?.limit);
+    const firstLine = isNumber(params?.offset) ? Math.max(1, Math.floor(params.offset)) : 1;
+    const sliced = sliceLines(text, params?.offset, params?.limit);
+    ledger.recordOrigin(rel, firstLine, sliced.split("\n"), explicit);
+    return textResult(sliced, { path: targetPath });
+  }
+
+  /**
+   * The edit result answers the follow-ups a model would otherwise spend turns on: the post-edit
+   * lines with numbers (so no verification re-read), a quick structural check, and every other
+   * place a changed declaration is referenced (so callers are not forgotten).
+   */
+  async function editSummary(cwd, target, original, updated, diff) {
+    const rel = relativeSlash(cwd, target);
+    const newLines = updated.split("\n");
+    const added = diff.lines.filter((l) => l.type === "add");
+    const first = added.length ? Math.max(1, added[0].lineNum - 2) : 1;
+    const last = added.length ? Math.min(newLines.length, added[added.length - 1].lineNum + 2) : Math.min(newLines.length, first + 6);
+    const window = [];
+    for (let l = first; l <= last && window.length < 40; l++) window.push(String(l).padStart(5) + " " + newLines[l - 1]);
+    ledger.recordOrigin(rel, first, newLines.slice(first - 1, first - 1 + window.length));
+    let out = `edited ${rel}:${first}–${first + window.length - 1}\n${window.join("\n")}`;
+    const check = quickCheck(updated, path.extname(target));
+    if (check && !check.ok) out += `\ncheck: ${check.message}`;
+    const refs = await changedDeclarationRefs(cwd, target, original, updated, diff);
+    if (refs) out += `\n${refs}`;
+    return out;
+  }
+
+  async function changedDeclarationRefs(cwd, target, original, updated, diff) {
+    // Diff rows carry the replaced fragments; declarations live on whole file lines.
+    const oldLines = original.split("\n");
+    const newLines = updated.split("\n");
+    const names = new Set();
+    for (const l of diff.lines) {
+      if (l.type === "context") continue;
+      const name = declaredName((l.type === "remove" ? oldLines : newLines)[l.lineNum - 1] ?? "");
+      if (name) names.add(name);
+    }
+    if (names.size === 0) return "";
+    const find = await referenceFinder(cwd, target);
+    const parts = [];
+    for (const name of [...names].slice(0, 3)) {
+      const refs = find(name).filter((r) => !r.startsWith(relativeSlash(cwd, target) + ":"));
+      if (refs.length) parts.push(`${name} also referenced in ${refs.slice(0, 6).join(", ")}${refs.length > 6 ? " (+" + (refs.length - 6) + ")" : ""}`);
+    }
+    return parts.join("\n");
+  }
+
+  const SOURCE_REF = /((?:[\w.@-]+\/)*[\w.@-]+\.(?:m?[jt]sx?|c[jt]s|py|rs|go|java|kt|rb|php|c|cc|cpp|h|hpp|cs|swift|json|ya?ml|toml))(?::|\()(\d+)/g;
+
+  /** Source window (±2 lines, ► on the cited line) for one path:line, or null when it is outside the workspace/index. */
+  function sourceWindow(cwd, file, lineNo) {
+    const candidate = path.resolve(cwd, file);
+    if (!candidate.startsWith(path.resolve(cwd) + path.sep)) return null;
+    const entry = index.entry(candidate);
+    if (!entry) return null;
+    const { raw } = WorkspaceIndex.linesOf(entry);
+    if (lineNo < 1 || lineNo > raw.length) return null;
+    const rel = relativeSlash(cwd, candidate);
+    const start = Math.max(1, lineNo - 2);
+    const rows = [];
+    for (let l = start; l <= Math.min(raw.length, lineNo + 2); l++) rows.push((l === lineNo ? "►" : " ") + String(l).padStart(4) + " " + raw[l - 1]);
+    ledger.recordOrigin(rel, start, rows);
+    return rel + ":" + lineNo + "\n" + rows.join("\n");
+  }
+
+  /** A failing command names path:line; the model wants those lines next. Attach them (≤4 sites). */
+  function sourceForReferences(cwd, output) {
+    const seen = new Set();
+    const blocks = [];
+    for (const m of output.matchAll(SOURCE_REF)) {
+      const key = m[1] + ":" + m[2];
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const block = sourceWindow(cwd, m[1], Number(m[2]));
+      if (block) blocks.push(block);
+      if (blocks.length >= 4) break;
+    }
+    return blocks.length ? "\n--- source\n" + blocks.join("\n") : "";
+  }
+
+  function outlineOptions(params, references) {
+    const options = { references };
+    if (params?.maxChars) options.maxChars = params.maxChars;
+    return options;
+  }
+
+  /** Outline lines carry their own line numbers ("  330 text"); provenance follows them. */
+  function recordOutlineOrigins(rel, outlineText) {
+    for (const line of outlineText.split("\n")) {
+      const m = /^\s*(\d+) (.*)$/.exec(line);
+      if (m && !/ … \d+ lines$/.test(line)) ledger.recordOrigin(rel, Number(m[1]), [line]);
+    }
+  }
+
+  /** Where else a name appears (declaration line excluded), for outlines and edit results. */
+  async function referenceFinder(cwd, targetPath) {
+    const files = await index.files(cwd);
+    if (!index.canScan(files)) return () => [];
+    return (name, excludeLine) => {
+      if (!name || name.length < 3) return [];
+      const escaped = name.replace(/[$]/g, (c) => "\\" + c);
+      const regex = new RegExp("\\b" + escaped + "\\b");
+      return index
+        .grepRows(files, regex, cwd)
+        .filter((r) => !(r.line === excludeLine && r.rel === relativeSlash(cwd, targetPath)))
+        .map((r) => r.rel + ":" + r.line);
+    };
   }
 
   return {
@@ -218,12 +282,14 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const cwd = getCwd();
       const target = await resolveWorkspacePath(cwd, params?.path, "write", false);
       if (signal?.aborted) throw new Error("aborted");
-      const content = String(params?.content ?? "");
+      if (!isString(params?.content)) throw new Error("write requires string content");
+      const content = params.content;
       let prevText = "";
       try {
         prevText = await vfs.read(target);
       } catch {}
       const { speculative } = await vfs.write(target, content);
+      index.touch(relativeSlash(cwd, target));
       const diff = buildWriteDiff(target, prevText, content);
       const tag = speculative ? " (speculative)" : "";
       return textResult(`wrote ${target}${tag}`, { path: target, speculative, diff });
@@ -233,33 +299,19 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const target = await resolveWorkspacePath(cwd, params?.path, "edit", false);
       if (signal?.aborted) throw new Error("aborted");
 
-      if (patchModeOf(params)) {
-        const patchContent = params.patch || params.oldText;
-        const original = await vfs.read(target);
-        const { resultText, hunkCount } = applyPatchToText(original, patchContent);
-        const { speculative } = await vfs.write(target, resultText);
-        const diff = buildPatchDiff(target, patchContent);
-        const tag = speculative ? " (speculative)" : "";
-        return textResult(`applied ${hunkCount} hunk(s) to ${target}${tag}`, {
-          path: target,
-          hunks: hunkCount,
-          speculative,
-          diff,
-        });
-      }
-
       const requestedEdits = Array.isArray(params?.edits)
         ? params.edits
         : [{ oldText: params?.oldText, newText: params?.newText }];
       const content = await vfs.read(target);
       const { updated, matches } = applyReplacements(target, content, requestedEdits);
       const { speculative } = await vfs.write(target, updated);
+      index.touch(relativeSlash(cwd, target));
       const diff =
         matches.length === 1
           ? buildEditDiff(target, content, matches[0].oldText, matches[0].newText)
           : buildMultiEditDiff(target, content, matches);
-      const tag = speculative ? " (speculative)" : "";
-      return textResult(`edited ${target}${tag}`, { path: target, speculative, diff });
+      const summary = await editSummary(cwd, target, content, updated, diff);
+      return textResult(summary, { path: target, speculative, diff });
     },
     async apply_patch(params, signal) {
       const cwd = getCwd();
@@ -316,7 +368,8 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const options = {};
       if (Number.isInteger(params?.k) && params.k > 0) options.k = params.k;
       if (Number.isInteger(params?.maxChars) && params.maxChars > 0) options.maxChars = params.maxChars;
-      const res = await selectEvidence({ query: params.query, root: cwd, searchDir, index, overlayText: (p) => vfs.getOverlay(p), options });
+      const res = await selectEvidence({ query: params.query, root: cwd, searchDir, index, overlayText: (p) => vfs.getOverlay(p), pendingPaths: vfs.getOverlayPaths(), options });
+      for (const span of res.spans) ledger.recordOrigin(span.path, span.lines[0], span.text.split("\n"));
       return textResult(JSON.stringify(res), { route: res.route, count: res.spans.length });
     },
     async surface(params, signal) {
@@ -352,10 +405,11 @@ function createNativeAdapters(getCwd, vfs, config, index) {
         index.invalidate();
       }
       const { stdout, stderr } = res;
-      const text = stdout && stderr ? stdout + (stdout.endsWith("\n") ? "" : "\n") + stderr : stdout || stderr;
+      let text = stdout && stderr ? stdout + (stdout.endsWith("\n") ? "" : "\n") + stderr : stdout || stderr;
+      if (res.exitCode !== 0) text += sourceForReferences(cwd, text);
       return {
         content: [{ type: "text", text }],
-        details: { exitCode: res.exitCode, outputTruncated: res.outputTruncated, transactionBarrier },
+        details: { exitCode: res.exitCode, signal: res.signal, outputTruncated: res.outputTruncated, transactionBarrier },
         isError: res.exitCode !== 0,
       };
     },
@@ -366,6 +420,7 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const searchPath = params?.path ? await resolveWorkspacePath(cwd, params.path, "grep", true) : cwd;
       const indexed = await grepIndexed(index, pattern, params, searchPath, cwd);
       if (indexed !== null) return textResult(indexed, { exitCode: indexed ? 0 : 1, via: "index" });
+      // Large tree: real rg keeps its own output format.
       const res = await runCommand(["rg", ...rgGrepArgs(pattern, params, searchPath)], { cwd, timeoutMs: 30_000, signal });
       if (res.exitCode !== 0 && res.exitCode !== 1) {
         throw new Error(res.stderr.trim() || `rg exited ${res.exitCode}`);
@@ -376,6 +431,8 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const cwd = getCwd();
       const pattern = String(params?.pattern || "");
       if (!pattern) throw new Error("glob requires pattern");
+      const fuzzy = await fuzzyFind(index, cwd, cwd, pattern);
+      if (fuzzy !== null) return textResult(fuzzy, { via: "fuzzy" });
       const indexed = await listIndexed(index, cwd, cwd, pattern);
       if (indexed !== null) return textResult(indexed, { via: "index" });
       const rg = await runCommand(["rg", "--files", "-g", pattern], { cwd, timeoutMs: 30_000, signal }).catch(
@@ -398,6 +455,8 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       const pattern = params?.pattern || params?.glob;
       if (signal?.aborted) throw new Error("aborted");
       const globPattern = pattern ? String(pattern) : null;
+      const fuzzy = await fuzzyFind(index, searchDir, cwd, globPattern);
+      if (fuzzy !== null) return textResult(fuzzy, { via: "fuzzy" });
       const indexed = await listIndexed(index, searchDir, cwd, globPattern);
       if (indexed !== null) return textResult(indexed, { via: "index" });
       return listWithTools(searchDir, globPattern, cwd, signal);
@@ -416,18 +475,24 @@ function createNativeAdapters(getCwd, vfs, config, index) {
   };
 }
 
-export function createHostBridge({ pi, config, getCwd }) {
-  const index = new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
+export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedger }) {
+  const index = registry?.index ?? new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
+  const ledger = runLedger ?? new SeenLedger({ window: config.seenWindow ?? 40 });
   const vfs = new CausalVfs(() => index.invalidate());
-  const executors = new Map();
-  const natives = createNativeAdapters(getCwd, vfs, config, index);
+  const executors = registry?.executors ?? new Map();
+  const definitions = registry?.definitions ?? new Map();
+  const sharedRegistry = registry ?? { executors, definitions, index, callSeq: 0 };
+  let closed = false;
+  const natives = createNativeAdapters(getCwd, vfs, config, index, ledger);
   let callCount = 0;
   let activeCtx = null;
+  let hostSession = null;
+  let boundSessionId;
   let activeSignal = undefined;
   let trace = [];
   let callListener = null;
 
-  if (pi && isFunction(pi.registerTool)) {
+  if (!registry && pi && isFunction(pi.registerTool)) {
     const original = pi.registerTool.bind(pi);
     const excluded = new Set(config.excludeTools || []);
     pi.registerTool = (tool) => {
@@ -439,6 +504,7 @@ export function createHostBridge({ pi, config, getCwd }) {
         !excluded.has(tool.name)
       ) {
         executors.set(tool.name, tool.execute.bind(tool));
+        definitions.set(tool.name, tool);
       }
       return original(tool);
     };
@@ -446,10 +512,52 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   function bindCallContext(ctx, signal) {
     activeCtx = ctx || null;
+    const sessionId = ctx?.sessionManager?.getSessionId?.();
+    boundSessionId = sessionId;
+    const registry = pi?.pi?.AgentRegistry?.global?.();
+    hostSession = sessionId && registry?.list
+      ? registry.list().map(ref => ref.session).find(session => !session?.isDisposed && session?.sessionManager?.getSessionId?.() === sessionId) ?? null
+      : null;
     activeSignal = signal;
+    vfs.signal = signal;
+  }
+
+  function hostTool(name) {
+    if (!hostSession) return undefined;
+    const metadata = definitions.get(name);
+    // Keep Supernova's transactional adapters for ordinary built-ins. Respect overrides.
+    if (Object.hasOwn(natives, name) && metadata?.sourceInfo?.source === "builtin") return undefined;
+    return hostSession.getToolForEvalBridge?.(name);
+  }
+
+  function isCallable(name) {
+    if (name === "supernova" || (config.excludeTools ?? []).includes(name)) return false;
+    if (hostSession) {
+      if (hostSession.isDisposed || hostSession.sessionManager.getSessionId() !== boundSessionId) return false;
+      if (!hostSession.getEvalBridgeToolNames().includes(name) && definitions.has(name)) return false;
+      return !!hostTool(name) || (Object.hasOwn(natives, name) && (!definitions.has(name) || definitions.get(name).sourceInfo?.source === "builtin"));
+    }
+    if (definitions.has(name) && isFunction(pi?.getActiveTools) && !pi.getActiveTools().includes(name)) return false;
+    return executors.has(name) || Object.hasOwn(natives, name);
+  }
+
+  function refreshTools() {
+    const tools = pi?.getAllTools?.() ?? [];
+    for (const tool of tools) {
+      if (!isString(tool?.name)) continue;
+      definitions.set(tool.name, { ...definitions.get(tool.name), ...tool });
+      if (!hostSession && isFunction(tool.execute)) executors.set(tool.name, tool.execute.bind(tool));
+    }
+    return [...definitions.values()].filter(tool => isCallable(tool.name));
+  }
+
+  function externalNames() {
+    return [...definitions.keys()].filter(name => !!hostTool(name) || executors.has(name));
   }
 
   function resetCallBudget() {
+    closed = false;
+    vfs.closed = false;
     callCount = 0;
     trace = [];
     // Files may change between programs (editor, git); never serve a stale run.
@@ -465,10 +573,6 @@ export function createHostBridge({ pi, config, getCwd }) {
     callListener = isFunction(fn) ? fn : null;
   }
 
-  function hasExecutor(name) {
-    return executors.has(name) || Object.hasOwn(natives, name);
-  }
-
   function beginSpeculation() {
     return vfs.begin();
   }
@@ -481,10 +585,6 @@ export function createHostBridge({ pi, config, getCwd }) {
     return vfs.rollback();
   }
 
-  function clearVfsCache() {
-    vfs.clear();
-  }
-
   function resultDiff(response) {
     let details = response?.details;
     if (isString(details)) {
@@ -505,6 +605,7 @@ export function createHostBridge({ pi, config, getCwd }) {
   }
 
   function checkCallBudget(name) {
+    if (closed) throw new Error("program is already complete");
     const maxCalls = config.maxBridgeCalls ?? 256;
     callCount += 1;
     if (callCount > maxCalls) {
@@ -547,23 +648,35 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   async function invokeRaw(name, args) {
     checkCallBudget(name);
+    const callId = ++sharedRegistry.callSeq;
     assertCallableTarget(name);
+    if (!isCallable(name)) throw new Error(unknownToolMessage(name, [...definitions.keys(), ...Object.keys(natives)].filter(isCallable)));
 
     const record = { name, args: args || {}, time: Date.now() };
     trace.push(record);
     notifyCall(record);
 
     try {
-      const exec = executors.get(name);
+      const delegated = hostTool(name);
+      const exec = delegated ? delegated.execute.bind(delegated) : hostSession ? undefined : executors.get(name);
       if (exec) {
         const fallbackDiff = await writeFallbackDiff(name, args);
-        if (isMutatingTool(name, config)) await vfs.prepareExternalMutation(name);
-        const res = await exec(`supernova:${name}:${callCount}`, args || {}, activeSignal, undefined, activeCtx);
-        completeRecord(record, res, fallbackDiff);
-        return res;
+        const mutating = isMutatingTool(name, config, args, definitions.get(name));
+        if (mutating) await vfs.prepareExternalMutation(name);
+        if (activeSignal?.aborted || closed) throw new Error("aborted");
+        if (!isCallable(name)) throw new Error("tool is no longer enabled in this session: " + name);
+        try {
+          const res = await exec(`supernova:${name}:${callId}`, args || {}, activeSignal, undefined, delegated
+            ? { ...activeCtx, settings: hostSession.settings, toolNames: hostSession.getEvalBridgeToolNames(), autoApprove: false }
+            : activeCtx);
+          completeRecord(record, res, fallbackDiff);
+          return res;
+        } finally {
+          if (mutating) { vfs.invalidateCache(); index.invalidate(); clearPathCache(); }
+        }
       }
 
-      const native = natives[name];
+      const native = Object.hasOwn(natives, name) ? natives[name] : undefined;
       if (native) {
         const res = await native(args || {}, activeSignal);
         completeRecord(record, res);
@@ -582,7 +695,7 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   function finishRecord(record, res) {
     record.ms = Date.now() - record.time;
-    record.ok = res?.isError !== true && res?.details?.ok !== false;
+    record.ok = !hostResultFailed(res);
     const exitCode = isObject(res?.details) ? res.details.exitCode : undefined;
     if (Number.isInteger(exitCode) && exitCode !== 0) record.exitCode = exitCode;
   }
@@ -594,14 +707,16 @@ export function createHostBridge({ pi, config, getCwd }) {
   }
 
   async function callMany(calls) {
-    const list = Array.isArray(calls) ? calls : [];
+    if (!Array.isArray(calls)) throw new TypeError("nova.callMany requires an array");
+    const list = calls;
+    if (list.some(item => !isString(item?.name) || !item.name)) throw new TypeError("nova.callMany entries require a tool name");
     const thunks = list.map((item) => {
       const n = item?.name;
       const a = item?.args;
       return () => call(n, a);
     });
     const names = list.map((item) => item?.name).filter((n) => isString(n));
-    const wave = await runParallelWave(thunks, { names }, { mode: "auto", config });
+    const wave = await runParallelWave(thunks, { names, calls: list, definitions: names.map(name => definitions.get(name)) }, { mode: "auto", config });
     // Return a results array that also carries .mode/.reason, and is directly
     // iterable so `for (const r of await nova.callMany([...]))` works.
     const results = Array.isArray(wave.results) ? wave.results.slice() : [];
@@ -615,20 +730,27 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   return {
     executors,
+    definitions,
     natives,
+    refreshTools,
+    isCallable,
+    externalNames,
+    supportsBatchRead: () => !hostTool("read") && !executors.has("read"),
+    fork(options) {
+      return createHostBridge({ pi, config, getCwd: options.getCwd, registry: sharedRegistry, ledger: ledger.fork() });
+    },
+    close() { closed = true; vfs.closed = true; },
     bindCallContext,
     resetCallBudget,
     getTrace,
     setCallListener,
-    hasExecutor,
     beginSpeculation,
     commitSpeculation,
     rollbackSpeculation,
-    clearVfsCache,
     getVfsCacheSize: () => vfs.getCacheSize(),
     getOverlayDepth: () => vfs.getOverlayDepth(),
     call,
     callMany,
-    isMutating: (name) => isMutatingTool(name, config),
+    ledger,
   };
 }