pi-supernova 0.5.0 → 0.7.0

package/src/bridge/invoke.js

@@ -0,0 +1,35 @@
+import { isString } from "../shared/decode.js";
+
+/** Ordered permission rules. First decisive answer wins. */
+export function toolIsCallable(name, env) {
+  if (name === "supernova" || env.excluded.has(name)) return false;
+  if (env.sessionInvalid()) return false;
+  if (env.nativeOwned(name)) return true;
+  if (env.hostSession) return env.evalAllows(name);
+
+  return env.listed(name);
+}
+
+function isArgvOwned(name, args) {
+  return name === "bash" && Array.isArray(args?.args) && process.platform !== "win32"
+    && args.args.length === Object.keys(args.args).length && args.args.every(isString);
+}
+
+function hostExecutor(name, env) {
+  const delegated = env.hostTool(name);
+
+  if (delegated) return { exec: delegated.execute.bind(delegated), delegated };
+  if (env.hostSession) return { exec: undefined, delegated };
+
+  return { exec: env.executors.get(name), delegated };
+}
+
+export function resolveInvokeTarget(name, args, env) {
+  const argvOwned = isArgvOwned(name, args);
+  const { exec, delegated } = hostExecutor(name, env);
+
+  if (exec && !argvOwned) return { kind: "override", exec, delegated, argvOwned: false };
+  if (env.natives[name]) return { kind: "native", native: env.natives[name], argvOwned };
+
+  return { kind: "unknown" };
+}

package/src/bridge/native-tools.js

@@ -1,189 +1,2 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { homedir } from "node:os";
-import { loadConfig } from "../config/config.js";
-import { isString } from "../shared/decode.js";
-import { createHostBridge } from "./host-bridge.js";
-import { buildPatchDiff } from "../fs/diff.js";
-import { createNativeScheduler } from "../runtime/parallel.js";
-import { truncateChars } from "../output/format.js";
-import { clearPathCache, resolveWorkspacePath } from "../fs/workspace.js";
-
+/** Native command names. Host registration lives in createHostBridge. */
 export const NATIVE_NAMES = Object.freeze(["read", "edit", "write", "bash"]);
-
-function userPath(cwd, input) {
-  if (!isString(input) || !input.trim()) throw new Error("path must be a non-empty string");
-  const value = input.trim().replace(/^@/, "");
-
-  return path.resolve(cwd, value === "~" ? homedir() : value.startsWith("~/") ? path.join(homedir(), value.slice(2)) : value);
-}
-
-function boundText(result, maxChars) {
-  const total = result.content.reduce((sum, block) => sum + (block.type === "text" ? block.text.length : 0), 0);
-  const truncated = total > maxChars;
-  const notice = truncated ? truncateChars("\n[Truncated: read files individually or narrow the line range/question.]", maxChars, "read-result").text : "";
-  let remaining = maxChars - notice.length;
-
-  const content = result.content.map(block => {
-    if (block.type !== "text") return block; // Images remain image attachments.
-    const bounded = truncateChars(block.text, remaining, "read-result");
-    remaining -= bounded.text.length;
-
-    return { ...block, text: bounded.text };
-  });
-
-  if (notice) content.push({ type: "text", text: notice });
-  const details = { ...result.details };
-
-  if (truncated) details.outputTruncated = true;
-
-  return { ...result, content, details };
-}
-
-/** Familiar Pi tool definitions with Supernova's source engine and atomic VFS. */
-export function registerNativeTools(pi, host, config = loadConfig()) {
-  let cwd = process.cwd();
-  const base = createHostBridge({ pi: null, config: { ...config, seenWindow: 0 }, getCwd: () => cwd });
-  const scheduler = createNativeScheduler();
-
-  const factories = {
-    read: host.createReadToolDefinition,
-    edit: host.createEditToolDefinition,
-    write: host.createWriteToolDefinition,
-    bash: host.createBashToolDefinition,
-  };
-
-  function settingsFor(ctx) {
-    return host.SettingsManager?.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted?.() === true });
-  }
-
-  async function readOne(args, signal, ctx, bridge, id) {
-    const target = userPath(ctx.cwd, args.path);
-    let stat;
-
-    try { stat = await fs.stat(target); }
-    catch (error) { if (error.code !== "ENOENT" && error.code !== "ENOTDIR") throw error; }
-
-    signal?.throwIfAborted();
-    const image = /\.(png|jpe?g|gif|webp|bmp)$/i.test(target);
-
-    if (stat?.isFile() && (args.about === undefined || image)) {
-      // Pi retains image handling, full text, line windows, truncation metadata,
-      // and actionable continuation offsets. Do not summarize or dedupe these.
-      return factories.read(ctx.cwd, { autoResizeImages: image ? settingsFor(ctx)?.getImageAutoResize() : undefined }).execute(id, { ...args, path: target }, signal, undefined, ctx);
-    }
-
-    return boundText(await bridge.natives.read({ ...args, path: stat ? target : args.path }, signal), config.maxCallResultChars);
-  }
-
-  async function execute(name, id, args, signal, onUpdate, context) {
-    const ctx = { ...context, cwd: context?.cwd || cwd };
-    const bridge = base.fork({ getCwd: () => ctx.cwd });
-    bridge.bindCallContext(ctx, signal);
-    signal?.throwIfAborted();
-
-    try {
-      if (name === "read") {
-        if (!Array.isArray(args.path)) return await readOne(args, signal, ctx, bridge, id);
-
-        if (args.path.some(p => !isString(p) || !p.trim())) throw new Error("read paths must be non-empty strings");
-
-        if (args.path.length > 64) throw new Error("read path arrays support at most 64 entries; use smaller batches");
-        const groups = [], errors = [];
-
-        // Bound fan-out even when a model submits a large path array.
-        for (let offset = 0; offset < args.path.length; offset += 8) {
-          const results = await Promise.all(args.path.slice(offset, offset + 8).map(async file => {
-            try {
-              const result = await readOne({ ...args, path: file }, signal, ctx, bridge, id);
-
-              return { content: [{ type: "text", text: "File: " + file }, ...result.content] };
-            } catch (error) {
-              signal?.throwIfAborted();
-              errors.push({ path: file, message: error.message });
-
-              return { content: [{ type: "text", text: "[read error: " + file + "] " + error.message }] };
-            }
-          }));
-
-          groups.push(...results);
-        }
-
-        const content = [];
-        let remaining = config.maxCallResultChars, outputTruncated = false;
-
-        for (let i = 0; i < groups.length; i++) {
-          const bounded = boundText(groups[i], Math.floor(remaining / (groups.length - i)));
-          remaining -= bounded.content.reduce((sum, block) => sum + (block.type === "text" ? block.text.length : 0), 0);
-          outputTruncated ||= bounded.details.outputTruncated === true;
-          content.push(...bounded.content);
-        }
-
-        return { content, details: { batch: true, count: args.path.length, errors, outputTruncated } };
-      }
-
-      if (name === "bash") {
-        const settings = settingsFor(ctx);
-
-        try { return await factories.bash(ctx.cwd, { shellPath: settings?.getShellPath(), commandPrefix: settings?.getShellCommandPrefix() }).execute(id, args, signal, onUpdate, ctx); }
-        finally { bridge.invalidateFiles(); }
-      }
-
-      clearPathCache();
-      const target = await resolveWorkspacePath(ctx.cwd, userPath(ctx.cwd, args.path), name);
-      const ops = bridge.fileOperations;
-      let before, after;
-
-      const tool = factories[name](ctx.cwd, { operations: {
-        ...ops,
-        async readFile(file) { const buffer = await ops.readFile(file); before = buffer.toString("utf8");
-
- return buffer; },
-        async writeFile(file, content) { await ops.writeFile(file, content); after = content; },
-      } });
-
-      // Pi's edit/write implementations hold its shared canonical per-file queue
-      // over the entire mutation, including our atomic replacement operation.
-      const result = await tool.execute(id, { ...args, path: target }, signal, onUpdate, ctx);
-
-      if (name === "edit" && before !== undefined && after !== undefined && result.details?.patch) {
-        const summary = await bridge.summarizeEdit(target, before, after, buildPatchDiff(target, result.details.patch));
-        result.content = [{ type: "text", text: summary }];
-      }
-
-      return result;
-    } finally { bridge.close(); }
-  }
-
-  for (const name of NATIVE_NAMES) {
-    const definition = factories[name](cwd);
-
-    const tool = {
-      ...definition,
-      execute(id, args, signal, onUpdate, ctx) {
-        return scheduler.schedule(name, () => execute(name, id, args, signal, onUpdate, ctx), signal);
-      },
-    };
-
-    if (name === "read") {
-      tool.description += " Also reads directories or finds source from a symbol/question passed as path. Use about to focus a file or directory on a question. An array of paths returns all readable files and labels individual errors.";
-      tool.parameters = { ...definition.parameters, properties: {
-        ...definition.parameters.properties,
-        path: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, maxItems: 64 }], description: "File, directory, source question, or up to 64 paths to read" },
-        about: { type: "string", description: "Focus on this question or symbol; source selection reports uncertainty instead of guessing" },
-      } };
-      tool.promptGuidelines = [...(definition.promptGuidelines || []), "read can find source from a symbol or question; check its selection status before choosing a file. Plain file reads preserve full text within the stated limits."];
-    }
-
-    pi.registerTool(tool);
-  }
-
-  pi.on("session_start", (_event, ctx) => {
-    cwd = ctx?.cwd || cwd;
-    base.invalidateFiles();
-  });
-  pi.registerCommand("supernova", {
-    description: "Show Supernova native runtime status",
-    handler: async (_args, ctx) => ctx.ui.notify("Supernova runtime: read, edit, write, bash; " + scheduler.stats.calls + " calls, " + scheduler.stats.readWaves + " read waves, peak " + scheduler.stats.peakParallelReads + " parallel reads. Mutations are ordered; plain reads are not summarized or deduplicated.", "info"),
-  });
-}

package/src/context/evidence.js

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { WorkspaceIndex } from "./repo-index.js";
 import { tokenizeQuery, scorePathTopology, stem } from "./snap.js";
@@ -86,36 +87,36 @@ function spanLines(span) {
 
 // ---- eq.3 / eq.4: entity–context graph over candidate spans ----
 
-function buildGraph(spans) {
-  const entityNames = new Set(spans.map((s) => s.name).filter((n) => n && n.length > 2));
-  const spanEntities = new Map(); // span.id → Map(entity → w(d,e))
-  const entitySpans = new Map();  // entity → Set(span.id)
+function countSpanEntities(span, entityNames) {
+  const counts = new Map();
+  let total = 0;
+  const { idents } = span.lines;
 
-  for (const span of spans) {
-    const counts = new Map();
-    let total = 0;
-    const { idents } = span.lines;
-
-    for (let li = span.start - 1; li < span.end; li++) {
-      for (const word of idents[li]) {
-        if (!entityNames.has(word)) continue;
-        counts.set(word, (counts.get(word) || 0) + 1);
-        total += 1;
-      }
+  for (let li = span.start - 1; li < span.end; li++) {
+    for (const word of idents[li]) {
+      if (!entityNames.has(word)) continue;
+      counts.set(word, (counts.get(word) || 0) + 1);
+      total += 1;
     }
+  }
 
-    const weights = new Map();
+  return { counts, total };
+}
 
-    for (const [e, c] of counts) {
-      weights.set(e, c / total); // eq.4
+function weightsFromCounts(counts, total, entitySpans, spanId) {
+  const weights = new Map();
 
-      if (!entitySpans.has(e)) entitySpans.set(e, new Set());
-      entitySpans.get(e).add(span.id);
-    }
+  for (const [e, c] of counts) {
+    weights.set(e, c / total); // eq.4
 
-    spanEntities.set(span.id, weights);
+    if (!entitySpans.has(e)) entitySpans.set(e, new Set());
+    entitySpans.get(e).add(spanId);
   }
 
+  return weights;
+}
+
+function hubEntities(entitySpans, spans) {
   // Entities present in a large share of spans (isString, path, …) carry no query signal; keep them out of propagation.
   const hubLimit = Math.max(HUB_MIN, Math.floor(spans.length * HUB_FRACTION));
   const hubs = new Set();
@@ -124,7 +125,20 @@ function buildGraph(spans) {
     if (ids.size > hubLimit) hubs.add(entity);
   }
 
-  return { entityNames, spanEntities, entitySpans, hubs, byId: new Map(spans.map((s) => [s.id, s])) };
+  return hubs;
+}
+
+function buildGraph(spans) {
+  const entityNames = new Set(spans.map((s) => s.name).filter((n) => n && n.length > 2));
+  const spanEntities = new Map(); // span.id → Map(entity → w(d,e))
+  const entitySpans = new Map();  // entity → Set(span.id)
+
+  for (const span of spans) {
+    const { counts, total } = countSpanEntities(span, entityNames);
+    spanEntities.set(span.id, weightsFromCounts(counts, total, entitySpans, span.id));
+  }
+
+  return { entityNames, spanEntities, entitySpans, hubs: hubEntities(entitySpans, spans), byId: new Map(spans.map((s) => [s.id, s])) };
 }
 
 // ---- eq.8 / eq.9: entity activation and one propagation step ----
@@ -143,7 +157,7 @@ function lexicalSim(a, b) {
 
 function activateEntities(profile, graph) {
   const eta = new Map();
-  const anchors = profile.subjects.length ? profile.subjects : profile.keywords;
+  const anchors = profile.subjects.length ? profile.subjects : profile.stems;
 
   for (const anchor of anchors) {
     let best = null;
@@ -377,7 +391,7 @@ function normalize(scores) {
 
 // ---- candidate files (boundary + topology + entity hits) ----
 
-function candidateFiles(files, profile, index, limit, overlayText) {
+function topologyScored(files, profile) {
   const scored = [];
 
   for (const f of files) {
@@ -387,27 +401,41 @@ function candidateFiles(files, profile, index, limit, overlayText) {
   }
 
   scored.sort((a, b) => b.s - a.s);
-  const chosen = new Set();
-  const anchors = (profile.subjects.length ? profile.subjects : profile.keywords).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
 
-  const pendingHits = files.filter(file => {
+  return scored;
+}
+
+function pendingAnchorHits(files, anchors, overlayText) {
+  return files.filter(file => {
     const pending = overlayText(file);
 
-    return pending !== undefined && anchors.some(anchor => pending.toLowerCase().includes(anchor));
+    return pending !== undefined && Buffer.byteLength(pending, "utf8") <= 512 * 1024 && anchors.some(anchor => pending.toLowerCase().includes(anchor));
   });
+}
 
-  const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
-
+function chooseByHits(hits, profile, limit, chosen) {
   for (const f of hits) {
     if (chosen.size >= limit) break;
 
     if (profile.flags.wantsTest || scorePathTopology(f, profile.keywords, profile.flags) > -50) chosen.add(f);
   }
+}
 
+function fillFromScored(scored, limit, chosen) {
   for (const { f } of scored) {
     if (chosen.size >= limit) break;
     chosen.add(f);
   }
+}
+
+function candidateFiles(files, profile, index, limit, overlayText) {
+  const scored = topologyScored(files, profile);
+  const chosen = new Set();
+  const anchors = (profile.subjects.length ? profile.subjects : profile.stems).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
+  const pendingHits = pendingAnchorHits(files, anchors, overlayText);
+  const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
+  chooseByHits(hits, profile, limit, chosen);
+  fillFromScored(scored, limit, chosen);
 
   return { files: [...chosen], fileScores: new Map(scored.map(({ f, s }) => [f, s])) };
 }
@@ -494,70 +522,114 @@ function render(spans, picks, fused, opts, root) {
   return out;
 }
 
-/**
- * R(q): top-K provenance-bearing source spans for a concept query, selected without any model call.
- * @returns {{ route: string, spans: Array<{path, lines, name, kind, why, text}> }}
- */
-export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, pendingPaths = [], options = {} }) {
-  const opts = { ...EVIDENCE_DEFAULTS, ...options };
-  const profile = profileQuery(query);
-
-  if (profile.keywords.length === 0) throw new Error("evidence requires at least one searchable concept keyword");
-  const searchRoot = path.resolve(searchDir || root);
-
-  const staged = pendingPaths.filter(file => {
+function stagedInRoot(searchRoot, pendingPaths) {
+  return pendingPaths.filter(file => {
     const relative = path.relative(searchRoot, file);
 
     return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
   });
+}
 
-  const files = [...new Set([...await index.files(searchRoot), ...staged])];
+function statCatch(error) {
+  if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return null;
+  throw error;
+}
+
+async function diskFilesAt(searchRoot, index) {
+  const rootStat = await fs.stat(searchRoot).catch(statCatch);
+
+  if (rootStat?.isFile()) return [searchRoot];
+
+  if (rootStat) return index.files(searchRoot);
+
+  return [];
+}
+
+async function listedFiles(root, searchDir, pendingPaths, index) {
+  const searchRoot = path.resolve(searchDir || root);
+  const files = [...new Set([...await diskFilesAt(searchRoot, index), ...stagedInRoot(searchRoot, pendingPaths)])];
 
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
-  const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles, overlayText);
+  return files;
+}
+
+function overlayEntry(f, overlayText, index) {
+  const pending = overlayText(f);
+
+  return pending === undefined
+    ? index.entry(f)
+    : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(f, pending) : null;
+}
+
+function collectSpans(chosenFiles, overlayText, index, maxSpanLines) {
   const spans = [];
 
   for (const f of chosenFiles) {
-    const pending = overlayText(f);
-    const entry = pending === undefined ? index.entry(f) : WorkspaceIndex.fromText(f, pending);
+    const entry = overlayEntry(f, overlayText, index);
 
     if (!entry) continue;
-    spans.push(...spansOf(entry, f, opts.maxSpanLines));
+    spans.push(...spansOf(entry, f, maxSpanLines));
   }
 
-  if (spans.length === 0) return { route: profile.route, spans: [] };
-
-  const graph = buildGraph(spans);
-  const hier = hierarchicalScores(spans, fileScores, profile);
-  const hierNorm = normalize(hier);
-  const eta = propagate(activateEntities(profile, graph), spans, graph, profile);
-  const pi = pageRank(spans, graph, eta, hierNorm.map((s) => s * 0.5), opts);
-  const graphNorm = normalize([...pi]);
+  return spans;
+}
 
+function fuseScores(profile, graphNorm, hierNorm, rho) {
   const [primary, secondary] = profile.route === "relational" ? [graphNorm, hierNorm] : [hierNorm, graphNorm];
-  const fused = primary.map((p, i) => opts.rho * p + (1 - opts.rho) * secondary[i]); // eq.13
 
-  // eq.15 Filter: boundary/type hard constraints and lexical support; Rank_ϕ: answer-type compatibility.
-  const usage = profile.answerType === "usage";
+  return primary.map((p, i) => rho * p + (1 - rho) * secondary[i]); // eq.13
+}
 
-  const admissible = spans.flatMap((span, i) => {
-    const p = span.path;
-    const isDoc = /\.(md|mdx|rst|txt)$/i.test(p);
+function spanAdmissible(span, profile) {
+  const p = span.path;
+  const isDoc = /\.(md|mdx|rst|txt)$/i.test(p);
 
-    return span.support > 0
-      && (profile.flags.wantsTest || !isTestPath(p))
-      && (profile.flags.wantsDoc || !isDoc)
-      ? [i] : [];
-  });
+  return span.support > 0
+    && (profile.flags.wantsTest || !isTestPath(p))
+    && (profile.flags.wantsDoc || !isDoc);
+}
+
+function compareFused(spans, fused) {
+  return (a, b) => fused[b] - fused[a] || spans[a].path.localeCompare(spans[b].path) || spans[a].start - spans[b].start;
+}
+
+function dampUsageDefiners(spans, profile, fused, admissible) {
+  const usage = profile.answerType === "usage";
 
   for (const i of admissible) {
     if (usage && profile.subjects.includes(spans[i].name)) fused[i] *= 0.5; // a usage question is answered by callers
   }
+}
+
+function pickEvidence(spans, fileScores, profile, opts) {
+  const graph = buildGraph(spans);
+  const hierNorm = normalize(hierarchicalScores(spans, fileScores, profile));
+  const eta = propagate(activateEntities(profile, graph), spans, graph, profile);
+  const pi = pageRank(spans, graph, eta, hierNorm.map((s) => s * 0.5), opts);
+  const fused = fuseScores(profile, normalize([...pi]), hierNorm, opts.rho);
+  // eq.15 Filter: boundary/type hard constraints and lexical support; Rank_ϕ: answer-type compatibility.
+  const admissible = spans.flatMap((span, i) => spanAdmissible(span, profile) ? [i] : []);
+  dampUsageDefiners(spans, profile, fused, admissible);
+  const main = admissible.sort(compareFused(spans, fused)).slice(0, opts.k);
+
+  return { picks: closure(main, spans, graph, fused, opts.k), fused };
+}
 
-  const ranked = admissible.sort((a, b) => fused[b] - fused[a] || spans[a].path.localeCompare(spans[b].path) || spans[a].start - spans[b].start);
-  const main = ranked.slice(0, opts.k);
-  const picks = closure(main, spans, graph, fused, opts.k);
+/**
+ * R(q): top-K provenance-bearing source spans for a concept query, selected without any model call.
+ * @returns {{ route: string, spans: Array<{path, lines, name, kind, why, text}> }}
+ */
+export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, pendingPaths = [], options = {} }) {
+  const opts = { ...EVIDENCE_DEFAULTS, ...options };
+  const profile = profileQuery(query);
+
+  if (profile.keywords.length === 0) throw new Error("evidence requires at least one searchable concept keyword");
+  const { files: chosenFiles, fileScores } = candidateFiles(await listedFiles(root, searchDir, pendingPaths, index), profile, index, opts.maxCandidateFiles, overlayText);
+  const spans = collectSpans(chosenFiles, overlayText, index, opts.maxSpanLines);
+
+  if (spans.length === 0) return { route: profile.route, spans: [] };
+  const { picks, fused } = pickEvidence(spans, fileScores, profile, opts);
 
   return { route: profile.route, spans: render(spans, picks, fused, opts, root) };
 }

package/src/context/fuzzy.js

@@ -15,6 +15,7 @@ const AI_DECAY = Math.LN2 / 3;            // per day
 const AI_MAX_HISTORY_DAYS = 7;
 
 const MAX_TIMESTAMPS_PER_FILE = 128;
+const MAX_FRECENCY_FILES = 10000;
 
 const AI_MODIFICATION_THRESHOLDS = [[16, 30], [8, 300], [4, 900], [2, 3600], [1, 14400]]; // [boost, seconds]
 
@@ -26,7 +27,10 @@ export class Frecency {
   record(filePath, at = Date.now() / 1000) {
     let list = this.access.get(filePath);
 
-    if (!list) this.access.set(filePath, (list = []));
+    if (!list) {
+      if (this.access.size >= MAX_FRECENCY_FILES) this.access.delete(this.access.keys().next().value);
+      this.access.set(filePath, (list = []));
+    }
     list.push(at);
 
     if (list.length > MAX_TIMESTAMPS_PER_FILE) list.splice(0, list.length - MAX_TIMESTAMPS_PER_FILE);
@@ -118,18 +122,9 @@ function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
   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 });
+function considerShorter(part, typosLeft, visit, best) {
+  for (let i = 0; i < part.length; i++) {
+    const m = visit(part.slice(0, i) + part.slice(i + 1), typosLeft - 1);
 
     if (!m) continue;
     const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
@@ -140,6 +135,37 @@ export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false }
   return best;
 }
 
+function matchWithTypos(needle, hay, maxTypos, caseSensitive) {
+  const memo = new Map();
+
+  const visit = (part, typosLeft) => {
+    const key = part + "\0" + typosLeft;
+
+    if (memo.has(key)) return memo.get(key);
+    let best = matchOnce(part, hay, caseSensitive);
+
+    if (best) best = { ...best, typos: 0, exact: hay.toLowerCase() === part.toLowerCase() };
+
+    if (typosLeft > 0) best = considerShorter(part, typosLeft, visit, best);
+    memo.set(key, best);
+
+    return best;
+  };
+
+  return visit(needle, maxTypos);
+}
+
+/** 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 || needle.length > 128) return null;
+
+  return matchWithTypos(needle, hay, maxTypos, caseSensitive);
+}
+
 export function smartCase(query) {
   return /[A-Z]/.test(query);
 }
@@ -161,23 +187,34 @@ function distancePenalty(currentDir, candidateDir) {
  * 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 }
  */
+function partTypos(parts, ctx) {
+  return ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
+}
+
+function scoredPath(rel, parts, maxTypos, caseSensitive, ctx, currentDir) {
+  const matched = matchParts(parts, rel, maxTypos, caseSensitive);
+
+  if (!matched) return null;
+  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));
+
+  return { path: rel, score: base + boosts, exact, typos: first.typos };
+}
+
 export function rankPaths(query, paths, ctx = {}) {
   const parts = query.trim().split(/\s+/).filter((p) => p.length >= 2);
 
-  if (parts.length === 0) return [];
+  if (parts.length === 0 || parts.length > 16) return [];
   const caseSensitive = smartCase(query);
-  const maxTypos = ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
+  const maxTypos = partTypos(parts, ctx);
   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);
+    const scored = scoredPath(rel, parts, maxTypos, caseSensitive, ctx, currentDir);
 
-    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 });
+    if (scored) out.push(scored);
   }
 
   out.sort((a, b) => b.score - a.score || a.path.length - b.path.length || a.path.localeCompare(b.path));
@@ -212,7 +249,9 @@ function filenameBonus(base, rel, filenameStart, first, needle) {
 
 /** 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;
+  let frecency = 0;
+
+  try { frecency = ctx.frecency ? ctx.frecency.score(rel, ctx.mtimeOf?.(rel)) : 0; } catch {}
   const gitBoost = ctx.modified?.has(rel) ? Math.floor((base * 15) / 100) : 0;
 
   return Math.floor((base * frecency) / 100) + gitBoost;