pi-hashline-edit-pro 3.0.4 → 4.0.0

package/src/edit-common.ts

@@ -1,18 +1,38 @@
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
+import { ownerOf } from "./anchor-registry";
+import { parseHashRef, stripAnchorRow } from "./hashline";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
 
 export const editPrepare = makePrepareArguments();
 
-export function editRenderResultWrapper(
-  result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
-  opts: { isPartial: boolean; expanded?: boolean } | boolean,
-  theme: FgT,
-  context: any,
-) {
-  return renderEditResult(result, opts, theme, context);
+export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
+  const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
+  const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));
+  const missing = owners.findIndex((owner) => !owner);
+  if (missing >= 0) {
+    throw new Error(
+      `[E_STALE_ANCHOR] "${refs[missing]!}" is not owned in this session. Call read() on the target file first.`,
+    );
+  }
+  const paths = new Set(owners.map((owner) => owner!.path));
+  if (paths.size > 1) {
+    throw new Error(
+      `[E_BAD_SHAPE] The anchors are owned by different files (${owners.map((owner) => owner!.path).join(", ")}); edit one file per call.`,
+    );
+  }
+  return owners[0]!.path;
+}
+
+export function tryResolveEditTarget(removeFrom: string | undefined, removeTo?: string): string | undefined {
+  if (typeof removeFrom !== "string") return undefined;
+  try {
+    return resolveEditTarget(removeFrom, removeTo);
+  } catch {
+    return undefined;
+  }
 }
 
 export function editRenderCallWrapper(
@@ -20,7 +40,24 @@ export function editRenderCallWrapper(
   getInput?: (args: unknown) => { path?: string } | null,
   toolName?: string,
 ) {
-  return makeRenderCall(preview, { getInput, toolName });
+  return makeRenderCall(preview, {
+    getInput,
+    toolName,
+    resolveTarget: (input) => {
+      if (typeof input.remove_from === "string") return tryResolveEditTarget(input.remove_from, input.remove_to);
+      if (typeof input.anchor === "string") return tryResolveEditTarget(input.anchor);
+      return undefined;
+    },
+  });
+}
+
+export function editRenderResultWrapper(
+  result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
+  opts: { isPartial: boolean; expanded?: boolean } | boolean,
+  theme: FgT,
+  context: any,
+) {
+  return renderEditResult(result, opts, theme, context);
 }
 
 export const editToolBase = {

package/src/file-reader.ts

@@ -7,6 +7,7 @@ import { resolveTarget, type FileIdentity } from "./fs-write";
 import { toCwd } from "./paths";
 import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
 import { abortIf, errCode, assertLineLimit } from "./utils";
+import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
 import { valKind, valAccess } from "./validation";
 import type { HashStore } from "./hash-store";
 export interface NormFile {
@@ -66,6 +67,7 @@ export interface ReadNormOptions {
   maxLines?: number;
   store?: HashStore;
   noPersist?: boolean;
+  allocation?: "real" | "shadow";
 }
 
 export async function readNormFile(
@@ -94,7 +96,7 @@ export async function readNormFile(
 
   if (options?.maxLines !== undefined) assertLineLimit(normalized, path, options.maxLines);
 
-  const fileHashes = await lineHashes(normalized, resolvedPath, undefined, options?.store, options?.noPersist !== true);
+  const fileHashes = await lineHashes(normalized, resolvedPath, undefined, options?.store, options?.noPersist !== true, options?.allocation === "shadow");
   let identity = file.identity;
   if (!identity) {
     const { dev, ino } = await stat(resolvedPath);
@@ -126,6 +128,7 @@ export async function tryReadNormFile(
     if (code === "EACCES" || code === "EPERM" || code === "ENOENT" || code === "ELOOP") return undefined;
     if (error instanceof Error) {
       const msg = error.message;
+      if (msg.startsWith(ANCHOR_POOL_EXHAUSTED_PREFIX)) throw error;
       if (msg.startsWith("[E_FILE_TOO_LARGE]") || msg.startsWith("[E_NOT_FOUND]") || msg.startsWith("[E_ACCESS]") || msg.startsWith("[E_NOT_TEXT]")) return undefined;
     }
     throw error;

package/src/grep.ts

@@ -7,19 +7,23 @@ 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 { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { recordServedSafe, buildServedMap } from "./served";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
-
+import { markServed as markServedScoped } from "./anchor-registry";
+import { buildServedMap } from "./served";
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 
 function cmp(a: string, b: string): number {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
+function isPoolExhaustedError(error: unknown): boolean {
+  return error instanceof Error && error.message.startsWith(ANCHOR_POOL_EXHAUSTED_PREFIX);
+}
+
 export interface GrepReq {
   pattern: string;
   path?: string;
@@ -491,6 +495,16 @@ export function regGrep(pi: ExtensionAPI): void {
       let truncatedBy: "lines" | "bytes" | null = null;
       let linesReplaced = 0;
       let countOnly = false;
+      let poolSkipped = 0;
+      const readGrepFile = async (absPath: string) => {
+        try {
+          return await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, allocation: "real", signal });
+        } catch (error) {
+          if (!isPoolExhaustedError(error)) throw error;
+          poolSkipped += 1;
+          return undefined;
+        }
+      };
       const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
       const sortedFiles = [...rgMatches.keys()].sort(cmp);
       for (let f = 0; f < sortedFiles.length; f++) {
@@ -506,7 +520,7 @@ export function regGrep(pi: ExtensionAPI): void {
             const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
             if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
           }
-          const norm = await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
+          const norm = await readGrepFile(absPath);
           if (!norm) continue;
           const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
           const display = displayRowsForHit(hit);
@@ -532,7 +546,7 @@ export function regGrep(pi: ExtensionAPI): void {
           const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
           if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
         }
-        const norm = await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
+        const norm = await readGrepFile(absPath);
         if (!norm) continue;
         const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
         if (!hit) continue;
@@ -571,8 +585,7 @@ export function regGrep(pi: ExtensionAPI): void {
       }
       hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
       for (const hit of hits) {
-        const servedMap = buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes);
-        await recordServedSafe(hit.path, servedMap, "anchor_grep", new Set(hit.fileHashes));
+        markServedScoped(hit.path, buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes), new Set(hit.fileHashes));
       }
       const blocks = hits
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
@@ -581,6 +594,7 @@ export function regGrep(pi: ExtensionAPI): void {
       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 (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.]`);
+      if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; free anchors with /clear-anchors or narrow the search.]`);
       const truncated = limitTruncated || rowTruncated;
       const truncation: TruncationResult | undefined = rowTruncated
         ? {
@@ -597,7 +611,11 @@ export function regGrep(pi: ExtensionAPI): void {
             maxBytes: DEFAULT_MAX_BYTES,
           }
         : undefined;
-      const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
+      const text = blocks.length > 0
+        ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}`
+        : notes.length > 0
+          ? `No matches found.\n${notes.join("\n")}`
+          : "No matches found.";
       return {
         content: [{ type: "text", text }],
         details: {

package/src/hash-store/cache.ts

@@ -26,10 +26,6 @@ export function touchSession(path: string): void {
   sessionTouched.set(path, sessionSeq);
 }
 
-export function sessionRank(path: string): number | undefined {
-  return sessionTouched.get(path);
-}
-
 export function clearSession(): void {
   sessionTouched.clear();
   sessionSeq = 0;

package/src/hash-store.ts

@@ -20,7 +20,7 @@ import {
   retriedWrite,
   openDbWithBusyRetryAsync,
 } from "./hash-store/retry";
-import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT, touchSession, sessionRank, clearSession, forgetSession } from "./hash-store/cache";
+import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT, touchSession, clearSession, forgetSession } from "./hash-store/cache";
 
 export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
@@ -84,20 +84,16 @@ if (typeof process !== "undefined" && (process.versions as Record<string, string
 
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
+  getState: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   allHashes: (...params: SqlParams) => Record<string, unknown>[];
-  allServed: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
   undoGet: (...params: SqlParams) => Record<string, unknown> | undefined;
   undoDelete: (...params: SqlParams) => void;
-  servedGet: (...params: SqlParams) => Record<string, unknown> | undefined;
-  servedUpsert: (...params: SqlParams) => void;
-  servedDelete: (...params: SqlParams) => void;
   snapshotTime: (...params: SqlParams) => Record<string, unknown> | undefined;
   undoTime: (...params: SqlParams) => Record<string, unknown> | undefined;
-  servedTime: (...params: SqlParams) => Record<string, unknown> | undefined;
 }
 
 export interface HashStore {
@@ -158,31 +154,26 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
       "updated_at INTEGER NOT NULL" +
     ")"
   );
-  db.exec(
-    "CREATE TABLE IF NOT EXISTS served (" +
-      "path TEXT PRIMARY KEY, " +
-      "hashes TEXT NOT NULL, " +
-      "updated_at INTEGER NOT NULL" +
-    ")"
-  );
+  try {
+    db.exec("ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
+  } catch {}
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
     db.exec("DELETE FROM undo");
-    db.exec("DELETE FROM served");
   }
   db.prepare(
     "INSERT INTO meta (key, value) VALUES ('version', ?) " +
     "ON CONFLICT(key) DO UPDATE SET value = excluded.value"
   ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
-  const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
+  const getStateStmt = db.prepare("SELECT checksum, hashes, line_checksums FROM snapshots WHERE path = ?");
+  const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
   const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
-  const allServedStmt = db.prepare("SELECT path, hashes FROM served");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
-    "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
-    "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at"
+    "INSERT INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, line_checksums = excluded.line_checksums, updated_at = excluded.updated_at"
   );
   const undoUpsertStmt = db.prepare(
     "INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) " +
@@ -192,31 +183,20 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     "SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?"
   );
   const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
-  const servedGetStmt = db.prepare("SELECT hashes FROM served WHERE path = ?");
-  const servedUpsertStmt = db.prepare(
-    "INSERT INTO served (path, hashes, updated_at) VALUES (?, ?, ?) " +
-    "ON CONFLICT(path) DO UPDATE SET hashes = excluded.hashes, updated_at = excluded.updated_at"
-  );
-  const servedDelStmt = db.prepare("DELETE FROM served WHERE path = ?");
   const snapshotTimeStmt = db.prepare("SELECT updated_at FROM snapshots WHERE path = ?");
   const undoTimeStmt = db.prepare("SELECT updated_at FROM undo WHERE path = ?");
-  const servedTimeStmt = db.prepare("SELECT updated_at FROM served WHERE path = ?");
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
+    getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
     allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
-    allServed: (...params) => allServedStmt.all(...params) as Record<string, unknown>[],
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
     undoDelete: retriedWrite(undoDelStmt),
-    servedGet: (...params) => servedGetStmt.get(...params) as Record<string, unknown> | undefined,
-    servedUpsert: retriedWrite(servedUpsertStmt),
-    servedDelete: retriedWrite(servedDelStmt),
     snapshotTime: (...params) => snapshotTimeStmt.get(...params) as Record<string, unknown> | undefined,
     undoTime: (...params) => undoTimeStmt.get(...params) as Record<string, unknown> | undefined,
-    servedTime: (...params) => servedTimeStmt.get(...params) as Record<string, unknown> | undefined,
   };
   return { db, stmts };
 }
@@ -391,7 +371,7 @@ async function migrateLegacy(db: RawDb): Promise<void> {
   const raw = parsed.snapshots;
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
 
-  const rows: [string, string, number, string, number][] = [];
+  const rows: [string, string, number, string, string, number][] = [];
   for (const [key, value] of Object.entries(raw)) {
     if (
       isRec(value) &&
@@ -409,6 +389,7 @@ async function migrateLegacy(db: RawDb): Promise<void> {
       contentChecksum(value.content),
       splitLines(value.content).length,
       JSON.stringify(value.hashes),
+      "",
       Date.now(),
     ]);
   }
@@ -417,7 +398,7 @@ async function migrateLegacy(db: RawDb): Promise<void> {
       db.exec("BEGIN IMMEDIATE");
       try {
         const stmt = db.prepare(
-          "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
+          "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
         );
         for (const row of rows) stmt.run(...row);
         db.exec("COMMIT");
@@ -465,8 +446,9 @@ export function upsertSnapshot(
   checksum: string,
   lineCount: number,
   hashes: string[],
+  lineChecksums?: string[],
 ): void {
-  store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
+  store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), lineChecksums ? JSON.stringify(lineChecksums) : "", Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
   touchSession(path);
 }
@@ -475,8 +457,39 @@ export function persistSnapshot(
   path: string,
   content: string,
   hashes: string[],
+  lineChecksums?: string[],
 ): void {
-  upsertSnapshot(store, path, contentChecksum(content), splitLines(content).length, hashes);
+  upsertSnapshot(store, path, contentChecksum(content), splitLines(content).length, hashes, lineChecksums);
+}
+
+export interface AllocatedState {
+  anchors: string[];
+  checksums: string[] | undefined;
+  contentChecksum: string;
+}
+
+export function getAllocatedState(store: HashStore, path: string, deleteCorrupt = true): AllocatedState | undefined {
+  const row = withBusyRetry(() => store.stmts.getState(path)) as
+    | { checksum?: unknown; hashes?: unknown; line_checksums?: unknown }
+    | undefined;
+  if (!row || typeof row.checksum !== "string") return undefined;
+  const parsedAnchors = parseStoredHashes({ hashes: row.hashes }, () => {
+    if (deleteCorrupt) store.stmts.deleteOne(path);
+    snapshotCache.delete(path);
+  });
+  if (!parsedAnchors) return undefined;
+  let checksums: string[] | undefined;
+  if (typeof row.line_checksums === "string" && row.line_checksums.length > 0) {
+    try {
+      const parsed = JSON.parse(row.line_checksums) as unknown;
+      if (Array.isArray(parsed) && parsed.every((c) => typeof c === "string")) {
+        checksums = parsed as string[];
+      }
+    } catch {
+      checksums = undefined;
+    }
+  }
+  return { anchors: parsedAnchors, checksums, contentChecksum: row.checksum };
 }
 
 export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
@@ -537,119 +550,19 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
   return missing;
 }
 
-export async function pruneMissing(store: HashStore): Promise<void> {
+export async function pruneMissing(store: HashStore): Promise<string[]> {
   const rows = store.stmts.allPaths() as { path: string }[];
   const missing = await statMissing(rows);
-  if (missing.length === 0) return;
+  if (missing.length === 0) return [];
   withStore(() => {
     for (const path of missing) {
       store.stmts.deleteOne(path);
-      store.stmts.servedDelete(path);
     }
   });
   for (const path of missing) snapshotCache.delete(path);
   for (const path of missing) forgetSession(path);
+  return missing;
 }
 
-function matchPathsByHashes(
-  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 (!isValidHashList(parsed)) continue;
-      const parsedSet = new Set(parsed);
-      let ok = true;
-      for (const h of needed) {
-        if (!parsedSet.has(h)) {
-          ok = false;
-          break;
-        }
-      }
-      if (ok) matches.push(row.path);
-    } catch {
-      continue;
-    }
-  }
-  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 matchPathsByServed(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
-}
-
-export function pathActivity(store: HashStore, path: string): number {
-  let activity = 0;
-  try {
-    const snap = withBusyRetry(() => store.stmts.snapshotTime(path)) as { updated_at?: unknown } | undefined;
-    const snapTime = typeof snap?.updated_at === "number" ? snap.updated_at : 0;
-    if (snapTime > activity) activity = snapTime;
-  } catch {
-  }
-  try {
-    const undo = withBusyRetry(() => store.stmts.undoTime(path)) as { updated_at?: unknown } | undefined;
-    const undoTime = typeof undo?.updated_at === "number" ? undo.updated_at : 0;
-    if (undoTime > activity) activity = undoTime;
-  } catch {
-  }
-  try {
-    const served = withBusyRetry(() => store.stmts.servedTime(path)) as { updated_at?: unknown } | undefined;
-    const servedTime = typeof served?.updated_at === "number" ? served.updated_at : 0;
-    if (servedTime > activity) activity = servedTime;
-  } catch {
-  }
-  return activity;
-}
 
-export function rankRecentPaths(store: HashStore, candidates: string[]): string[] {
-  const scored = candidates.map((candidate) => {
-    const rank = sessionRank(candidate) ?? -1;
-    const activity = rank < 0 ? pathActivity(store, candidate) : -1;
-    return { candidate, rank, activity };
-  });
-  scored.sort((a, b) => {
-    if (a.rank !== b.rank) return b.rank - a.rank;
-    if (a.activity !== b.activity) return b.activity - a.activity;
-    return a.candidate < b.candidate ? -1 : a.candidate > b.candidate ? 1 : 0;
-  });
-  return scored.map((entry) => entry.candidate);
-}
 
-export function pickRecentPath(store: HashStore, candidates: string[]): string {
-  return rankRecentPaths(store, candidates)[0]!;
-}