pi-hashline-edit-pro 4.2.11 → 4.3.0

package/src/batch.ts

@@ -17,12 +17,12 @@ import {
   type PlannedEdit,
 } from "./hashline";
 import { boundaryDedupNoopWarning, boundaryDedupWarning, dedupRowsFromFixes } from "./commit";
-import { adoptAnchors, markServed, servedForPath } from "./anchor-registry";
+import { adoptAnchors, servedForPath } from "./anchor-registry";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { assertInsertReq, assertReq, normReq } from "./payload-contract";
 import { saveUndo } from "./replace-undo";
 import { buildChanged, buildNoop, type RMetrics, type TResult } from "./replace-response";
-import { buildServedMap, servedHashesFromDiff } from "./served";
+import { serveRows, servedHashesFromDiff } from "./served";
 import { abortIf, assertLineLimit, errCode, isRec, splitLines } from "./utils";
 import { MAX_BYTES } from "./constants";
 
@@ -750,7 +750,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   changed.details.diff = `${header}\n${changed.details.diff}`;
   changed.details.diffLineNumbers?.unshift(undefined);
   try {
-    markServed(runtime.target, buildServedMap(resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff)), new Set(resultHashes));
+    serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {
     console.error("Failed to mark batch diff served:", error);
   }

package/src/commit.ts

@@ -8,11 +8,10 @@ import { saveUndo } from "./replace-undo";
 import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { servedHashesFromDiff, buildServedMap } from "./served";
+import { servedHashesFromDiff, serveRows } from "./served";
 import { lineHashes, type AutoFix } from "./hashline";
-import { hashSpan } from "./replace";
+import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF } from "./normalize";
-import { markServed as markServedScoped } from "./anchor-registry";
 export interface CommitMeta {
   editAnchors?: [string, string];
   path: string;
@@ -131,18 +130,14 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     removedLines: pipe.totalRemovedLines,
   };
 
-  const span = meta.editAnchors ? hashSpan(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1]) : undefined;
-  const resultCount = splitLines(pipe.result).length;
-  const replacementCount = span ? resultCount - (pipe.originalHashes.length - (span[1] - span[0] + 1)) : 0;
+  const span = meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined;
   let resultHashes: string[];
   try {
-    resultHashes = pipe.result === pipe.originalNormalized
-      ? pipe.originalHashes
-      : await lineHashes(pipe.result, mutationTargetPath, {
-        content: pipe.originalNormalized,
-        hashes: pipe.originalHashes,
-        spans: span ? [{ start: span[0], end: span[1], replacementCount }] : undefined,
-      });
+    resultHashes = await lineHashes(pipe.result, mutationTargetPath, {
+      content: pipe.originalNormalized,
+      hashes: pipe.originalHashes,
+      spans: span ? [span] : undefined,
+    });
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(`${detail} File was written; anchor finalization failed. One undo reverts. Call read for fresh anchors.`);
@@ -158,15 +153,11 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     editMeta,
     boundaryDedupAbove: pipe.boundaryDedupAbove,
     boundaryDedupBelow: pipe.boundaryDedupBelow,
-    ...(span ? { spans: [{ start: span[0], end: span[1], replacementCount }] } : {}),
+    ...(span ? { spans: [span] } : {}),
   };
   const changed = buildChanged(successInput, meta.verb, await getDiffContextLines());
   if (changed.details.diff) {
-    markServedScoped(
-      mutationTargetPath,
-      buildServedMap(resultHashes, splitLines(pipe.result), servedHashesFromDiff(changed.details.diff)),
-      new Set(resultHashes),
-    );
+    serveRows(mutationTargetPath, resultHashes, splitLines(pipe.result), servedHashesFromDiff(changed.details.diff));
   }
   return changed;
 }

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -18,6 +18,7 @@ export interface ConfigRow {
 export function configRows(config: Config): ConfigRow[] {
   return [
     { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "autoReadAll", label: "Auto-read all", hint: "Attach every non-ignored file with anchors on the first turn", enabled: config.autoReadAll === true },
     { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },

package/src/config.ts

@@ -12,6 +12,7 @@ export const MAX_DIFF_CONTEXT_LINES = 10;
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
+  autoReadAll?: boolean;
   requirePath?: boolean;
   strictInput?: boolean;
   boundaryDedupMode?: BoundaryDedupMode;
@@ -21,6 +22,7 @@ export interface Config {
 const DEFAULT_CONFIG: Config = {
   autoRead: true,
   anchorGrepEnabled: true,
+  autoReadAll: false,
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
@@ -50,15 +52,17 @@ function parseConfig(content: string): Config {
     throw new Error("config.json must be an object with a boolean autoRead field");
   }
   const autoRead = parsed.autoRead;
-  const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
-  const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
-  const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
-  const boundaryDedupMode = isRec(parsed) ? parsed.boundaryDedupMode : undefined;
-  const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
-  const diffContextLines = isRec(parsed) ? parsed.diffContextLines : undefined;
+  const anchorGrepEnabled = parsed.anchorGrepEnabled;
+  const autoReadAll = parsed.autoReadAll;
+  const requirePath = parsed.requirePath;
+  const strictInput = parsed.strictInput;
+  const boundaryDedupMode = parsed.boundaryDedupMode;
+  const legacyBoundaryDedup = parsed.boundaryDedupEnabled;
+  const diffContextLines = parsed.diffContextLines;
   return {
     autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
+    autoReadAll: typeof autoReadAll === "boolean" ? autoReadAll : DEFAULT_CONFIG.autoReadAll,
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
@@ -92,17 +96,23 @@ export async function readConfig(): Promise<Config> {
 export async function readConfigWithStatus(): Promise<{ config: Config; corrupted: boolean }> {
   return loadConfigFile();
 }
-const CONFIG_LOCK_RETRIES = 80;
 const CONFIG_LOCK_DELAY_MS = 25;
 const CONFIG_LOCK_STALE_MS = 5000;
-async function acquireConfigLock(lockPath: string): Promise<void> {
+const CONFIG_LOCK_RETRIES = Math.ceil(CONFIG_LOCK_STALE_MS / CONFIG_LOCK_DELAY_MS) * 2;
+
+interface ConfigLock {
+  path: string;
+  dev: number;
+  ino: number;
+}
+
+async function acquireConfigLock(lockPath: string): Promise<ConfigLock> {
   try {
     await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
   } catch { }
   for (let attempt = 0; attempt < CONFIG_LOCK_RETRIES; attempt++) {
     try {
       await mkdir(lockPath, { mode: 0o700 });
-      return;
     } catch (error) {
       if (errCode(error) === "ENOENT") {
         try {
@@ -119,26 +129,44 @@ async function acquireConfigLock(lockPath: string): Promise<void> {
         }
       } catch { }
       await new Promise<void>((r) => setTimeout(r, CONFIG_LOCK_DELAY_MS));
+      continue;
+    }
+    try {
+      const st = await stat(lockPath);
+      return { path: lockPath, dev: st.dev, ino: st.ino };
+    } catch (error) {
+      if (errCode(error) !== "ENOENT") {
+        try {
+          await rm(lockPath, { recursive: true, force: true });
+        } catch { }
+      }
+      continue;
     }
   }
   throw new Error(`[E_ACCESS] Could not acquire config lock: ${lockPath}`);
 }
-async function releaseConfigLock(lockPath: string): Promise<void> {
+async function releaseConfigLock(lock: ConfigLock): Promise<void> {
+  try {
+    const st = await stat(lock.path);
+    if (st.dev !== lock.dev || st.ino !== lock.ino) return;
+  } catch {
+    return;
+  }
   try {
-    await rm(lockPath, { recursive: true, force: true });
+    await rm(lock.path, { recursive: true, force: true });
   } catch { }
 }
 export async function updateConfig(mut: (config: Config) => void): Promise<Config> {
   const cfgPath = configPath();
   const lockPath = `${cfgPath}.lock`;
-  await acquireConfigLock(lockPath);
+  const lock = await acquireConfigLock(lockPath);
   try {
     const config = await readConfig();
     mut(config);
     await writeConfig(config);
     return config;
   } finally {
-    await releaseConfigLock(lockPath);
+    await releaseConfigLock(lock);
   }
 }
 export async function writeConfig(config: Config): Promise<void> {
@@ -146,22 +174,17 @@ export async function writeConfig(config: Config): Promise<void> {
 }
 
 
-export async function toggleAutoRead(): Promise<boolean> {
-  const config = await updateConfig((c) => { c.autoRead = !c.autoRead; });
-  return config.autoRead;
-}
-export async function toggleAnchorGrep(): Promise<boolean> {
-  const config = await updateConfig((c) => { c.anchorGrepEnabled = !c.anchorGrepEnabled; });
-  return config.anchorGrepEnabled;
-}
-export async function toggleRequirePath(): Promise<boolean> {
-  const config = await updateConfig((c) => { c.requirePath = !c.requirePath; });
-  return config.requirePath === true;
-}
-export async function toggleStrictInput(): Promise<boolean> {
-  const config = await updateConfig((c) => { c.strictInput = !(c.strictInput === true); });
-  return config.strictInput === true;
-}
+type ToggleKey = "autoRead" | "anchorGrepEnabled" | "autoReadAll" | "requirePath" | "strictInput";
+
+async function toggleFlag(key: ToggleKey): Promise<boolean> {
+  const config = await updateConfig((c) => { c[key] = !(c[key] === true); });
+  return config[key] === true;
+}
+export const toggleAutoRead = (): Promise<boolean> => toggleFlag("autoRead");
+export const toggleAnchorGrep = (): Promise<boolean> => toggleFlag("anchorGrepEnabled");
+export const toggleAutoReadAll = (): Promise<boolean> => toggleFlag("autoReadAll");
+export const toggleRequirePath = (): Promise<boolean> => toggleFlag("requirePath");
+export const toggleStrictInput = (): Promise<boolean> => toggleFlag("strictInput");
 export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
   let next: BoundaryDedupMode = "on";
   await updateConfig((c) => {

package/src/constants.ts

@@ -20,3 +20,9 @@ export const ANCHOR_POOL_EXHAUSTED_PREFIX =
   "[E_FILE_TOO_LARGE] The session's anchor pool is exhausted";
 
 export const DEDUP_ANCHOR = "dedup";
+
+export const AUTO_READ_ALL_CUSTOM_TYPE = "hashline-auto-read-all";
+export const AUTO_READ_ALL_MAX_FILES = 500;
+export const AUTO_READ_ALL_MAX_FILE_BYTES = 200_000;
+export const AUTO_READ_ALL_MIN_BUDGET_BYTES = 200_000;
+export const AUTO_READ_ALL_MAX_BUDGET_BYTES = 2_000_000;

package/src/fs-write.ts

@@ -21,7 +21,7 @@ export interface FileIdentity {
 }
 
 function sameIdentity(
-  actual: Pick<Awaited<ReturnType<typeof stat>>, "dev" | "ino">,
+  actual: FileIdentity,
   expected: FileIdentity,
 ): boolean {
   return actual.dev === expected.dev && actual.ino === expected.ino;

package/src/grep.ts

@@ -12,8 +12,8 @@ import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
-import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
-import { buildServedMap } from "./served";
+import { withAnchorSession } from "./anchor-registry";
+import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 import { expandHint, getResultText, reuseText, type CallT, type FgT } from "./replace-render";
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
@@ -281,11 +281,8 @@ function makeHitFromIndices(
 }
 
 let cachedRgPath: string | undefined;
-export function clearRgPathCache(): void {
-  cachedRgPath = undefined;
-}
 
-async function resolveRgPath(): Promise<string> {
+export async function resolveRgPath(): Promise<string> {
   if (cachedRgPath !== undefined) return cachedRgPath;
   try {
     const r = spawnSync("rg", ["--version"], { stdio: "pipe" });
@@ -572,6 +569,12 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         const globRoot = baseStat.isFile() ? dirname(base) : base;
         const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+        const matchesGlob = (absPath: string): boolean => {
+          if (globRegex === undefined) return true;
+          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
+          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+          return globRegex.test(globPath) || globRegex.test(displayPath);
+        };
         const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
         const rgPath = await resolveRgPath();
         const hits: FileHit[] = [];
@@ -607,11 +610,7 @@ export function regGrep(pi: ExtensionAPI): void {
           const sortedNums = [...allNums].sort((a, b) => a - b);
           const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
           if (countOnly) {
-            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;
-            }
+            if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
             const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
@@ -633,15 +632,10 @@ export function regGrep(pi: ExtensionAPI): void {
             limitTruncated = true;
             break;
           }
-          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;
-          }
+          if (!matchesGlob(absPath)) continue;
           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;
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];
@@ -677,7 +671,7 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
         for (const hit of hits) {
-          markServedScoped(hit.path, buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes), new Set(hit.fileHashes));
+          serveRows(hit.path, hit.fileHashes, hit.fileLines, hit.hashes);
         }
         const blocks = hits
           .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)

package/src/hash-store/cache.ts

@@ -16,21 +16,3 @@ export function cacheSnapshot(path: string, checksum: string, lineCount: number,
     if (oldest !== undefined) snapshotCache.delete(oldest);
   }
 }
-
-let sessionSeq = 0;
-export const sessionTouched = new Map<string, number>();
-
-export function touchSession(path: string): void {
-  sessionSeq += 1;
-  sessionTouched.delete(path);
-  sessionTouched.set(path, sessionSeq);
-}
-
-export function clearSession(): void {
-  sessionTouched.clear();
-  sessionSeq = 0;
-}
-
-export function forgetSession(path: string): void {
-  sessionTouched.delete(path);
-}

package/src/hash-store/retry.ts

@@ -42,7 +42,3 @@ export function retriedWrite(stmt: { run(...params: (string | number | null)[]):
     withBusyRetry(() => { stmt.run(...params); });
   };
 }
-
-export async function openDbWithBusyRetryAsync<T>(fn: () => T): Promise<T> {
-  return withBusyRetryAsync(fn);
-}

package/src/hash-store/validation.ts

@@ -9,15 +9,6 @@ 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 {
@@ -35,33 +26,11 @@ 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

@@ -7,22 +7,19 @@ 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,
   retriedWrite,
-  openDbWithBusyRetryAsync,
+  withBusyRetryAsync,
 } from "./hash-store/retry";
-import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT, touchSession, clearSession, forgetSession } from "./hash-store/cache";
+import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT } from "./hash-store/cache";
 
-export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
+export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
@@ -283,19 +280,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => openDb(storePath));
   } catch (error) {
     if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => openDb(storePath));
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => openDb(storePath));
   }
   const { db, stmts } = opened;
   try {
@@ -367,25 +364,28 @@ export function shutdownHashStore(): void {
     cachedDb = null;
   }
   snapshotCache.clear();
-  clearSession();
 }
 
-export function withStore(fn: () => void): void {
-  if (!cachedDb || !cachedDb.db.isOpen) {
-    throw new Error(STORE_NOT_OPEN_MESSAGE);
-  }
+function withTransaction(db: RawDb, fn: () => void): void {
   withBusyRetry(() => {
-    cachedDb!.db.exec("BEGIN IMMEDIATE");
+    db.exec("BEGIN IMMEDIATE");
     try {
       fn();
-      cachedDb!.db.exec("COMMIT");
+      db.exec("COMMIT");
     } catch (e) {
-      try { cachedDb!.db.exec("ROLLBACK"); } catch {}
+      try { db.exec("ROLLBACK"); } catch {}
       throw e;
     }
   });
 }
 
+export function withStore(fn: () => void): void {
+  if (!cachedDb || !cachedDb.db.isOpen) {
+    throw new Error(STORE_NOT_OPEN_MESSAGE);
+  }
+  withTransaction(cachedDb.db, fn);
+}
+
 async function migrateLegacy(db: RawDb): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
@@ -431,18 +431,11 @@ async function migrateLegacy(db: RawDb): Promise<void> {
     ]);
   }
   if (rows.length > 0) {
-    withBusyRetry(() => {
-      db.exec("BEGIN IMMEDIATE");
-      try {
-        const stmt = db.prepare(
-          "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");
-      } catch (e) {
-        try { db.exec("ROLLBACK"); } catch {}
-        throw e;
-      }
+    withTransaction(db, () => {
+      const stmt = db.prepare(
+        "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
+      );
+      for (const row of rows) stmt.run(...row);
     });
   }
 
@@ -487,7 +480,6 @@ export function upsertSnapshot(
 ): void {
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), lineChecksums ? JSON.stringify(lineChecksums) : "", Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
-  touchSession(path);
 }
 export function persistSnapshot(
   store: HashStore,
@@ -540,7 +532,6 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
     typeof entry.mode === "number" ? entry.mode : null,
     Date.now(),
   );
-  touchSession(path);
 }
 
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
@@ -600,7 +591,6 @@ export async function pruneMissing(store: HashStore): Promise<string[]> {
     }
   });
   for (const path of missing) snapshotCache.delete(path);
-  for (const path of missing) forgetSession(path);
   return missing;
 }
 

package/src/hashline/apply.ts

@@ -184,9 +184,9 @@ export function planEdit(
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];
 
-  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
+  const rangeFixed = swapReversedRanges(edit, fileHashes);
   const prefixFixed = stripDiffPrefixes(
-    stripBarePrefixes(rangeFixed, fileHashes, warnings),
+    stripBarePrefixes(rangeFixed, warnings),
     warnings,
   );
 

package/src/hashline/hash.ts

@@ -2,7 +2,7 @@ import { splitLines, truncateToBytes, getCached } from "../utils";
 import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import { loadHashStore, type HashStore } from "../hash-store";
 import { allocateFileAnchors } from "../anchor-registry";
-import { xxh32, initHasher } from "./hasher";
+import { xxh32, initHasher, contentChecksum } from "./hasher";
 import { HASH_LEN, ANCHOR_COUNT, anchorAt, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, HASH_CLASS, HASH_RUN };
 
@@ -15,11 +15,6 @@ export const MAX_HASH_LINES = HASH_SPACE;
 
 export const HASH_PROBE_STRIDE = 836286;
 
-
-function hashAt(idx: number): string {
-  return anchorAt(idx);
-}
-
 export const HL_PREFIX_PLUS_RE = new RegExp(
 	`^\\+${HASH_RUN}│`,
 );
@@ -61,6 +56,10 @@ export function hashSource(line: string): string {
 	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
 }
 
+export function lineChecksum(line: string): string {
+	return contentChecksum(hashSource(line));
+}
+
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {
@@ -88,12 +87,12 @@ function assignHash(used: Uint32Array, baseIdx: number, hint: { value: number })
   if (!getBit(used, baseIdx)) {
     setBit(used, baseIdx);
     hint.value = baseIdx + HASH_PROBE_STRIDE;
-    return hashAt(baseIdx);
+    return anchorAt(baseIdx);
   }
   const nextIdx = nextZeroBit(used, hint.value);
   setBit(used, nextIdx);
   hint.value = nextIdx + HASH_PROBE_STRIDE;
-  return hashAt(nextIdx);
+  return anchorAt(nextIdx);
 }
 
 export function _lineHashesPure(content: string): string[] {

package/src/hashline/index.ts

@@ -12,6 +12,7 @@ export {
 	initHasher,
 	canon,
 	hashSource,
+	lineChecksum,
 } from "./hash";
 
 export {