pi-supernova 0.9.0 → 0.10.0

package/src/bridge/host-bridge.js

@@ -1,3 +1,4 @@
+import { createBackgroundTerminals } from "../fs/background.js";
 import {createToolRegistry} from './tool-registry.js';
 import {traceArgs,finishRecord} from './trace.js';
 import * as fs from "node:fs/promises";
@@ -16,20 +17,23 @@ import { resolveWorkspacePath, runCommand, clearPathCache, relativeSlash } from
 import { createNativeAdapters } from "../adapters/index.js";
 import { resultDiff, boundedWriteDiff, writeSnapshot } from "../fs/text-ops.js";
 
-export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedger, budget }) {
+export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedger, budget, terminalIdentity }) {
   const index = registry?.index ?? new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
   const ledger = runLedger ?? new SeenLedger({ window: config.seenWindow ?? 0 });
 
   const vfs = new CausalVfs(paths => {
     index.invalidate();
     notifyWorkspaceChanged(paths);
-  }, target => resolveWorkspacePath(getCwd(), target, "commit", false, true));
+  }, target => resolveWorkspacePath(getCwd(), target, "commit", false, true), assertSession);
 
   const executors = registry?.executors ?? new Map();
   const definitions = registry?.definitions ?? new Map();
   const sharedRegistry = registry ?? { executors, definitions, index, callSeq: 0 };
+  sharedRegistry.terminals ??= createBackgroundTerminals();
   let closed = false;
-  const hooks = {};
+  const hooks = { terminals: sharedRegistry.terminals, terminalGeneration: terminalIdentity?.generation ?? sharedRegistry.terminals.getGeneration() };
+  const ownerOf = ctx => JSON.stringify([ctx?.sessionManager?.getSessionId?.() ?? null, path.resolve(getCwd())]);
+  let terminalOwner = terminalIdentity?.owner ?? ownerOf(null);
   const natives = createNativeAdapters(getCwd, vfs, config, index, ledger, hooks);
   let callCount = 0;
   let activeCtx = null;
@@ -51,9 +55,16 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
     try { pi.events.emit("workspace:changed", event)?.catch?.(() => {}); } catch {}
   }
 
+  hooks.terminalOwner = () => terminalOwner;
   hooks.workspaceChanged = notifyWorkspaceChanged;
-  hooks.artifactsDir = () => activeCtx?.sessionManager?.getArtifactsDir?.();
+  hooks.artifactsDir = () => {
+    assertSession();
+
+    return activeCtx?.sessionManager?.getArtifactsDir?.();
+  };
+
   hooks.commandEnv = () => {
+    assertSession();
     const env = { ...process.env };
 
     const current = {
@@ -77,6 +88,7 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
 
   function bindCallContext(ctx, signal) {
     activeCtx = ctx || null;
+    terminalOwner = terminalIdentity?.owner ?? ownerOf(ctx);
     tools.bindSession(ctx);
     activeSignal = signal;
     vfs.signal = signal;
@@ -100,8 +112,15 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
     } catch {}
   }
 
+  function assertSession() {
+    if (hooks.terminalGeneration !== sharedRegistry.terminals.getGeneration() || terminalOwner !== ownerOf(activeCtx)) {
+      throw new Error("host session changed; start a new call");
+    }
+  }
+
   function assertRunOpen(name) {
     if (closed) throw new Error("program is already complete");
+    assertSession();
 
     if (activeSignal?.aborted) throw new Error("aborted");
 
@@ -149,7 +168,10 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
   }
 
   function assertOwnedOverride(name, args) {
+    if (name === "bash" && (args?.background === true || args?.action !== undefined)) throw new Error("background terminals require the Supernova-owned bash adapter, not an external override");
+
     if (name === "read" && (args?.json !== undefined || /^(agent|artifact):\/\/.*\?/i.test(String(args?.path)))) throw new Error("JSON projection requires the Supernova-owned read adapter, not an external override");
+
     if (name === "write" && args?.append === true) throw new Error("append requires the Supernova-owned write adapter, not an external override");
   }
 
@@ -159,8 +181,11 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
     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);
+    assertSession();
 
     try {
       const res = await target.exec(`supernova:${name}:${callId}`, args || {}, activeSignal, undefined, target.delegated
@@ -176,6 +201,7 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
   }
 
   async function invokeNative(target, args, record, onItem) {
+    assertSession();
     const res = await target.native(target.argvOwned ? { ...args, args: args.args.map(String) } : args || {}, activeSignal, onItem);
     completeRecord(record, res);
 
@@ -207,6 +233,7 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
       const target = resolveInvokeTarget(name, args, { hostTool, hostSession: tools.session, executors, natives });
 
       if (target.kind === "override") return await invokeOverride(target, name, args, record, callId);
+
       if (target.kind === "native") return await invokeNative(target, args, record, onItem);
 
       throw new Error(unknownToolMessage(name, [...executors.keys(), ...Object.keys(natives)]));
@@ -218,11 +245,13 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
 
   function fileMutationKey(name, args) {
     if (!["edit", "write", "apply_patch"].includes(name) || !isString(args?.path)) return;
+
     // Overrides can mutate more than their declared path: keep them global.
     if (hostTool(name) || executors.has(name)) return;
 
     return async () => {
       const target = await resolveWorkspacePath(getCwd(), args.path, name, false, true);
+
       // Share the commit identity, including symlinks and not-yet-created files.
       return (await resolveCommitTarget(target)).target;
     };
@@ -296,8 +325,14 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
     fork(options) {
       const runConfig = options.timeoutMs === undefined ? config : { ...config, timeoutMs: Number(options.timeoutMs) };
 
-      return createHostBridge({ pi, config: runConfig, getCwd: options.getCwd, registry: sharedRegistry, ledger: ledger.fork(), budget: options.budget });
+      return createHostBridge({ pi, config: runConfig, getCwd: options.getCwd, registry: sharedRegistry, ledger: ledger.fork(), budget: options.budget, terminalIdentity:options.terminalIdentity });
     },
+    captureTerminalIdentity: (ctx, runCwd) => ({
+      generation:sharedRegistry.terminals.getGeneration(),
+      owner:JSON.stringify([ctx?.sessionManager?.getSessionId?.() ?? null, path.resolve(runCwd)]),
+    }),
+    shutdownTerminals: () => sharedRegistry.terminals.shutdown(),
+    reopenTerminals: () => sharedRegistry.terminals.reopen(),
     close() { closed = true; vfs.closed = true; },
     bindCallContext,
     resetCallBudget,
@@ -305,8 +340,16 @@ export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedg
     getMutations: () => ({ ...vfs.mutations }),
     setCallListener: fn => { callListener = isFunction(fn) ? fn : null; },
     barrier: run => scheduler.schedule("write", run, activeSignal),
-    beginSpeculation: () => vfs.begin(),
-    commitSpeculation: async () => await vfs.commit(),
+    beginSpeculation() {
+      assertSession();
+
+      return vfs.begin();
+    },
+    async commitSpeculation() {
+      assertSession();
+
+      return await vfs.commit();
+    },
     rollbackSpeculation: () => vfs.rollback(),
     getOverlayDepth: () => vfs.getOverlayDepth(),
     call,

package/src/bridge/invoke.js

@@ -3,15 +3,18 @@ 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"
+  return name === "bash" && args?.background !== true && args?.action === undefined && Array.isArray(args?.args)
     && args.args.length === Object.keys(args.args).length && args.args.every(isString);
 }
 
@@ -19,6 +22,7 @@ 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 };
@@ -29,6 +33,7 @@ export function resolveInvokeTarget(name, args, env) {
   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/trace.js

@@ -7,7 +7,7 @@ function traceArgs(args) {
   if (!isObject(args)) return {};
   const out = {};
 
-  for (const key of ["path", "target", "query", "pattern", "command", "cwd", "glob", "action", "op"]) {
+  for (const key of ["path", "target", "query", "pattern", "command", "cwd", "glob", "action", "sessionId", "op"]) {
     const value = args[key];
 
     if (isString(value)) out[key] = truncateChars(value, 240, "trace").text;
@@ -16,7 +16,9 @@ function traceArgs(args) {
   }
 
   if (isString(args.content)) out.content = args.content.length + " chars";
+
   if (Array.isArray(args.edits)) out.edits = args.edits.length + " edits";
+
   if (Array.isArray(args.args)) out.args = args.args.length + " argv";
 
   return out;
@@ -38,4 +40,5 @@ function finishRecord(record, res) {
 
   if (text) record.resultText = truncateChars(text, 4096, "trace").text;
 }
+
 export { traceArgs, finishRecord };

package/src/context/evidence.js

@@ -3,6 +3,7 @@ import {pendingInScope,overlaySearchEntry} from './search-files.js';
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { WorkspaceIndex } from "./repo-index.js";
+import { relativeSlash } from "../fs/workspace.js";
 import { tokenizeQuery, scorePathTopology, stem } from "./query.js";
 
 // Zero-token evidence selection over source code, after Zero-Mem (arXiv:2607.29377).
@@ -148,15 +149,18 @@ function render(spans, picks, fused, opts, root) {
     const lastLine = span.start + text.split("\n").length - 1;
     const truncated = lastLine < span.sourceEnd;
     budget -= text.length;
+
     const rendered = {
-      path: path.relative(root, span.path) || span.path,
+      path: relativeSlash(root, span.path),
       lines: [span.start, lastLine],
       name: span.name,
       kind: span.kind,
       why,
       text,
     };
+
     if (truncated) { rendered.truncated = true; rendered.nextOffset = lastLine+1; }
+
     out.push(rendered);
 
     if (budget <= 0) break;
@@ -206,15 +210,20 @@ function collectSpans(chosenFiles, overlayText, index, maxSpanLines) {
 // its declaration. Keep the matching line in the bounded window, even in long bodies.
 function usageSpans(spans, profile, maxSpanLines) {
   if (profile.answerType !== "usage" || !profile.subjects.length) return spans;
+
   return spans.flatMap(span => {
     for (let i = span.start - 1; i < span.sourceEnd; i++) {
       const words = span.lines.idents[i];
+
       const matched = profile.subjects.some(subject =>
         words.filter(word => word === subject).length > Number(span.lines.defNames[i] === subject.toLowerCase()));
+
       if (!matched) continue;
       const start = Math.max(span.start, i - 1);
+
       return [{ ...span, start, end: Math.min(span.sourceEnd, start + maxSpanLines - 1) }];
     }
+
     return [];
   });
 }

package/src/context/fuzzy.js

@@ -40,10 +40,13 @@ export class Frecency {
   score(filePath, mtimeSec, now = Date.now() / 1000) {
     let total = 0;
     const cutoff = now - AI_MAX_HISTORY_DAYS * 86400;
+    const stamps = this.access.get(filePath);
 
-    for (const t of this.access.get(filePath) || []) {
-      if (t < cutoff) continue;
-      total += Math.exp(-AI_DECAY * ((now - t) / 86400));
+    if (stamps) {
+      for (const t of stamps) {
+        if (t < cutoff) continue;
+        total += Math.exp(-AI_DECAY * ((now - t) / 86400));
+      }
     }
 
     if (mtimeSec) {
@@ -74,33 +77,42 @@ function isBoundary(hay, i) {
 }
 
 /**
- * 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.
+ * Greedy forward scan. Returns the match end or the needle index that failed
+ * (failAt), which the typo retry uses to prune deletions provably unable to
+ * match (see matchWithTypos).
  */
-function matchOnce(needle, hay, caseSensitive) {
-  const hayCmp = caseSensitive ? hay : hay.toLowerCase();
-  const nCmp = caseSensitive ? needle : needle.toLowerCase();
+function scanForward(nCmp, hayCmp) {
   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;
+    if (hi < 0) return { failAt: ni };
     hi++;
   }
 
-  const end = hi;
+  return { end: hi, failAt: -1 };
+}
+
+/**
+ * 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.
+ * Lowered strings arrive precomputed: the needle once per query, the haystack
+ * once per path — never re-lowered per part or per typo variant.
+ */
+function matchOnce(part, pCmp, hay, hayCmp) {
+  const scan = scanForward(pCmp, hayCmp);
+
+  if (scan.failAt >= 0) return null;
+  const end = scan.end;
   // 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);
+  for (let ni = pCmp.length - 1; ni >= 0; ni--) {
+    start = hayCmp.lastIndexOf(pCmp[ni], start - 1);
   }
 
-  return { score: scoreAlignment(needle, nCmp, hay, hayCmp, start), start, end };
+  return { score: scoreAlignment(part, pCmp, hay, hayCmp, start), start, end };
 }
 
 /** +16 boundary, +8 consecutive, +4 exact-case, −1 per skipped haystack char. */
@@ -122,9 +134,14 @@ function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
   return score;
 }
 
-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);
+function considerShorter(sub, subCmp, subLower, typosLeft, visit, best, maxDel) {
+  for (let i = 0; i <= maxDel; i++) {
+    const m = visit(
+      sub.slice(0, i) + sub.slice(i + 1),
+      subCmp.slice(0, i) + subCmp.slice(i + 1),
+      subLower.slice(0, i) + subLower.slice(i + 1),
+      typosLeft - 1,
+    );
 
     if (!m) continue;
     const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
@@ -135,46 +152,95 @@ function considerShorter(part, typosLeft, visit, best) {
   return best;
 }
 
-function matchWithTypos(needle, hay, maxTypos, caseSensitive) {
+// Failure pruning (exact, not heuristic): a deletion strictly after the
+// fail index preserves the failing prefix, so that child fails too — and
+// every deeper success deletes an early char first, which the unpruned
+// order reaches with the same typo count via memo. On success all
+// deletions are still explored (a shorter variant can outscore the -12).
+// This turns full-miss retries from O(len^typos) attempts into O(len×typos).
+function matchWithTypos(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, maxTypos) {
   const memo = new Map();
+  let hayLower = hayLowerOrNull;
 
-  const visit = (part, typosLeft) => {
-    const key = part + "\0" + typosLeft;
+  const visit = (sub, subCmp, subLower, typosLeft) => {
+    const key = sub + "\0" + typosLeft;
 
     if (memo.has(key)) return memo.get(key);
-    let best = matchOnce(part, hay, caseSensitive);
+    const scan = scanForward(subCmp, hayCmp);
+    let best = null;
+    let maxDel = sub.length - 1;
+
+    if (scan.failAt < 0) {
+      let start = scan.end;
+
+      for (let ni = subCmp.length - 1; ni >= 0; ni--) {
+        start = hayCmp.lastIndexOf(subCmp[ni], start - 1);
+      }
 
-    if (best) best = { ...best, typos: 0, exact: hay.toLowerCase() === part.toLowerCase() };
+      if (hayLower === null) hayLower = hay.toLowerCase();
+      best = {
+        score: scoreAlignment(sub, subCmp, hay, hayCmp, start),
+        start,
+        end: scan.end,
+        typos: 0,
+        exact: hayLower === subLower,
+      };
+    } else {
+      maxDel = scan.failAt;
+    }
 
-    if (typosLeft > 0) best = considerShorter(part, typosLeft, visit, best);
+    if (typosLeft > 0) best = considerShorter(sub, subCmp, subLower, typosLeft, visit, best, maxDel);
     memo.set(key, best);
 
     return best;
   };
 
-  return visit(needle, maxTypos);
+  return visit(part, pCmp, partLower, maxTypos);
+}
+
+function matchPart(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, maxTypos) {
+  const direct = matchOnce(part, pCmp, hay, hayCmp);
+
+  if (direct) {
+    const hayLower = hayLowerOrNull === null ? hay.toLowerCase() : hayLowerOrNull;
+
+    return { ...direct, typos: 0, exact: hayLower === partLower };
+  }
+
+  if (maxTypos <= 0 || part.length < 3 || part.length > 128) return null;
+
+  return matchWithTypos(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, 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 (caseSensitive) return matchPart(needle, needle, needle.toLowerCase(), hay, hay, null, maxTypos);
 
-  if (maxTypos <= 0 || needle.length < 3 || needle.length > 128) return null;
+  const needleLower = needle.toLowerCase();
+  const hayLower = hay.toLowerCase();
 
-  return matchWithTypos(needle, hay, maxTypos, caseSensitive);
+  return matchPart(needle, needleLower, needleLower, hay, hayLower, hayLower, maxTypos);
 }
 
 export function smartCase(query) {
   return /[A-Z]/.test(query);
 }
 
+function splitDirSegs(dir) {
+  return dir.split("/").filter(Boolean);
+}
+
 /** 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);
+function distancePenalty(currentSegs, candidateDir, dirCache) {
+  if (!currentSegs) return 0;
+  let b = dirCache.get(candidateDir);
+
+  if (!b) {
+    b = splitDirSegs(candidateDir);
+    dirCache.set(candidateDir, b);
+  }
+
+  const a = currentSegs;
   let common = 0;
 
   while (common < a.length && common < b.length && a[common] === b[common]) common++;
@@ -191,13 +257,14 @@ 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);
+function scoredPath(rel, parts, partLower, maxTypos, caseSensitive, ctx, currentSegs, dirCache) {
+  const hayCmp = caseSensitive ? rel : rel.toLowerCase();
+  const matched = matchParts(parts, partLower, rel, hayCmp, caseSensitive ? null : hayCmp, 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));
+  const boosts = filenameBonus(base, rel, filenameStart, first, partLower[0]) + contextBoost(base, rel, ctx) + distancePenalty(currentSegs, rel.slice(0, filenameStart), dirCache);
 
   return { path: rel, score: base + boosts, exact, typos: first.typos };
 }
@@ -208,11 +275,17 @@ export function rankPaths(query, paths, ctx = {}) {
   if (parts.length === 0 || parts.length > 16) return [];
   const caseSensitive = smartCase(query);
   const maxTypos = partTypos(parts, ctx);
+  // Per-query hoists: lowered parts once (not once per path per part), the
+  // current directory split once (not once per candidate), plus a
+  // per-call cache for candidate directory segments (paths share dirs).
+  const partLower = parts.map((p) => p.toLowerCase());
   const currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
+  const currentSegs = currentDir ? splitDirSegs(currentDir) : null;
+  const dirCache = new Map();
   const out = [];
 
   for (const rel of paths) {
-    const scored = scoredPath(rel, parts, maxTypos, caseSensitive, ctx, currentDir);
+    const scored = scoredPath(rel, parts, partLower, maxTypos, caseSensitive, ctx, currentSegs, dirCache);
 
     if (scored) out.push(scored);
   }
@@ -223,13 +296,13 @@ export function rankPaths(query, paths, ctx = {}) {
 }
 
 /** 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) {
+function matchParts(parts, partLower, rel, hayCmp, hayLowerOrNull, 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 });
+    const m = matchPart(parts[pi], caseSensitive ? parts[pi] : partLower[pi], partLower[pi], rel, hayCmp, hayLowerOrNull, pi === 0 ? maxTypos : Math.min(maxTypos, 1));
 
     if (!m) return null;
     first ??= m;
@@ -241,10 +314,10 @@ function matchParts(parts, rel, maxTypos, caseSensitive) {
 }
 
 /** fff: exact filename +40% of base, any filename match +20%. */
-function filenameBonus(base, rel, filenameStart, first, needle) {
+function filenameBonus(base, rel, filenameStart, first, needleLower) {
   if (first.start < filenameStart) return 0;
 
-  return rel.slice(filenameStart).toLowerCase() === needle.toLowerCase() ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
+  return rel.slice(filenameStart).toLowerCase() === needleLower ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
 }
 
 /** fff: frecency boost base·f/100 and +15% for git-modified files. */

package/src/context/query.js

@@ -12,6 +12,14 @@ const SOURCE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs",
 
 const TYPED_EXT = new Set([".ts", ".tsx", ".rs", ".go"]);
 
+const BUILD_DIRS = new Set(["node_modules", "dist", "target"]);
+
+const TEST_WORDS = new Set(["test", "tests", "testing", "spec", "specs"]);
+
+const TYPE_WORDS = new Set(["type", "types", "interface", "interfaces", "schema", "schemas"]);
+
+const DOC_WORDS = new Set(["doc", "docs", "documentation", "readme"]);
+
 const MAX_NEEDLE_CHARS = 128;
 
 /** Light suffix stripping so "terminated" ⊇ "terminat" matches "terminate"; deterministic, no dictionary. */
@@ -27,9 +35,9 @@ export function tokenizeQuery(query) {
 
   return {
     tokens: [...new Set(words.filter(word => word.length > 1 && !STOP_WORDS.has(word)))],
-    wantsTest: words.some(word => ["test", "tests", "testing", "spec", "specs"].includes(word)),
-    wantsType: words.some(word => ["type", "types", "interface", "interfaces", "schema", "schemas"].includes(word)),
-    wantsDoc: words.some(word => ["doc", "docs", "documentation", "readme"].includes(word)),
+    wantsTest: words.some(word => TEST_WORDS.has(word)),
+    wantsType: words.some(word => TYPE_WORDS.has(word)),
+    wantsDoc: words.some(word => DOC_WORDS.has(word)),
   };
 }
 
@@ -37,7 +45,8 @@ function tokenPathScore(base, words, normalized, tokens) {
   let score = 0;
 
   for (const token of tokens) {
-    if (base === token || base.startsWith(token + ".")) score += 60;
+    // base === token + "." without the concat alloc: same verdict, no garbage.
+    if (base === token || (base.length > token.length && base[token.length] === "." && base.startsWith(token))) score += 60;
     else if (base.includes(token)) score += 30;
     else if (words.includes(token)) score += 15;
     else if (normalized.includes(token)) score += 5;
@@ -49,7 +58,7 @@ function tokenPathScore(base, words, normalized, tokens) {
 function topologyPenalty(normalized, flags) {
   const parts = normalized.split("/");
 
-  if (parts.some(part => ["node_modules", "dist", "target"].includes(part))) return -100;
+  if (parts.some(part => BUILD_DIRS.has(part))) return -100;
   const test = isTestPath(normalized);
 
   if (test && !flags.wantsTest) return -50;

package/src/context/repo-index.js

@@ -113,6 +113,19 @@ function grepEntryRows(e, filePath, root, regex, nameRegex, out) {
   }
 }
 
+// One alternation scan per file instead of one full scan per needle — same
+// verdict as needles.some(includes). Needles are escaped: they arrive as
+// literals that may carry regex syntax.
+function anyOfProbe(needles) {
+  return new RegExp(needles.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"));
+}
+
+function fileMatchesNeedles(entry, needles, anyOf, probe) {
+  if (probe) return probe.test(entry.lower);
+
+  return anyOf ? needles.some((n) => entry.lower.includes(n)) : needles.every((n) => entry.lower.includes(n));
+}
+
 export class WorkspaceIndex {
   constructor(runCommand) {
     this.runCommand = runCommand;
@@ -358,14 +371,12 @@ export class WorkspaceIndex {
   /** Files whose lowercase text contains any (or every) needle; needles are lowercase. */
   filesContaining(files, needles, anyOf) {
     const hits = [];
+    const probe = anyOf && needles.length > 1 ? anyOfProbe(needles) : null;
 
     for (const filePath of files) {
       const e = this.entry(filePath);
 
-      if (!e) continue;
-      const found = anyOf ? needles.some((n) => e.lower.includes(n)) : needles.every((n) => e.lower.includes(n));
-
-      if (found) hits.push(filePath);
+      if (e && fileMatchesNeedles(e, needles, anyOf, probe)) hits.push(filePath);
     }
 
     return hits;