pi-supernova 0.0.11 → 0.0.15

package/fuzzy.js

@@ -0,0 +1,182 @@
+// Typo-resistant fuzzy path matching and frecency, ported from fff (dmtrKovalenko/fff)
+// to plain JS so path search stays in-process: no binary, no spawn.
+//
+// fff pieces reproduced here:
+//   - frizbee-style fuzzy match with max_typos (skipped needle chars), boundary / consecutive /
+//     capitalization bonuses, smart-case (uppercase in query ⇒ case-sensitive)
+//   - filename bonus: exact filename +40% of base, filename match +20%
+//   - frecency boost: base × frecency / 100, AI-mode decay (3-day half-life, 7-day window)
+//     plus modification-recency boosts (30s/5m/15m/1h/4h thresholds)
+//   - git-modified boost: +15% of base
+//   - distance penalty from the current (last touched) file: −1 per directory hop, floor −20
+
+const AI_DECAY = Math.LN2 / 3;            // per day
+const AI_MAX_HISTORY_DAYS = 7;
+const MAX_TIMESTAMPS_PER_FILE = 128;
+const AI_MODIFICATION_THRESHOLDS = [[16, 30], [8, 300], [4, 900], [2, 3600], [1, 14400]]; // [boost, seconds]
+
+export class Frecency {
+  constructor() {
+    this.access = new Map(); // path → number[] (epoch seconds, newest last)
+  }
+
+  record(filePath, at = Date.now() / 1000) {
+    let list = this.access.get(filePath);
+    if (!list) this.access.set(filePath, (list = []));
+    list.push(at);
+    if (list.length > MAX_TIMESTAMPS_PER_FILE) list.splice(0, list.length - MAX_TIMESTAMPS_PER_FILE);
+  }
+
+  /** Σ exp(−λ·age) over accesses in the window, plus a step boost for a recently modified file. */
+  score(filePath, mtimeSec, now = Date.now() / 1000) {
+    let total = 0;
+    const cutoff = now - AI_MAX_HISTORY_DAYS * 86400;
+    for (const t of this.access.get(filePath) || []) {
+      if (t < cutoff) continue;
+      total += Math.exp(-AI_DECAY * ((now - t) / 86400));
+    }
+    if (mtimeSec) {
+      const age = now - mtimeSec;
+      for (const [boost, seconds] of AI_MODIFICATION_THRESHOLDS) {
+        if (age <= seconds) {
+          total += boost;
+          break;
+        }
+      }
+    }
+    return total;
+  }
+}
+
+const SEPARATORS = new Set(["/", "\\", "_", "-", ".", " "]);
+
+function isBoundary(hay, i) {
+  if (i === 0) return true;
+  const prev = hay[i - 1];
+  if (SEPARATORS.has(prev)) return true;
+  const c = hay[i];
+  return c >= "A" && c <= "Z" && !(prev >= "A" && prev <= "Z");
+}
+
+/**
+ * Greedy forward match with backward tightening (fzf v1). Returns null or
+ * { score, start, end }. Score: +16 boundary, +8 consecutive, +4 case match, −1 per gap char.
+ */
+function matchOnce(needle, hay, caseSensitive) {
+  const hayCmp = caseSensitive ? hay : hay.toLowerCase();
+  const nCmp = caseSensitive ? needle : needle.toLowerCase();
+  let hi = 0;
+  let firstAt = -1;
+  for (let ni = 0; ni < nCmp.length; ni++) {
+    hi = hayCmp.indexOf(nCmp[ni], hi);
+    if (hi < 0) return null;
+    if (firstAt < 0) firstAt = hi;
+    hi++;
+  }
+  const end = hi;
+  // Tighten: walk backwards from end to find the latest possible start.
+  let start = end;
+  for (let ni = nCmp.length - 1; ni >= 0; ni--) {
+    start = hayCmp.lastIndexOf(nCmp[ni], start - 1);
+  }
+  return { score: scoreAlignment(needle, nCmp, hay, hayCmp, start), start, end };
+}
+
+/** +16 boundary, +8 consecutive, +4 exact-case, −1 per skipped haystack char. */
+function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
+  let score = 0;
+  let prev = -2;
+  let cursor = start;
+  for (let ni = 0; ni < nCmp.length; ni++) {
+    const at = hayCmp.indexOf(nCmp[ni], cursor);
+    score += isBoundary(hay, at) ? 16 : 0;
+    score += at === prev + 1 ? 8 : 0;
+    score += hay[at] === needle[ni] ? 4 : 0;
+    score -= prev >= 0 ? at - prev - 1 : 0;
+    prev = at;
+    cursor = at + 1;
+  }
+  return score;
+}
+
+/** Best match allowing up to maxTypos skipped needle characters. */
+export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false } = {}) {
+  const direct = matchOnce(needle, hay, caseSensitive);
+  if (direct) return { ...direct, typos: 0, exact: hay.toLowerCase() === needle.toLowerCase() };
+  if (maxTypos <= 0 || needle.length < 3) return null;
+  let best = null;
+  for (let i = 0; i < needle.length; i++) {
+    const shorter = needle.slice(0, i) + needle.slice(i + 1);
+    const m = fuzzyMatch(shorter, hay, { maxTypos: maxTypos - 1, caseSensitive });
+    if (!m) continue;
+    const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+    if (!best || scored.score > best.score) best = scored;
+  }
+  return best;
+}
+
+export function smartCase(query) {
+  return /[A-Z]/.test(query);
+}
+
+/** fff distance penalty: directory hops from the current file's directory, floor −20. */
+function distancePenalty(currentDir, candidateDir) {
+  if (!currentDir) return 0;
+  const a = currentDir.split("/").filter(Boolean);
+  const b = candidateDir.split("/").filter(Boolean);
+  let common = 0;
+  while (common < a.length && common < b.length && a[common] === b[common]) common++;
+  const depth = a.length - common;
+  return Math.max(-20, -depth);
+}
+
+/**
+ * Rank file paths for a query the fff way. paths are workspace-relative "/"-joined.
+ * ctx: { frecency: Frecency, mtimeOf: (path) => sec, modified: Set(path), currentFile?: string, maxTypos }
+ */
+export function rankPaths(query, paths, ctx = {}) {
+  const parts = query.trim().split(/\s+/).filter((p) => p.length >= 2);
+  if (parts.length === 0) return [];
+  const caseSensitive = smartCase(query);
+  const maxTypos = ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
+  const currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
+  const out = [];
+  for (const rel of paths) {
+    const matched = matchParts(parts, rel, maxTypos, caseSensitive);
+    if (!matched) continue;
+    const { base, first, exact } = matched;
+    const filenameStart = rel.lastIndexOf("/") + 1;
+    const boosts = filenameBonus(base, rel, filenameStart, first, parts[0]) + contextBoost(base, rel, ctx) + distancePenalty(currentDir, rel.slice(0, filenameStart));
+    out.push({ path: rel, score: base + boosts, exact, typos: first.typos });
+  }
+  out.sort((a, b) => b.score - a.score || a.path.length - b.path.length || a.path.localeCompare(b.path));
+  return out;
+}
+
+/** Every query part must match; later parts get at most one typo (fff narrows per part). Score is the average. */
+function matchParts(parts, rel, maxTypos, caseSensitive) {
+  let sum = 0;
+  let first = null;
+  let exact = true;
+  for (let pi = 0; pi < parts.length; pi++) {
+    const m = fuzzyMatch(parts[pi], rel, { maxTypos: pi === 0 ? maxTypos : Math.min(maxTypos, 1), caseSensitive });
+    if (!m) return null;
+    first ??= m;
+    sum += m.score;
+    exact = exact && m.exact;
+  }
+  return { base: Math.max(1, Math.round(sum / parts.length)), first, exact };
+}
+
+/** fff: exact filename +40% of base, any filename match +20%. */
+function filenameBonus(base, rel, filenameStart, first, needle) {
+  if (first.start < filenameStart) return 0;
+  return rel.slice(filenameStart).toLowerCase() === needle.toLowerCase() ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
+}
+
+/** fff: frecency boost base·f/100 and +15% for git-modified files. */
+function contextBoost(base, rel, ctx) {
+  const frecency = ctx.frecency ? ctx.frecency.score(rel, ctx.mtimeOf?.(rel)) : 0;
+  const gitBoost = ctx.modified?.has(rel) ? Math.floor((base * 15) / 100) : 0;
+  return Math.floor((base * frecency) / 100) + gitBoost;
+}

package/guest-worker.js

@@ -10,7 +10,7 @@ const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
 const compiledCache = new Map();
 const COMPILED_CACHE_MAX = 256;
 const PARAMS = [
-  "nova", "tools", "console", "parallel", "pipeline",
+  "nova", "console", "parallel", "pipeline",
   "read", "write", "edit", "patch", "surface", "snap", "evidence", "bash", "exec", "speculate",
 ];
 // V8 and JSC both place the body on the line after the synthesized header.
@@ -228,20 +228,22 @@ function buildGuestApi(available) {
         return { ok: false, committed: false, error: err instanceof Error ? err.message : String(err) };
       }
     },
-    surface: async (filePath) => unwrapJsonValue(await rpc("surface", [filePath])),
+    surface: async (filePath) => unwrapJsonValue(await rpc("call", ["surface", { path: filePath }])),
     evidence: async (query, opts) => unwrapJsonValue(await rpc("call", ["evidence", { query, ...opts }])),
-    snap: async (query, targetPath) => unwrapJsonValue(await rpc("snap", [query, targetPath])),
+    snap: async (query, targetPath) => unwrapJsonValue(await rpc("call", ["snap", { query, path: targetPath }])),
     has: (name) => availableSet.has(name),
   };
 
-  const read = async (p, offset, limit) => {
+  // read(path, offset?, limit?) or read(path, { about, offset, limit, maxChars })
+  const readArgs = (p, a, b) => (isObject(a) && !Array.isArray(a) ? { path: p, ...a } : { path: p, offset: a, limit: b });
+  const read = async (p, a, b) => {
     if (Array.isArray(p)) {
-      const res = await nova.call("read", { path: p, offset, limit });
+      const res = await nova.call("read", readArgs(p, a, b));
       if (Array.isArray(res?.items)) return res.items;
       // Captured host executor without batch support: fan out.
-      return Promise.all(p.map((item) => read(item, offset, limit)));
+      return Promise.all(p.map((item) => read(item, a, b)));
     }
-    return unwrapValue(await nova.call("read", { path: p, offset, limit }));
+    return unwrapValue(await nova.call("read", readArgs(p, a, b)));
   };
   const write = async (p, content) => unwrapValue(await nova.call("write", { path: p, content }));
   const edit = async (p, oldText, newText) => unwrapValue(await nova.call("edit", { path: p, oldText, newText }));
@@ -312,7 +314,7 @@ async function handleRun(msg) {
   const scopedConsole = makeConsole(runId, limits);
   try {
     const value = await compiled(
-      api.nova, api.nova, scopedConsole, runParallel, runPipeline,
+      api.nova, scopedConsole, runParallel, runPipeline,
       api.read, api.write, api.edit, api.patch, api.surface, api.snap, api.evidence, api.bash, api.exec, api.speculate,
     );
     if (runId !== activeRunId) return;

package/host-bridge.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) => {
@@ -115,61 +111,7 @@ 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) {
       const cwd = getCwd();
       const targetParam = params?.path ?? params?.target;
@@ -184,15 +126,11 @@ function createNativeAdapters(getCwd, vfs, config, index) {
 
       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 +146,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 {
@@ -224,6 +287,7 @@ function createNativeAdapters(getCwd, vfs, config, index) {
         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 +297,20 @@ 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();
@@ -317,6 +368,7 @@ function createNativeAdapters(getCwd, vfs, config, index) {
       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 });
+      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,7 +404,8 @@ 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 },
@@ -366,6 +419,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 +430,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 +454,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);
@@ -418,9 +476,10 @@ function createNativeAdapters(getCwd, vfs, config, index) {
 
 export function createHostBridge({ pi, config, getCwd }) {
   const index = new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
+  const ledger = new SeenLedger({ window: config.seenWindow ?? 40 });
   const vfs = new CausalVfs(() => index.invalidate());
   const executors = new Map();
-  const natives = createNativeAdapters(getCwd, vfs, config, index);
+  const natives = createNativeAdapters(getCwd, vfs, config, index, ledger);
   let callCount = 0;
   let activeCtx = null;
   let activeSignal = undefined;
@@ -465,10 +524,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 +536,6 @@ export function createHostBridge({ pi, config, getCwd }) {
     return vfs.rollback();
   }
 
-  function clearVfsCache() {
-    vfs.clear();
-  }
-
   function resultDiff(response) {
     let details = response?.details;
     if (isString(details)) {
@@ -620,15 +671,13 @@ export function createHostBridge({ pi, config, getCwd }) {
     resetCallBudget,
     getTrace,
     setCallListener,
-    hasExecutor,
     beginSpeculation,
     commitSpeculation,
     rollbackSpeculation,
-    clearVfsCache,
     getVfsCacheSize: () => vfs.getCacheSize(),
     getOverlayDepth: () => vfs.getOverlayDepth(),
     call,
     callMany,
-    isMutating: (name) => isMutatingTool(name, config),
+    ledger,
   };
 }