pi-hashline-edit-pro 2.8.1 → 2.8.2

package/README.md

@@ -133,7 +133,7 @@ Notes:
 
 ## The grep tool
 
-`grep` replaces the built-in grep with an anchored search. Every matching line (and each requested context line) is returned as an `anchor│content` row, and those rows are recorded in the served state exactly like `read` output, so you can target them with `replace` or `insert` immediately without a separate `read`.
+`grep` replaces the built-in grep with an anchored search backed by ripgrep. Every matching line (and each requested context line) is returned as `lineNumber │ anchor│content` — the `anchor│content` part is served exactly like `read` output, so you can target it with `replace`/`insert` without a separate `read`, while the line-number gutter and `=== path ===` header give filename and line for navigation (press Return to jump).
 
 | Field | Description |
 | --- | --- |
@@ -146,10 +146,10 @@ Notes:
 | `limit` | Maximum number of matched lines to return (default: 100). |
 
 Notes:
-- Results are grouped per file under a `=== path ===` header; every shown row carries the anchor it would have in `read` output.
-- Directory searches skip `node_modules`, `.git`, `.tmp`, and `coverage`. Binary, image, and oversized files are skipped silently.
+- Results are grouped per file under a `=== path ===` header; every shown row is `lineNumber │ anchor│content` where `anchor│content` is the anchor it would have in `read` output.
+- Directory searches use ripgrep, respecting `.gitignore`; `node_modules`, `.git`, `.tmp`, and `coverage` are always skipped. Binary, image, and oversized files are skipped silently.
 - Regex patterns with backreferences, nested quantifiers, quantified alternation, or multiple variable quantifiers are rejected with `[E_UNSAFE_REGEX]` before any files are scanned; use `literal: true` when regex behavior is unnecessary.
-- Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line). Directory scans stop after 4000 files with a hint; results may be incomplete.
+- Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line).
 - `file_path` works as an alias for `path`.
 - Line endings and BOMs survive every edit. The file's line ending is detected from its first newline and restored on write; a file that mixes LF and CRLF (for example a WSL-edited file) is normalized to the first-seen ending.
 - Files with multiple hard links (`nlink > 1`) are rewritten in place rather than via a temp-file rename, so every link keeps seeing the same content; that write is direct rather than atomic.

package/index.ts

@@ -14,13 +14,14 @@ import {
   toggleAutoRead,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { recordServedSafe, clearServed } from "./src/served";
+import { recordServedSafe, clearServed, buildServedMap } from "./src/served";
 import { clearBoundaryBypass } from "./src/boundary-bypass";
 import { registerWriteHook } from "./src/write-hook";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
 import { resolveInCwd } from "./src/fs-write";
 import { valAccess } from "./src/validation";
+import { splitLines } from "./src/utils";
 
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
@@ -37,12 +38,15 @@ export default function (pi: ExtensionAPI): void {
     const active = pi.getActiveTools();
     pi.setActiveTools(active.filter((t) => t !== "edit"));
     await initHasher();
-    try {
-      const store = await loadHashStore();
-      await pruneMissing(store);
-    } catch (err) {
-      console.error("Failed to load or prune hash store:", err);
-    }
+    loadHashStore()
+      .then(store =>
+        pruneMissing(store).catch(err => {
+          console.error("Failed to prune hash store:", err);
+        }),
+      )
+      .catch(err => {
+        console.error("Failed to load hash store:", err);
+      });
     const config = await readConfig();
     autoRead = config.autoRead;
     const debugValue = process.env.PI_HASHLINE_DEBUG;
@@ -95,7 +99,9 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_BYTES,
           DEFAULT_MAX_LINES,
         );
-        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read", new Set(fileHashes));
+        const fileLines = splitLines(normalized);
+        const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
+        await recordServedSafe(absolutePath, servedMap, "auto-read", new Set(fileHashes));
         return {
           content: [
             ...(event.content ?? []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/grep-guidelines.md

@@ -1,3 +1,3 @@
-- `grep`: every hit and `context` line comes back as `anchor│content` — use that anchor directly for `replace`/`insert` without a new `read`.
-- `grep`: use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
-- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.
+- `grep`: every hit and `context` line comes back as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` enables jump-to-line.
+- `grep`: uses ripgrep, respects `.gitignore`; use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
+- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.

package/prompts/grep-snippet.md

@@ -1 +1 @@
-Search with `anchor│content` hits usable directly for `replace`/`insert`; use `literal`/`glob`/`context`
+Search with `lineNumber │ anchor│content` hits usable directly for `replace`/`insert`; use `literal`/`glob`/`context`

package/prompts/grep.md

@@ -1 +1 @@
-Search text files for a pattern. Every hit and each `context` line is returned as `anchor│content` so you can use that anchor directly for `replace`/`insert` without a new `read`. Directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.
+Search text files for a pattern using ripgrep. Every hit and each `context` line is returned as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` and the `=== path ===` header give file and line for navigation. Respects `.gitignore` via ripgrep; directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.

package/src/commit.ts

@@ -4,8 +4,9 @@ import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-res
 import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { recordServedDiffSafe } from "./served";
+import { recordServedSafe, buildServedMap, servedHashesFromDiff } from "./served";
 import { restoreEndings } from "./normalize";
+import { splitLines } from "./utils";
 
 export interface CommitMeta {
   path: string;
@@ -102,7 +103,10 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   };
   const changed = buildChanged(successInput, meta.verb);
   if (changed.details.diff) {
-    await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff", new Set(pipe.resultHashes));
+    const diffHashes = servedHashesFromDiff(changed.details.diff);
+    const resultLines = splitLines(pipe.result);
+    const servedMap = buildServedMap(pipe.resultHashes, resultLines, diffHashes);
+    await recordServedSafe(mutationTargetPath, servedMap, "post-edit diff", new Set(pipe.resultHashes));
   }
   return changed;
 }

package/src/constants.ts

@@ -7,6 +7,6 @@ export const MAX_HASH_SOURCE_BYTES = 500;
 export const MAX_GREP_LINE_BYTES = 500;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 5;
+export const HASH_STORE_VERSION = 6;
 export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "replacement_lines" must be an array of strings, one per line (use [] to delete).`;

package/src/grep.ts

@@ -1,20 +1,20 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { readdir, stat } from "fs/promises";
+import { stat } from "fs/promises";
 import { dirname, join, relative } from "path";
+import { spawn, spawnSync } from "child_process";
+import { createInterface } from "readline";
 import { tryReadNormFile } from "./file-reader";
 import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
 import { MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { recordServedSafe } from "./served";
+import { recordServedSafe, buildServedMap } from "./served";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
-const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
-const MAX_SCAN_FILES = 4000;
 
 function cmp(a: string, b: string): number {
   return a < b ? -1 : a > b ? 1 : 0;
@@ -69,13 +69,11 @@ function unsafeRegex(pattern: string): never {
 
 function assertSafeRegex(pattern: string): void {
   if (pattern.length > 4096) unsafeRegex(pattern);
-
   const groups: RegexGroupRisk[] = [];
   let inClass = false;
   let escaped = false;
   let variableQuantifiers = 0;
   let lastAtom: { groupRisky: boolean; quantified: boolean } | undefined;
-
   for (let i = 0; i < pattern.length; i++) {
     const ch = pattern[i]!;
     if (escaped) {
@@ -122,13 +120,17 @@ function assertSafeRegex(pattern: string): void {
       lastAtom = undefined;
       continue;
     }
-
     let quantifierLength = 0;
     if (ch === "*" || ch === "+" || ch === "?") {
       quantifierLength = 1;
     } else if (ch === "{") {
       quantifierLength = /^\{\d+(?:,\d*)?\}/.exec(pattern.slice(i))?.[0].length ?? 0;
     }
+    if (ch === "{" && quantifierLength > 0) {
+      const quant = pattern.slice(i, i + quantifierLength);
+      const m = /^\{(\d+)/.exec(quant);
+      if (m && Number(m[1]) > 1000) unsafeRegex(pattern);
+    }
     if (quantifierLength > 0 && lastAtom) {
       if (ch === "?" && lastAtom.quantified) continue;
       const variable = ch !== "{" || pattern.slice(i, i + quantifierLength).includes(",");
@@ -140,7 +142,6 @@ function assertSafeRegex(pattern: string): void {
       i += quantifierLength - 1;
       continue;
     }
-
     lastAtom = { groupRisky: false, quantified: false };
   }
 }
@@ -177,8 +178,10 @@ interface FileHit {
   path: string;
   displayPath: string;
   fileHashes: string[];
+  fileLines: string[];
   rows: string[];
   hashes: string[];
+  lineNumbers: number[];
   matchCount: number;
   totalMatchCount: number;
   fragmented: boolean[];
@@ -219,96 +222,41 @@ function grepHeadFragment(line: string): string {
   return head.length < line.length ? `${head}...` : head;
 }
 
-interface ScanState {
-  scanned: number;
-  stopped: boolean;
-}
-
-async function walkFiles(
-  root: string,
-  state: ScanState,
-  onFile: (absPath: string) => Promise<void>,
-  signal?: AbortSignal,
-): Promise<void> {
-  const queue: string[] = [root];
-  let head = 0;
-  while (head < queue.length && !state.stopped) {
-    abortIf(signal);
-    const dir = queue[head++]!;
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    entries.sort((a, b) => cmp(a.name, b.name));
-    for (let ei = 0; ei < entries.length; ei++) {
-      if ((ei & 127) === 0) abortIf(signal);
-      if (state.stopped) break;
-      const entry = entries[ei]!;
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
-        queue.push(full);
-      } else if (entry.isFile()) {
-        state.scanned += 1;
-        if (state.scanned > MAX_SCAN_FILES) {
-          state.stopped = true;
-          break;
-        }
-        await onFile(full);
-      }
-    }
-  }
-}
-
-async function searchFile(
-  absPath: string,
-  globRoot: string,
-  cwd: string,
-  regex: RegExp,
-  globRegex: RegExp | undefined,
+function makeHitFromIndices(
+  norm: { normalized: string; fileHashes: string[]; absolutePath: string },
+  displayPath: string,
+  matchIndices: number[],
   context: number,
-  maxMatches: number,
-  signal?: AbortSignal,
-): Promise<FileHit | undefined> {
-  const displayPath = relative(cwd, absPath).replace(/\\/g, "/");
-  if (globRegex) {
-    const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
-    if (!globRegex.test(globPath) && !globRegex.test(displayPath)) return undefined;
-  }
-  const norm = await tryReadNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
-  if (!norm) return undefined;
+  regex: RegExp | undefined,
+  totalMatchCount: number,
+  keptMatchCount: number,
+): FileHit {
   const lines = visLines(norm.normalized);
-  const matchLines: number[] = [];
-  for (let i = 0; i < lines.length; i++) {
-    if ((i & 1023) === 0) abortIf(signal);
-    if (i !== 0 && (i & 4095) === 0) await new Promise<void>((r) => setImmediate(r));
-    if (regex.test(lines[i]!)) matchLines.push(i);
-  }
-  if (matchLines.length === 0) return undefined;
-  const keptMatches = matchLines.length > maxMatches ? matchLines.slice(0, maxMatches) : matchLines;
   const shown = new Set<number>();
-  for (const i of keptMatches) {
+  const kept = matchIndices.slice(0, keptMatchCount);
+  for (const i of kept) {
     for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
   }
   const sorted = [...shown].sort((a, b) => a - b);
-  const matchSet = new Set(matchLines);
+  const matchSet = new Set(matchIndices);
   const rows: string[] = [];
   const hashes: string[] = [];
+  const lineNumbers: number[] = [];
   const fragmented: boolean[] = [];
   for (const idx of sorted) {
     const hash = norm.fileHashes[idx]!;
     const line = lines[idx]!;
     const row = fmtRow(hash, line);
     if (Buffer.byteLength(row, "utf-8") > MAX_GREP_LINE_BYTES) {
-      const content = matchSet.has(idx) ? grepMatchFragment(line, regex) : grepHeadFragment(line);
+      const content = matchSet.has(idx) && regex ? grepMatchFragment(line, regex) : grepHeadFragment(line);
       rows.push(fmtRow(hash, content));
       hashes.push(hash);
+      lineNumbers.push(idx + 1);
       fragmented.push(true);
     } else {
       rows.push(row);
       hashes.push(hash);
+      lineNumbers.push(idx + 1);
       fragmented.push(false);
     }
   }
@@ -316,14 +264,142 @@ async function searchFile(
     path: norm.absolutePath,
     displayPath,
     fileHashes: norm.fileHashes,
+    fileLines: lines,
     rows,
     hashes,
-    matchCount: keptMatches.length,
-    totalMatchCount: matchLines.length,
+    lineNumbers,
+    matchCount: kept.length,
+    totalMatchCount,
     fragmented,
   };
 }
 
+async function resolveRgPath(): Promise<string> {
+  try {
+    const r = spawnSync("rg", ["--version"], { stdio: "pipe" });
+    if (!r.error && r.status === 0) return "rg";
+  } catch {}
+  try {
+    const { homedir } = await import("os");
+    const { existsSync } = await import("fs");
+    const home = process.env.HOME ?? homedir();
+    const base = process.env.PI_CODING_AGENT_DIR ?? join(home, ".pi", "agent");
+    const bin = join(base, "bin", process.platform === "win32" ? "rg.exe" : "rg");
+    if (existsSync(bin)) {
+      const r = spawnSync(bin, ["--version"], { stdio: "pipe" });
+      if (!r.error && r.status === 0) return bin;
+    }
+  } catch {}
+  try {
+    const { createRequire } = await import("module");
+    const require = createRequire(import.meta.url);
+    const pkgPath = require.resolve("@earendil-works/pi-coding-agent/package.json");
+    const { dirname } = await import("path");
+    const piDir = dirname(pkgPath);
+    const toolsManagerPath = join(piDir, "dist/utils/tools-manager.js");
+    const mod = await import("file://" + toolsManagerPath);
+    if (mod.ensureTool) {
+      const p = await mod.ensureTool("rg", true);
+      if (p) return p;
+    }
+  } catch {}
+  throw new Error("[E_ACCESS] ripgrep (rg) is required for grep but was not found. Install ripgrep or ensure pi can download it to ~/.pi/agent/bin.");
+}
+
+async function collectRgMatches(
+  rgPath: string,
+  pattern: string,
+  searchPath: string,
+  req: GrepReq,
+  signal?: AbortSignal,
+): Promise<Map<string, number[]>> {
+  const args = ["--json", "--line-number", "--color=never", "--hidden"];
+  if (req.ignoreCase) args.push("--ignore-case");
+  if (req.literal) args.push("--fixed-strings");
+  args.push("--", pattern, searchPath);
+  const result = new Map<string, number[]>();
+  return await new Promise<Map<string, number[]>>((resolve, reject) => {
+    const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const rl = createInterface({ input: child.stdout });
+    let stderr = "";
+    let timedOut = false;
+    const rgTimeout = setTimeout(() => {
+      timedOut = true;
+      if (!child.killed) child.kill("SIGKILL");
+      reject(new Error("rg timeout"));
+    }, 10000);
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const onAbort = () => {
+      if (!child.killed) child.kill("SIGKILL");
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const cleanup = () => {
+      clearTimeout(rgTimeout);
+      rl.close();
+      signal?.removeEventListener("abort", onAbort);
+    };
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      let event: { type?: string; data?: { path?: { text?: string }; line_number?: number } };
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (event.type === "match") {
+        const filePath = event.data?.path?.text;
+        const lineNumber = event.data?.line_number;
+        if (typeof filePath === "string" && typeof lineNumber === "number") {
+          let abs: string;
+          try {
+            abs = filePath.startsWith("/") || /^[A-Za-z]:\\/.test(filePath) ? filePath : join(searchPath, filePath);
+          } catch {
+            abs = filePath;
+          }
+          const list = result.get(abs) ?? [];
+          list.push(lineNumber);
+          result.set(abs, list);
+        }
+      }
+    });
+    child.on("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      if (timedOut) return;
+      if (signal?.aborted) {
+        reject(new Error("Operation aborted"));
+        return;
+      }
+      if (code !== 0 && code !== 1) {
+        const msg = stderr.trim() || `ripgrep exited with code ${code}`;
+        reject(new Error(msg));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+function gutterWidthFor(numbers: number[]): number {
+  let max = 0;
+  for (const n of numbers) if (n > max) max = n;
+  return String(max || 1).length;
+}
+
+function displayRowsForHit(hit: FileHit): string[] {
+  const width = gutterWidthFor(hit.lineNumbers);
+  return hit.rows.map((row, i) => {
+    const n = hit.lineNumbers[i]!;
+    const padded = String(n).padStart(width, " ");
+    return `${padded} │ ${row}`;
+  });
+}
+
 const grepToolSchema = Type.Object(
   {
     pattern: Type.String({
@@ -380,10 +456,8 @@ export function regGrep(pi: ExtensionAPI): void {
       const canonical = normReq(params);
       assertGrepReq(canonical);
       const req = canonical;
-      const regex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
       const context = req.context ?? 0;
       const limit = req.limit ?? 100;
-      const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
       const base = req.path ? toCwd(req.path, ctx.cwd) : ctx.cwd;
       abortIf(signal);
       let baseStat;
@@ -396,16 +470,9 @@ export function regGrep(pi: ExtensionAPI): void {
         throw new Error(`[E_ACCESS] Cannot access path: ${req.path ?? ctx.cwd}`);
       }
       const globRoot = baseStat.isFile() ? dirname(base) : base;
-      const state: ScanState = { scanned: 0, stopped: false };
-      const files: string[] = [];
-      if (baseStat.isFile()) {
-        files.push(base);
-      } else {
-        await walkFiles(base, state, async (absPath) => {
-          files.push(absPath);
-        }, signal);
-        files.sort(cmp);
-      }
+      const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+      const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
+      const rgPath = await resolveRgPath();
       const hits: FileHit[] = [];
       let matches = 0;
       let limitTruncated = false;
@@ -417,17 +484,26 @@ export function regGrep(pi: ExtensionAPI): void {
       let truncatedBy: "lines" | "bytes" | null = null;
       let linesReplaced = 0;
       let countOnly = false;
-      for (let f = 0; f < files.length; f++) {
+      const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
+      const sortedFiles = [...rgMatches.keys()].sort(cmp);
+      for (let f = 0; f < sortedFiles.length; f++) {
         abortIf(signal);
-        const absPath = files[f]!;
+        const absPath = sortedFiles[f]!;
+        const allNums = rgMatches.get(absPath) ?? [];
+        const totalForFile = allNums.length;
+        const sortedNums = [...allNums].sort((a, b) => a - b);
+        const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
         if (countOnly) {
-          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER, signal);
-          if (!hit) continue;
-          totalRows += hit.rows.length;
-          for (const row of hit.rows) totalBytes += Buffer.byteLength(row, "utf-8") + 1;
+          const norm = await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
+          if (!norm) continue;
+          const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
+          const display = displayRowsForHit(hit);
+          totalRows += display.length;
+          for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
           const remaining = limit - matches;
           if (remaining > 0) {
-            matches += Math.min(hit.matchCount, remaining);
+            const add = Math.min(hit.matchCount, remaining);
+            matches += add;
             if (hit.matchCount > remaining) limitTruncated = true;
           } else {
             limitTruncated = true;
@@ -439,24 +515,36 @@ export function regGrep(pi: ExtensionAPI): void {
           limitTruncated = true;
           break;
         }
-        const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining, signal);
+        const norm = await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
+        if (!norm) continue;
+        if (globRegex) {
+          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
+          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+          if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
+        }
+        const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
         if (!hit) continue;
+        const display = displayRowsForHit(hit);
         const keptRows: string[] = [];
         const keptHashes: string[] = [];
-        for (let i = 0; i < hit.rows.length; i++) {
-          const row = hit.rows[i]!;
+        const keptLineNumbers: number[] = [];
+        const keptFragmented: boolean[] = [];
+        for (let i = 0; i < display.length; i++) {
+          const row = display[i]!;
           const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
           if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
             rowTruncated = true;
             if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
-            for (let j = i; j < hit.rows.length; j++) {
+            for (let j = i; j < display.length; j++) {
               totalRows += 1;
-              totalBytes += Buffer.byteLength(hit.rows[j]!, "utf-8") + 1;
+              totalBytes += Buffer.byteLength(display[j]!, "utf-8") + 1;
             }
             break;
           }
           keptRows.push(row);
-          keptHashes.push(hit.hashes[i]);
+          keptHashes.push(hit.hashes[i]!);
+          keptLineNumbers.push(hit.lineNumbers[i]!);
+          keptFragmented.push(hit.fragmented[i]!);
           if (hit.fragmented[i]) linesReplaced += 1;
           rowCount += 1;
           byteCount += rowBytes;
@@ -465,12 +553,14 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
         matches += hit.matchCount;
-        hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+        const displayHit: FileHit = { ...hit, rows: keptRows, hashes: keptHashes, lineNumbers: keptLineNumbers, fragmented: keptFragmented };
+        hits.push(displayHit);
         if (rowTruncated) countOnly = true;
       }
       hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
       for (const hit of hits) {
-        await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
+        const servedMap = buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes);
+        await recordServedSafe(hit.path, servedMap, "grep", new Set(hit.fileHashes));
       }
       const blocks = hits
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
@@ -478,7 +568,6 @@ export function regGrep(pi: ExtensionAPI): void {
       const notes: string[] = [];
       if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
-      if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
       if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
       const truncated = limitTruncated || rowTruncated;
       const truncation: TruncationResult | undefined = rowTruncated
@@ -505,7 +594,7 @@ export function regGrep(pi: ExtensionAPI): void {
           metrics: {
             matches,
             files: hits.length,
-            truncated: truncated || state.stopped,
+            truncated,
           },
         },
       };

package/src/hash-store/validation.ts

@@ -9,6 +9,15 @@ export function isValidHashList(value: unknown): value is string[] {
   return true;
 }
 
+export function isValidServedMap(value: unknown): value is Record<string, string> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof k !== "string" || !HASH_RE.test(k)) return false;
+    if (typeof v !== "string") return false;
+  }
+  return true;
+}
+
 export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
   let parsed: unknown;
   try {
@@ -26,11 +35,33 @@ export function parseHashList(raw: string, onInvalid: () => void, context?: stri
   return parsed;
 }
 
+export function parseServedMap(raw: string, onInvalid: () => void, context?: string): Map<string, string> | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    console.error(`[parseServedMap]${context ? ` ${context}:` : ""} failed to parse stored served JSON:`, error);
+    onInvalid();
+    return undefined;
+  }
+  if (!isValidServedMap(parsed)) {
+    console.error(`[parseServedMap]${context ? ` ${context}:` : ""} stored served did not pass validation:`, (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
+    onInvalid();
+    return undefined;
+  }
+  return new Map(Object.entries(parsed as Record<string, string>));
+}
+
 export function parseStoredHashes(row: Record<string, unknown> | undefined, onInvalid: () => void): string[] | undefined {
   if (!row) return undefined;
   return parseHashList(row.hashes as string, onInvalid);
 }
 
+export function parseStoredServed(row: Record<string, unknown> | undefined, onInvalid: () => void): Map<string, string> | undefined {
+  if (!row) return undefined;
+  return parseServedMap(row.hashes as string, onInvalid);
+}
+
 export function isValidSnapshot(value: unknown): value is { content: string; hashes: string[] } {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;

package/src/hash-store.ts

@@ -6,10 +6,13 @@ import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
 import {
   isValidHashList,
+  isValidServedMap,
   parseStoredHashes,
+  parseStoredServed,
   isValidSnapshot,
   isCorruptionError,
   parseHashList,
+  parseServedMap,
 } from "./hash-store/validation";
 import {
   withBusyRetry,
@@ -22,7 +25,7 @@ import {
   SNAPSHOT_CACHE_LIMIT,
 } from "./hash-store/cache";
 
-export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
+export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
@@ -272,6 +275,20 @@ async function openStore(storePath: string): Promise<HashStore> {
     opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   }
   const { db, stmts } = opened;
+  try {
+    const autoVacuum = (db.prepare("PRAGMA auto_vacuum").get() as { auto_vacuum: number }).auto_vacuum;
+    const pageCount = (db.prepare("PRAGMA page_count").get() as { page_count: number }).page_count;
+    const freelist = (db.prepare("PRAGMA freelist_count").get() as { freelist_count: number }).freelist_count;
+    if (autoVacuum === 0 && !existed) {
+      db.exec("PRAGMA auto_vacuum=INCREMENTAL");
+    } else if (freelist > 50 && freelist * 5 > pageCount) {
+      try {
+        db.exec("PRAGMA incremental_vacuum(50)");
+      } catch {
+        db.exec("VACUUM");
+      }
+    }
+  } catch {}
 
   if (process.platform !== "win32") {
     for (const candidate of [storePath, `${storePath}-wal`, `${storePath}-shm`]) {
@@ -551,10 +568,37 @@ function matchPathsByHashes(
   return matches;
 }
 
+function matchPathsByServed(
+  rows: { path: string; hashes: string }[],
+  hashes: string[],
+): string[] {
+  const needed = new Set(hashes);
+  if (needed.size === 0) return [];
+  const matches: string[] = [];
+  for (const row of rows) {
+    try {
+      const parsed = JSON.parse(row.hashes) as unknown;
+      if (!isValidServedMap(parsed)) continue;
+      const keySet = new Set(Object.keys(parsed as Record<string, unknown>));
+      let ok = true;
+      for (const h of needed) {
+        if (!keySet.has(h)) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) matches.push(row.path);
+    } catch {
+      continue;
+    }
+  }
+  return matches;
+}
+
 export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
   return matchPathsByHashes(store.stmts.allHashes() as { path: string; hashes: string }[], hashes);
 }
 
 export function findServedPaths(store: HashStore, hashes: string[]): string[] {
-  return matchPathsByHashes(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
+  return matchPathsByServed(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
 }

package/src/hashline/apply.ts

@@ -154,7 +154,7 @@ export function applyEdit(
 	signal?: AbortSignal,
 	precomputedHashes?: string[],
 	filePath?: string,
-	servedHashes?: ReadonlySet<string>,
+	servedHashes?: ReadonlyMap<string, string>,
 	skipBoundaryDedup?: boolean,
 	): {
 	content: string;
@@ -190,7 +190,7 @@ export function applyEdit(
 			fileHashes,
 			filePath,
 		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes);
+		throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
 	}
 
 	warnUnicodeEsc(prefixFixed, warnings);
@@ -233,7 +233,7 @@ export function applyEdit(
 				fileHashes,
 				filePath,
 			);
-			throw new AnchorMismatchError(feedback.text, feedback.hashes);
+			throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
 		}
 		resolved = correctedResult.resolved;
 	}

package/src/hashline/resolve.ts

@@ -2,6 +2,7 @@ import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, cl
 import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
+import { contentChecksum } from "./hasher";
 
 export type RAnchor = {
 	line: number;
@@ -90,14 +91,13 @@ export function fmtMismatchWithHashes(
   fileLines: string[],
   fileHashes: string[],
   filePath?: string,
-): { text: string; hashes: string[] } {
+): { text: string; hashes: string[]; servedMap: Map<string, string> } {
   assertAligned(fileLines, fileHashes, "fmtMismatch");
-
   const out: string[] = [];
   const hashes: string[] = [];
+  const servedMap = new Map<string, string>();
   const notFound = mismatches.filter((m) => m.kind === "not_found");
   const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
-
   const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
   if (notFound.length > 0) {
     out.push(
@@ -110,8 +110,11 @@ export function fmtMismatchWithHashes(
       const to = Math.min(fileLines.length, ctx.line + 1);
       const rows: string[] = [];
       for (let ln = from; ln <= to; ln++) {
-        hashes.push(fileHashes[ln - 1]!);
-        rows.push(`    ${ln}: ${fileHashes[ln - 1]}│${clipLine(fileLines[ln - 1] ?? "")}`);
+        const h = fileHashes[ln - 1]!;
+        const c = fileLines[ln - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+        rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
@@ -128,7 +131,12 @@ export function fmtMismatchWithHashes(
         (m.candidates?.length ?? 0) > sample.length
           ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)`
           : "";
-      for (const line of sample) hashes.push(fileHashes[line - 1]!);
+      for (const line of sample) {
+        const h = fileHashes[line - 1]!;
+        const c = fileLines[line - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+      }
       const lines = sample
         .map((line) => {
           const content = clipLine(fileLines[line - 1] ?? "");
@@ -140,8 +148,7 @@ export function fmtMismatchWithHashes(
         );
     }
   }
-
-  return { text: out.join("\n"), hashes };
+  return { text: out.join("\n"), hashes, servedMap };
 }
 
 
@@ -482,45 +489,49 @@ export function valEdit(
 }
 
 export function resolveAnchorLine(
-	ref: Anchor,
-	fileLines: string[],
-	fileHashes: string[],
-	filePath?: string,
+  ref: Anchor,
+  fileLines: string[],
+  fileHashes: string[],
+  filePath?: string,
 ): number {
-	const { resolved, mismatches } = valEdit(
-		{ hash_bounds: [ref, ref], content_lines: [] },
-		fileLines,
-		fileHashes,
-		[],
-		undefined,
-	);
-	if (mismatches.length > 0 || !resolved) {
-		const feedback = fmtMismatchWithHashes(
-			mismatches,
-			fileLines,
-			fileHashes,
-			filePath,
-		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes);
-	}
-	return resolved.hash_bounds[0].line;
+  const { resolved, mismatches } = valEdit(
+    { hash_bounds: [ref, ref], content_lines: [] },
+    fileLines,
+    fileHashes,
+    [],
+    undefined,
+  );
+  if (mismatches.length > 0 || !resolved) {
+    const feedback = fmtMismatchWithHashes(
+      mismatches,
+      fileLines,
+      fileHashes,
+      filePath,
+    );
+    throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+  }
+  return resolved.hash_bounds[0].line;
 }
 
 export class RangeStaleError extends Error {
   readonly rangeHashes: string[];
-  constructor(message: string, rangeHashes: string[]) {
+  readonly rangeServedMap: Map<string, string>;
+  constructor(message: string, rangeHashes: string[], rangeServedMap: Map<string, string>) {
     super(message);
     this.name = "RangeStaleError";
     this.rangeHashes = rangeHashes;
+    this.rangeServedMap = rangeServedMap;
   }
 }
 
 export class AnchorMismatchError extends Error {
   readonly feedbackHashes: string[];
-  constructor(message: string, feedbackHashes: string[]) {
+  readonly feedbackMap: Map<string, string>;
+  constructor(message: string, feedbackHashes: string[], feedbackMap: Map<string, string>) {
     super(message);
     this.name = "AnchorMismatchError";
     this.feedbackHashes = feedbackHashes;
+    this.feedbackMap = feedbackMap;
   }
 }
 
@@ -528,7 +539,7 @@ export function assertRangeServed(
   resolved: RHEdit,
   fileLines: string[],
   fileHashes: string[],
-  served: ReadonlySet<string>,
+  served: ReadonlyMap<string, string> | undefined,
   filePath?: string,
 ): void {
   assertAligned(fileLines, fileHashes, "assertRangeServed");
@@ -536,18 +547,23 @@ export function assertRangeServed(
   const endLine = resolved.hash_bounds[1].line;
   const mismatchLines: number[] = [];
   for (let line = startLine; line <= endLine; line++) {
-    if (!served.has(fileHashes[line - 1]!)) mismatchLines.push(line);
+    const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
+    const servedContent = served?.get(hash);
+    if (servedContent === undefined || servedContent !== contentChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
-
   const rangeLength = endLine - startLine + 1;
   const shownLength = Math.min(rangeLength, MAX_RANGE_STALE_LINES);
   const rows: string[] = [];
   const shownHashes: string[] = [];
+  const shownMap = new Map<string, string>();
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
+    shownMap.set(hash, contentChecksum(content));
+    rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -561,7 +577,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, shownHashes);
+  throw new RangeStaleError(message, shownHashes, shownMap);
 }
 
 export { warnUnicodeEsc };

package/src/read.ts

@@ -13,8 +13,8 @@ import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, makePrepareArguments, numberedRead, visLines } from "./utils";
-import { recordServedSafe } from "./served";
+import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
+import { recordServedSafe, buildServedMap } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
 import { Text } from "@earendil-works/pi-tui";
@@ -236,7 +236,9 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			await recordServedSafe(resolvedPath, preview.servedHashes, "read", new Set(fileHashes));
+			const fileLines = splitLines(normalized);
+			const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
+			await recordServedSafe(resolvedPath, servedMap, "read", new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors

package/src/replace-undo.ts

@@ -4,11 +4,11 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
-import { recordServedDiff } from "./served";
+import { recordServed, buildServedMap, servedHashesFromDiff } from "./served";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
 import { genDiff, genPatch } from "./replace-diff";
-import { cntDiff, errCode, makePrepareArguments } from "./utils";
+import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
 import { renderEditResult } from "./replace-render";
@@ -172,7 +172,10 @@ export function regUndo(pi: ExtensionAPI): void {
         try {
           const store = await loadHashStore();
           persistSnapshot(store, mutationTargetPath, undo.content, undo.hashes);
-          recordServedDiff(store, mutationTargetPath, undoDiff, new Set(undo.hashes));
+          const diffHashes = servedHashesFromDiff(undoDiff);
+          const undoLines = splitLines(undo.content);
+          const servedMap = buildServedMap(undo.hashes, undoLines, diffHashes);
+          recordServed(store, mutationTargetPath, servedMap, new Set(undo.hashes));
         } catch (error) {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }

package/src/replace.ts

@@ -119,8 +119,8 @@ function hashSpan(hashes: string[], from: string, to: string): [number, number]
 }
 async function noteAnchorError(absolutePath: string, error: unknown, scopeHashes: string[], noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
-  if (error instanceof RangeStaleError) await recordServedSafe(absolutePath, error.rangeHashes, "range-stale feedback", new Set(scopeHashes));
-  else if (error instanceof AnchorMismatchError) await recordServedSafe(absolutePath, error.feedbackHashes, "anchor-mismatch feedback", new Set(scopeHashes));
+  if (error instanceof RangeStaleError) await recordServedSafe(absolutePath, error.rangeServedMap, "range-stale feedback", new Set(scopeHashes));
+  else if (error instanceof AnchorMismatchError) await recordServedSafe(absolutePath, error.feedbackMap, "anchor-mismatch feedback", new Set(scopeHashes));
 }
 
 function collectRemovedHashes(

package/src/served.ts

@@ -1,5 +1,6 @@
-import { loadHashStore, parseStoredHashes, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
+import { loadHashStore, parseStoredServed, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
+import { contentChecksum } from "./hashline/hasher";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
 
@@ -12,60 +13,88 @@ export function servedHashesFromDiff(diff: string): string[] {
   return hashes;
 }
 
-export function getServed(store: HashStore, path: string): Set<string> | undefined {
+export function servedMapFromDiff(diff: string): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const line of diff.split("\n")) {
+    const match = SERVED_DIFF_ROW_RE.exec(line);
+    if (!match) continue;
+    const hash = match[1]!;
+    const content = line.slice(match[0].length);
+    map.set(hash, contentChecksum(content));
+  }
+  return map;
+}
+
+export function buildServedMap(fileHashes: string[], fileLines: string[], wantedHashes: string[]): Map<string, string> {
+  const index = new Map<string, number>();
+  for (let i = 0; i < fileHashes.length; i++) index.set(fileHashes[i]!, i);
+  const map = new Map<string, string>();
+  for (const h of wantedHashes) {
+    const idx = index.get(h);
+    if (idx !== undefined) map.set(h, contentChecksum(fileLines[idx]!));
+  }
+  return map;
+}
+
+export function getServed(store: HashStore, path: string): Map<string, string> | undefined {
   const row = store.stmts.servedGet(path);
-  const parsed = parseStoredHashes(row, () => store.stmts.servedDelete(path));
+  const parsed = parseStoredServed(row, () => store.stmts.servedDelete(path));
   if (!parsed) return undefined;
-  return new Set(parsed);
+  return parsed;
 }
 
 function computeUpdate(
   store: HashStore,
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   scope?: ReadonlySet<string>,
-): Set<string> | undefined {
+): Map<string, string> | undefined {
   const existing = getServed(store, path);
-  if (!existing && hashes.length === 0) return undefined;
-  const set = existing ?? new Set<string>();
+  if (!existing && entries.size === 0 && !scope) return undefined;
+  const map = existing ? new Map(existing) : new Map<string, string>();
   let changed = false;
   if (scope) {
-    for (const hash of set) {
+    for (const hash of [...map.keys()]) {
       if (!scope.has(hash)) {
-        set.delete(hash);
+        map.delete(hash);
         changed = true;
       }
     }
   }
-  for (const hash of hashes) {
-    if (!set.has(hash)) {
-      set.add(hash);
+  for (const [hash, content] of entries) {
+    const prev = map.get(hash);
+    if (prev !== content) {
+      map.set(hash, content);
       changed = true;
     }
   }
-  if (!changed) return undefined;
-  return set;
+  if (!changed && existing) return undefined;
+  if (map.size === 0 && (!existing || existing.size === 0)) return undefined;
+  if (!changed) return existing;
+  return map;
 }
 
 export function recordServed(
   store: HashStore,
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   scope?: ReadonlySet<string>,
 ): void {
   try {
     withStore(() => {
-      const set = computeUpdate(store, path, hashes, scope);
-      if (!set) return;
-      store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
+      const map = computeUpdate(store, path, entries, scope);
+      if (!map) return;
+      const obj = Object.fromEntries(map);
+      store.stmts.servedUpsert(path, JSON.stringify(obj), Date.now());
     });
     return;
   } catch (error) {
     if (!(error instanceof Error && error.message === STORE_NOT_OPEN_MESSAGE)) throw error;
   }
-  const set = computeUpdate(store, path, hashes, scope);
-  if (!set) return;
-  store.stmts.servedUpsert(path, JSON.stringify([...set]), Date.now());
+  const map = computeUpdate(store, path, entries, scope);
+  if (!map) return;
+  const obj = Object.fromEntries(map);
+  store.stmts.servedUpsert(path, JSON.stringify(obj), Date.now());
 }
 
 export function recordServedDiff(
@@ -74,7 +103,7 @@ export function recordServedDiff(
   diff: string,
   scope?: ReadonlySet<string>,
 ): void {
-  recordServed(store, path, servedHashesFromDiff(diff), scope);
+  recordServed(store, path, servedMapFromDiff(diff), scope);
 }
 
 export function clearServed(store: HashStore, path: string): void {
@@ -83,14 +112,14 @@ export function clearServed(store: HashStore, path: string): void {
 
 export async function recordServedSafe(
   path: string,
-  hashes: string[],
+  entries: Map<string, string>,
   context: string,
   scope?: ReadonlySet<string>,
 ): Promise<void> {
-  if (hashes.length === 0 && !scope) return;
+  if (entries.size === 0 && !scope) return;
   try {
     const store = await loadHashStore();
-    recordServed(store, path, hashes, scope);
+    recordServed(store, path, entries, scope);
   } catch (error) {
     console.error(`Failed to record served state (${context}):`, error);
   }
@@ -103,5 +132,5 @@ export async function recordServedDiffSafe(
   scope?: ReadonlySet<string>,
 ): Promise<void> {
   if (!diff) return;
-  await recordServedSafe(path, servedHashesFromDiff(diff), context, scope);
+  await recordServedSafe(path, servedMapFromDiff(diff), context, scope);
 }

package/src/write-hook.ts

@@ -8,19 +8,19 @@ import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
 const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
 
-function searchEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+function searchEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   for (let i = 0; i < lines.length; i++) {
     const match = HASH_ECHO_RE.exec(lines[i]!);
-    if (match && served.has(match[1]!)) return { line: i + 1, hash: match[1]! };
+    if (match && served.has(match[1]! as never)) return { line: i + 1, hash: match[1]! };
   }
   return undefined;
 }
 
-export function findServedHashEcho(content: string, served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+export function findServedHashEcho(content: string, served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   return searchEcho(splitLines(content), served);
 }
 
-export function findEditHashEcho(lines: string[], served: ReadonlySet<string>): { line: number; hash: string } | undefined {
+export function findEditHashEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   return searchEcho(lines, served);
 }