pi-supernova 0.5.0 → 0.6.0

package/src/bridge/native-tools.js

@@ -54,7 +54,11 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   };
 
   function settingsFor(ctx) {
-    return host.SettingsManager?.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted?.() === true });
+    try {
+      return host.SettingsManager?.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted?.() === true });
+    } catch {
+      return undefined;
+    }
   }
 
   async function readOne(args, signal, ctx, bridge, id) {
@@ -67,7 +71,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
     signal?.throwIfAborted();
     const image = /\.(png|jpe?g|gif|webp|bmp)$/i.test(target);
 
-    if (stat?.isFile() && (args.about === undefined || image)) {
+    if (stat?.isFile() && args.about === undefined && args.query === undefined && args.resolve === undefined && args.outline === undefined && args.evidence === undefined && args.json === undefined && args.complete === undefined) {
       // 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);
@@ -77,7 +81,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   }
 
   async function execute(name, id, args, signal, onUpdate, context) {
-    const ctx = { ...context, cwd: context?.cwd || cwd };
+    const ctx = { ...context, cwd: isString(context?.cwd) && context.cwd ? context.cwd : cwd };
     const bridge = base.fork({ getCwd: () => ctx.cwd });
     bridge.bindCallContext(ctx, signal);
     signal?.throwIfAborted();
@@ -166,11 +170,17 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
     };
 
     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.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 (at most 16 keywords). An array of up to 64 paths returns all readable files and labels individual errors. Images return as attachments up to 20 MiB each; at most 16 image attachments are returned.";
       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" },
+        about: { type: "string", description: "Focus on this question or symbol (at most 16 keywords); source selection reports uncertainty instead of guessing" },
+        query: { type: "string", description: "Source question; optional path scopes the search" },
+        outline: { type: "boolean" },
+        evidence: { type: "boolean" },
+        resolve: { type: "boolean" },
+        complete: { type: "boolean" },
+        json: { anyOf: [{ type: "boolean" }, { type: "string" }, { type: "array", items: { type: "string" }, maxItems: 64 }] },
       } };
       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."];
     }
@@ -179,7 +189,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   }
 
   pi.on("session_start", (_event, ctx) => {
-    cwd = ctx?.cwd || cwd;
+    cwd = isString(ctx?.cwd) && ctx.cwd ? ctx.cwd : cwd;
     base.invalidateFiles();
   });
   pi.registerCommand("supernova", {

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";
@@ -143,7 +144,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;
@@ -388,12 +389,12 @@ 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 anchors = (profile.subjects.length ? profile.subjects : profile.stems).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
 
   const pendingHits = 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)])] : [];
@@ -511,7 +512,12 @@ export async function selectEvidence({ query, root, searchDir, index, overlayTex
     return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
   });
 
-  const files = [...new Set([...await index.files(searchRoot), ...staged])];
+  const rootStat = await fs.stat(searchRoot).catch(error => {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return null;
+    throw error;
+  });
+  const diskFiles = rootStat?.isFile() ? [searchRoot] : rootStat ? await index.files(searchRoot) : [];
+  const files = [...new Set([...diskFiles, ...staged])];
 
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
@@ -520,7 +526,9 @@ export async function selectEvidence({ query, root, searchDir, index, overlayTex
 
   for (const f of chosenFiles) {
     const pending = overlayText(f);
-    const entry = pending === undefined ? index.entry(f) : WorkspaceIndex.fromText(f, pending);
+    const entry = pending === undefined
+      ? index.entry(f)
+      : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(f, pending) : null;
 
     if (!entry) continue;
     spans.push(...spansOf(entry, f, opts.maxSpanLines));

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);
@@ -124,20 +128,35 @@ export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false }
 
   if (direct) return { ...direct, typos: 0, exact: hay.toLowerCase() === needle.toLowerCase() };
 
-  if (maxTypos <= 0 || needle.length < 3) return null;
-  let best = null;
+  if (maxTypos <= 0 || needle.length < 3 || needle.length > 128) return null;
+  const memo = new Map();
 
-  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 });
+  const visit = (part, typosLeft) => {
+    const key = part + "\0" + typosLeft;
 
-    if (!m) continue;
-    const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+    if (memo.has(key)) return memo.get(key);
+    let best = matchOnce(part, hay, caseSensitive);
 
-    if (!best || scored.score > best.score) best = scored;
-  }
+    if (best) best = { ...best, typos: 0, exact: hay.toLowerCase() === part.toLowerCase() };
+
+    if (typosLeft > 0) {
+      for (let i = 0; i < part.length; i++) {
+        const shorter = part.slice(0, i) + part.slice(i + 1);
+        const m = visit(shorter, typosLeft - 1);
+
+        if (!m) continue;
+        const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+
+        if (!best || scored.score > best.score) best = scored;
+      }
+    }
+
+    memo.set(key, best);
 
-  return best;
+    return best;
+  };
+
+  return visit(needle, maxTypos);
 }
 
 export function smartCase(query) {
@@ -164,7 +183,7 @@ function distancePenalty(currentDir, candidateDir) {
 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 currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
@@ -212,7 +231,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;

package/src/context/outline.js

@@ -28,6 +28,7 @@ function relevance(span, lower, stems) {
 }
 
 function chooseExpanded(spans, lower, stems, raw, opts) {
+  if (stems.length === 0) return new Set();
   const scored = spans.map((s, i) => ({ i, r: relevance(s, lower, stems), chars: raw.slice(s.start - 1, s.end).join("\n").length }));
   scored.sort((a, b) => b.r - a.r || a.i - b.i);
   const expanded = new Set();
@@ -118,7 +119,15 @@ export function outlineFile(entry, relPath, about, options = {}) {
   }
 
   for (let i = 0; i < spans.length; i++) parts.push(expanded.has(i) ? expandedBlock(spans[i], raw, opts) : foldedLine(spans[i]));
-  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (about ? " for \"" + about + "\"" : "") + " · read(path, line, count) for a folded body";
+  const label = about ? String(about).replace(/\s+/g, " ").slice(0, 120) : "";
+  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (label ? " for \"" + label + "\"" : "") + " · read(path, line, count) for a folded body";
+  let text = title + "\n" + parts.join("\n");
 
-  return { text: title + "\n" + parts.join("\n"), expanded: expanded.size, declarations: spans.length };
+  if (text.length > opts.maxChars) {
+    const end = text.lastIndexOf("\n", Math.max(0, opts.maxChars - 160));
+
+    text = (end > title.length ? text.slice(0, end) : text.slice(0, opts.maxChars)) + "\n      … outline truncated; use read(path, line, count) for later declarations";
+  }
+
+  return { text, expanded: expanded.size, declarations: spans.length };
 }

package/src/context/repo-index.js

@@ -21,6 +21,7 @@ const WATCH_DEBOUNCE_MS = 150;
 const MAX_INDEXED_FILES = 4000;
 
 const MAX_FILE_BYTES = 512 * 1024;
+const MAX_ENTRY_CACHE_BYTES = 64 * 1024 * 1024;
 
 const BINARY_EXT = new Set([
   ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".tar", ".bz2", ".xz", ".7z",
@@ -34,11 +35,13 @@ const IDENT_TOKEN = /[A-Za-z_$][\w$]*/g;
 
 const EMPTY = Object.freeze([]);
 
-const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)/;
+const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(?:(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)|([A-Z][A-Z0-9_$]*)\s*(?::[^=\n]+)?=)/;
 
-/** Declared identifier on a line (function/class/const/…), or ""; the same rule snap and grep use. */
+/** Declared identifier on a line (function/class/UPPER_CASE constant/…), or ""; the same rule snap and grep use. */
 export function declaredName(line) {
-  return DEF_PATTERN.exec(String(line).trim())?.[2] ?? "";
+  const match = DEF_PATTERN.exec(String(line).trim());
+
+  return match?.[2] ?? match?.[3] ?? "";
 }
 
 function isTextCandidate(filePath) {
@@ -71,7 +74,9 @@ function globGroup(glob, i, open) {
 
   if (end < 0) throw new SyntaxError("unclosed " + open + " in glob");
   const inner = glob.slice(i + 1, end);
-  const source = open === "{" ? "(?:" + inner.split(",").map(globBody).join("|") + ")" : "[" + inner + "]";
+  const source = open === "{"
+    ? "(?:" + inner.split(",").map(globBody).join("|") + ")"
+    : "[" + (inner.startsWith("!") ? "^" + inner.slice(1) : inner) + "]";
 
   return [source, end + 1];
 }
@@ -137,6 +142,7 @@ export class WorkspaceIndex {
     this.runCommand = runCommand;
     this.lists = new Map();
     this.entries = new Map();
+    this.entryBytes = 0;
     this.watchers = new Map();
     this.frecency = new Frecency();
     this.gitModified = new Map(); // root → Set(relative "/"-joined paths)
@@ -145,6 +151,11 @@ export class WorkspaceIndex {
 
   invalidate() {
     this.lists.clear();
+    this.gitModified.clear();
+
+    for (const entry of this.entries.values()) this.entryBytes -= entry.weight ?? 0;
+    this.entries.clear();
+    this.entryBytes = 0;
   }
 
   /** fff frecency: every read/edit is an access; the newest one is the "current file" for distance penalties. */
@@ -166,12 +177,17 @@ export class WorkspaceIndex {
           timer = null;
           this.lists.clear();
           this.gitModified.delete(root);
+          this.entries.clear();
+          this.entryBytes = 0;
         }, WATCH_DEBOUNCE_MS);
+        timer.unref?.();
       });
 
       watcher.on("error", () => {
         this.watchers.set(root, false);
         this.lists.clear();
+        this.entries.clear();
+        this.entryBytes = 0;
       });
 
       if (isFunction(watcher.unref)) watcher.unref();
@@ -196,8 +212,21 @@ export class WorkspaceIndex {
       const res = await this.runCommand(["git", "status", "--porcelain", "-z", "--untracked-files=all"], { cwd: root, timeoutMs: 5_000 });
 
       if (res.exitCode === 0) {
-        for (const row of res.stdout.split("\0")) {
-          if (row.length > 3) set.add(row.slice(3));
+        const rows = res.stdout.split("\0");
+
+        for (let i = 0; i < rows.length; i++) {
+          const row = rows[i];
+
+          if (row.length <= 3) continue;
+          const status = row.slice(0, 2);
+          const file = row.slice(3);
+
+          if (file) set.add(file);
+          if ((status.includes("R") || status.includes("C")) && i + 1 < rows.length) {
+            const target = rows[++i];
+
+            if (target) set.add(target);
+          }
         }
       }
     } catch {}
@@ -229,7 +258,7 @@ export class WorkspaceIndex {
     const args = ["rg", "--files"];
 
     if (includeHidden) args.push("--hidden");
-    args.push("-g", "!.git/**", "-g", "!**/.git/**", root);
+    args.push("-g", "!.git/**", "-g", "!**/.git/**", "--", root);
     let files = [];
     let error;
     let truncated = false;
@@ -261,26 +290,107 @@ export class WorkspaceIndex {
     try {
       stat = fs.statSync(filePath);
     } catch {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
       this.entries.delete(filePath);
 
       return null;
     }
 
-    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return null;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
+      return null;
+    }
     const cached = this.entries.get(filePath);
 
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached;
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      this.entries.delete(filePath);
+      this.entries.set(filePath, cached);
+
+      return cached;
+    }
     let text;
+    let actual = stat;
 
     try {
-      text = fs.readFileSync(filePath, "utf8");
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
+
+      try {
+        actual = fs.fstatSync(fd);
+        if (!actual.isFile() || actual.size > MAX_FILE_BYTES) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        const buffer = Buffer.alloc(MAX_FILE_BYTES + 1);
+        let offset = 0;
+
+        while (offset < buffer.length) {
+          const read = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+
+          if (read <= 0) break;
+          offset += read;
+        }
+
+        if (offset > MAX_FILE_BYTES) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        actual = fs.fstatSync(fd);
+        if (!actual.isFile() || actual.size !== offset) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        text = buffer.subarray(0, offset).toString("utf8");
+      } finally { fs.closeSync(fd); }
     } catch {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
       return null;
     }
 
-    if (text.includes("\0")) return null;
-    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    if (text.includes("\0")) {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
+      return null;
+    }
+    const created = { text, lower: text.toLowerCase(), mtimeMs: actual.mtimeMs, size: actual.size, weight: Math.max(1, actual.size) * 2, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    const previous = this.entries.get(filePath);
+
+    if (previous) this.entryBytes -= previous.weight ?? 0;
+    this.entries.delete(filePath);
     this.entries.set(filePath, created);
+    this.entryBytes += created.weight;
+
+    while (this.entryBytes > MAX_ENTRY_CACHE_BYTES && this.entries.size > 1) {
+      const oldest = this.entries.keys().next().value;
+      const evicted = this.entries.get(oldest);
+
+      this.entries.delete(oldest);
+      this.entryBytes -= evicted?.weight ?? 0;
+    }
 
     return created;
   }
@@ -300,7 +410,8 @@ export class WorkspaceIndex {
     for (let i = 0; i < raw.length; i++) {
       const trimmed = raw[i].trim();
       lower[i] = trimmed.toLowerCase();
-      defNames[i] = DEF_PATTERN.exec(trimmed)?.[2].toLowerCase() ?? "";
+      const declared = DEF_PATTERN.exec(trimmed);
+      defNames[i] = (declared?.[2] ?? declared?.[3] ?? "").toLowerCase();
       idents[i] = trimmed.match(IDENT_TOKEN) || EMPTY;
     }
 
@@ -366,9 +477,33 @@ export class WorkspaceIndex {
 
     for (const filePath of files) {
       const pending = overlayText(filePath);
-      const e = pending === undefined ? this.entry(filePath) : WorkspaceIndex.fromText(filePath, pending);
+      let e = null;
+
+      if (pending === undefined) e = this.entry(filePath);
+      else if (Buffer.byteLength(pending, "utf8") <= MAX_FILE_BYTES) e = WorkspaceIndex.fromText(filePath, pending);
+      else {
+        const rel = relativeSlash(root, filePath);
+        let start = 0;
+        let line = 0;
+
+        while (start <= pending.length) {
+          const end = pending.indexOf("\n", start);
+          const stop = end === -1 ? pending.length : end;
+          const text = pending.slice(start, stop).replace(/\r$/, "");
+
+          line++;
+          if (regex.test(text)) out.push({ rel, line, text, def: false });
+          if (end === -1) break;
+          start = end + 1;
+        }
+
+        continue;
+      }
+
+      if (!e) continue;
+      const lineAnchored = /\^|\$/.test(regex.source.replace(/\\[\^$]|\[[^\]]*\]/g, ""));
 
-      if (!e || !regex.test(e.text)) continue;
+      if (!lineAnchored && !regex.test(e.text)) continue;
       const { raw, defNames } = WorkspaceIndex.linesOf(e);
       const rel = relativeSlash(root, filePath);
 

package/src/context/search.js

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isString } from "../shared/decode.js";
 import { WorkspaceIndex, globToRegExp } from "./repo-index.js";
@@ -12,6 +13,22 @@ function textResult(text, details) {
   return { content: [{ type: "text", text: String(text ?? "") }], details: details || {} };
 }
 
+async function candidateFileList(index, root, includeHidden = false, signal) {
+  const stat = await fs.stat(root).catch(() => null);
+
+  if (stat?.isFile()) return [root];
+
+  return index.files(root, includeHidden, signal);
+}
+
+function pendingInScope(root, pendingPaths) {
+  return pendingPaths.filter(file => {
+    const relative = path.relative(root, file);
+
+    return relative === "" || (relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative));
+  });
+}
+
 /** One bounded direct search for all changed names; no repository index or per-name spawn. */
 export async function referencesForNames({ root, names, excludePath, overlayText, pendingPaths, signal, run = runCommand }) {
   const references = new Map(names.map(name => [name, []]));
@@ -48,10 +65,10 @@ export async function referencesForNames({ root, names, excludePath, overlayText
     if (overlayText(file) === undefined) add(file, record.data.line_number, record.data.lines.text);
   }
 
-  for (const file of pendingPaths) {
+  for (const file of pendingInScope(root, pendingPaths)) {
     const text = overlayText(file);
 
-    if (text !== undefined) text.split("\n").forEach((line, i) => add(file, i + 1, line));
+    if (text !== undefined && Buffer.byteLength(text, "utf8") <= 512 * 1024) text.split("\n").forEach((line, i) => add(file, i + 1, line));
   }
 
   return { references, incomplete: result.outputTruncated === true };
@@ -59,29 +76,57 @@ export async function referencesForNames({ root, names, excludePath, overlayText
 
 export function rgGrepArgs(pattern, params, searchPath) {
   const args = ["--line-number", "--no-heading", "--color", "never"];
+  const caseSensitive = params?.caseSensitive === true || (params?.caseSensitive !== false && smartCase(pattern));
 
-  if (params?.caseSensitive !== true) args.push("--ignore-case");
+  if (!caseSensitive) args.push("--ignore-case");
 
   if (params?.glob) args.push("--glob", String(params.glob));
+  if (Number.isInteger(params?.limit) && params.limit > 0) args.push("--max-count", String(Math.min(params.limit, 2000)));
   args.push("--", pattern, searchPath);
 
   return args;
 }
 
 /** rg --files, then find(1) when rg is unavailable; both accept an optional glob/name pattern. */
-export async function listWithTools(searchDir, pattern, cwd, signal) {
+export async function listWithTools(searchDir, pattern, cwd, signal, pendingPaths = []) {
+  const stat = await fs.stat(searchDir).catch(() => null);
+  const pendingAbs = pendingInScope(searchDir, pendingPaths);
+  const pending = pendingAbs.map(file => relativeSlash(cwd, file));
+
+  let matcher = null;
+
+  if (pattern) {
+    try { matcher = globToRegExp(pattern); }
+    catch { matcher = /^$/; }
+  }
+
+  if (stat?.isFile() || (!stat?.isDirectory() && pending.length)) {
+    const rel = stat?.isFile() ? relativeSlash(cwd, searchDir) : null;
+    const rows = [...new Set([...(rel ? [rel] : []), ...pending])].filter(file => !matcher || matcher.test(file));
+
+    return textResult(rows.length ? rows.join("\n") + "\n" : "", { via: pending.length ? "vfs" : "file" });
+  }
+
+  const pendingMerged = pendingAbs.filter((_, i) => !matcher || matcher.test(pending[i]));
+  const mergePending = stdout => {
+    const diskRows = String(stdout || "").split("\n").filter(Boolean)
+      .map(row => relativeSlash(cwd, path.isAbsolute(row) ? row : path.resolve(cwd, row)));
+    const rows = [...new Set([...diskRows, ...pendingMerged])];
+
+    return rows.length ? rows.join("\n") + "\n" : "";
+  };
   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" });
+  if (res && (res.exitCode === 0 || res.exitCode === 1)) return textResult(mergePending(res.stdout), { via: "rg", outputTruncated: res.outputTruncated === true });
   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" });
+  return textResult(mergePending(findRes.stdout), { via: "find", outputTruncated: findRes.outputTruncated === true });
 }
 
 const GLOB_CHARS = /[*?[\]{}]/;
@@ -90,9 +135,9 @@ const GLOB_CHARS = /[*?[\]{}]/;
  * fffind: a pattern without glob characters is a fuzzy, typo-tolerant, frecency-ranked path query.
  * Returns "path" rows (best first) or null when the pattern is a real glob.
  */
-export async function fuzzyFind(index, root, cwd, pattern, limit = 20) {
+export async function fuzzyFind(index, root, cwd, pattern, limit = 20, pendingPaths = []) {
   if (!pattern || GLOB_CHARS.test(pattern)) return null;
-  const files = await index.files(root);
+  const files = [...new Set([...await candidateFileList(index, root), ...pendingInScope(root, pendingPaths)])];
 
   if (!index.canScan(files)) return null;
   const rel = files.map((f) => relativeSlash(cwd, f));
@@ -109,12 +154,12 @@ export async function fuzzyFind(index, root, cwd, pattern, limit = 20) {
 }
 
 /** fff-style grep: smart-case, definition lines first, fuzzy fallback when the literal has no hits. */
-export async function grepIndexed(index, pattern, params, searchPath, cwd) {
+export async function grepIndexed(index, pattern, params, searchPath, cwd, overlayText = () => undefined, pendingPaths = []) {
   const compiled = grepRegex(pattern, params);
 
   if (!compiled) return null;
   const { regex, caseSensitive } = compiled;
-  let files = await index.files(searchPath);
+  let files = [...new Set([...await candidateFileList(index, searchPath), ...pendingInScope(searchPath, pendingPaths)])];
 
   if (!index.canScan(files)) return null;
 
@@ -123,14 +168,19 @@ export async function grepIndexed(index, pattern, params, searchPath, cwd) {
     files = files.filter((f) => matcher.test(relativeSlash(cwd, f)));
   }
 
-  const rows = index.grepRows(files, regex, cwd);
-  const fallback = rows.length === 0 && /^[\w$.-]{4,}$/.test(pattern) ? fuzzyGrepRows(index, files, pattern, cwd, caseSensitive) : rows;
+  for (const file of files) {
+    const overlay = overlayText(file);
+
+    if (overlay === undefined && index.entry(file) === null) return null;
+  }
+  const rows = index.grepRows(files, regex, cwd, overlayText);
+  const fallback = rows.length === 0 && /^[\w$.-]{4,}$/.test(pattern) ? fuzzyGrepRows(index, files, pattern, cwd, caseSensitive, overlayText) : rows;
 
   return formatGrepRows(fallback, grepLimit(params));
 }
 
 function grepLimit(params) {
-  return Number.isInteger(params?.limit) && params.limit > 0 ? params.limit : 200;
+  return Number.isInteger(params?.limit) && params.limit > 0 ? Math.min(params.limit, 2000) : 200;
 }
 
 function grepRegex(pattern, params) {
@@ -144,12 +194,15 @@ function grepRegex(pattern, params) {
 }
 
 /** Zero literal hits: retry each line fuzzily (1 typo, 2 for long names) within a tight span, so IsOffTheRecord finds is_off_the_record. */
-function fuzzyGrepRows(index, files, pattern, cwd, caseSensitive) {
+function fuzzyGrepRows(index, files, pattern, cwd, caseSensitive, overlayText = () => undefined) {
   const maxTypos = pattern.length >= 8 ? 2 : 1;
   const rows = [];
 
   for (const filePath of files) {
-    const e = index.entry(filePath);
+    const pending = overlayText(filePath);
+    const e = pending === undefined
+      ? index.entry(filePath)
+      : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(filePath, pending) : null;
 
     if (!e) continue;
     const { raw, defNames } = WorkspaceIndex.linesOf(e);
@@ -197,8 +250,8 @@ function formatGrepRows(rows, limit) {
 }
 
 /** rg --files [-g pattern] served from the index; null when the tree is too large. */
-export async function listIndexed(index, root, cwd, pattern) {
-  const files = await index.files(root);
+export async function listIndexed(index, root, cwd, pattern, pendingPaths = []) {
+  const files = [...new Set([...await candidateFileList(index, root), ...pendingInScope(root, pendingPaths)])];
 
   if (!index.canScan(files)) return null;
   const rel = files.map((f) => path.relative(cwd, f).split(path.sep).join("/"));