pi-hashline-edit-pro 4.2.11 → 4.3.1

package/src/auto-read-all.ts

@@ -0,0 +1,309 @@
+import { execFile } from "node:child_process";
+import { lstat, open, readdir } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "@earendil-works/pi-coding-agent";
+import {
+  AUTO_READ_ALL_MAX_BUDGET_BYTES,
+  AUTO_READ_ALL_MAX_FILE_BYTES,
+  AUTO_READ_ALL_MAX_FILES,
+  AUTO_READ_ALL_MIN_BUDGET_BYTES,
+  SNIFF_BYTES,
+} from "./constants";
+import type { AutoReadAllMode } from "./config";
+import { serveRows } from "./served";
+import { readNormFile } from "./file-reader";
+import { resolveRgPath } from "./grep";
+import { MAX_HASH_LINES } from "./hashline";
+import { fmtReadPreview } from "./read";
+import { splitLines } from "./utils";
+
+const EXEC_TIMEOUT_MS = 20_000;
+const EXEC_MAX_BYTES = 64 * 1024 * 1024;
+const SCAN_CONCURRENCY = 32;
+const SCAN_LIMIT_MULTIPLIER = 4;
+const MAX_REPORTED_OMISSIONS = 50;
+
+const HEADER =
+  "[hashline auto-read-all] The content of every non-ignored project file is attached below with live hashline anchors. Each anchor│content row is already owned and served for this session, so replace and insert can target those anchors directly without calling read first. Rows with a truncation hint are only partially shown; call read with the hinted offset to see the rest.";
+
+const IMAGE_EXTENSIONS = new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".heic",
+  ".heif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".jxl",
+  ".png",
+  ".psd",
+  ".tif",
+  ".tiff",
+  ".webp",
+]);
+
+export const AUTO_READ_ALL_EXCLUDED_NAMES = ["package-lock.json"];
+
+const EXCLUDED_NAME_SET = new Set(AUTO_READ_ALL_EXCLUDED_NAMES);
+
+const WALK_IGNORED_DIRS = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".tmp",
+  ".cache",
+  ".next",
+  ".turbo",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "target",
+  "vendor",
+]);
+
+export type AutoReadAllSource = "git" | "rg" | "walk";
+
+export interface AutoReadAllDiscovery {
+  files: string[];
+  source: AutoReadAllSource;
+  discovered: number;
+  skippedBinary: number;
+  skippedLarge: number;
+  skippedOther: number;
+  skippedByName: number;
+}
+
+export interface AutoReadAllInjection {
+  text: string;
+  files: number;
+  bytes: number;
+  omitted: string[];
+}
+
+function runCommand(command: string, args: string[], cwd: string): Promise<{ stdout: string; code: number }> {
+  return new Promise((resolveResult) => {
+    execFile(command, args, { cwd, timeout: EXEC_TIMEOUT_MS, maxBuffer: EXEC_MAX_BYTES }, (error, stdout) => {
+      if (error === null) {
+        resolveResult({ stdout: stdout ?? "", code: 0 });
+        return;
+      }
+      const code = typeof (error as { code?: unknown }).code === "number" ? (error as { code: number }).code : 1;
+      resolveResult({ stdout: stdout ?? "", code });
+    });
+  });
+}
+
+async function listFromGit(cwd: string): Promise<string[] | undefined> {
+  const result = await runCommand("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd);
+  if (result.code !== 0) return undefined;
+  return result.stdout.split("\0").filter((entry) => entry.length > 0);
+}
+
+async function listFromRg(cwd: string): Promise<string[] | undefined> {
+  let rgPath: string;
+  try {
+    rgPath = await resolveRgPath();
+  } catch {
+    return undefined;
+  }
+  const result = await runCommand(rgPath, ["--files", "--hidden", "--no-require-git", "--glob", "!.git", "--null"], cwd);
+  if (result.code === 1) return [];
+  if (result.code !== 0) return undefined;
+  return result.stdout.split("\0").filter((entry) => entry.length > 0);
+}
+
+async function walkDir(dir: string, base: string, out: string[]): Promise<void> {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (WALK_IGNORED_DIRS.has(entry.name)) continue;
+      await walkDir(full, base, out);
+    } else if (entry.isFile()) {
+      out.push(toPosix(relative(base, full)));
+    }
+  }
+}
+
+function toPosix(path: string): string {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+
+function baseNameOf(path: string): string {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+
+function extensionOf(path: string): string {
+  const base = baseNameOf(path);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+
+async function hasNulByte(path: string): Promise<boolean | undefined> {
+  let handle;
+  try {
+    handle = await open(path, "r");
+  } catch {
+    return undefined;
+  }
+  try {
+    const buffer = Buffer.alloc(SNIFF_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).includes(0);
+  } catch {
+    return undefined;
+  } finally {
+    await handle.close();
+  }
+}
+
+async function forEachLimit<T>(items: T[], limit: number, work: (item: T) => Promise<void>): Promise<void> {
+  let index = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (index < items.length) {
+      const item = items[index];
+      index += 1;
+      if (item !== undefined) await work(item);
+    }
+  });
+  await Promise.all(workers);
+}
+
+export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMode = "on"): Promise<AutoReadAllDiscovery> {
+  let source: AutoReadAllSource = "git";
+  let candidates = await listFromGit(cwd);
+  if (candidates === undefined) {
+    if (mode === "git") {
+      return { files: [], source: "git", discovered: 0, skippedBinary: 0, skippedLarge: 0, skippedOther: 0, skippedByName: 0 };
+    }
+    candidates = await listFromRg(cwd);
+    source = "rg";
+  }
+  if (candidates === undefined) {
+    source = "walk";
+    const walked: string[] = [];
+    await walkDir(cwd, cwd, walked);
+    candidates = walked;
+  }
+
+  const unique = [...new Set(candidates.map(toPosix))].sort();
+  const includable: string[] = [];
+  let skippedByName = 0;
+  for (const file of unique) {
+    if (EXCLUDED_NAME_SET.has(baseNameOf(file).toLowerCase())) skippedByName += 1;
+    else includable.push(file);
+  }
+  const scanWindow = includable.slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
+  const sized: string[] = [];
+  let skippedBinary = 0;
+  let skippedLarge = 0;
+  let skippedOther = 0;
+
+  await forEachLimit(scanWindow, SCAN_CONCURRENCY, async (file) => {
+    let stats;
+    try {
+      stats = await lstat(resolve(cwd, file));
+    } catch {
+      skippedOther += 1;
+      return;
+    }
+    if (!stats.isFile()) {
+      skippedOther += 1;
+      return;
+    }
+    if (stats.size > AUTO_READ_ALL_MAX_FILE_BYTES) {
+      skippedLarge += 1;
+      return;
+    }
+    if (IMAGE_EXTENSIONS.has(extensionOf(file))) {
+      skippedBinary += 1;
+      return;
+    }
+    sized.push(file);
+  });
+
+  const textual: string[] = [];
+  await forEachLimit(sized, SCAN_CONCURRENCY, async (file) => {
+    const nul = await hasNulByte(resolve(cwd, file));
+    if (nul === undefined) skippedOther += 1;
+    else if (nul) skippedBinary += 1;
+    else textual.push(file);
+  });
+  textual.sort();
+  const files = textual.slice(0, AUTO_READ_ALL_MAX_FILES);
+
+  return { files, source, discovered: unique.length, skippedBinary, skippedLarge, skippedOther, skippedByName };
+}
+
+async function renderFile(file: string, cwd: string): Promise<string | undefined> {
+  try {
+    const { normalized, fileHashes, absolutePath } = await readNormFile(file, cwd, { maxLines: MAX_HASH_LINES });
+    const preview = await fmtReadPreview(normalized, {}, fileHashes, absolutePath, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+    serveRows(absolutePath, fileHashes, splitLines(normalized), preview.servedHashes);
+    return `=== ${file} ===\n${preview.text}`;
+  } catch (error) {
+    console.error(`Auto-read all: skipped ${file}:`, error);
+    return undefined;
+  }
+}
+
+function buildFooter(attached: number, discovery: AutoReadAllDiscovery, omitted: string[]): string {
+  const notes: string[] = [];
+  const beyondCap = Math.max(
+    0,
+    discovery.discovered - discovery.files.length - discovery.skippedBinary - discovery.skippedLarge - discovery.skippedOther - discovery.skippedByName,
+  );
+  if (beyondCap > 0) notes.push(`${beyondCap} file(s) beyond the ${AUTO_READ_ALL_MAX_FILES}-file cap skipped`);
+  if (discovery.skippedBinary > 0) notes.push(`${discovery.skippedBinary} binary or image file(s) skipped`);
+  if (discovery.skippedLarge > 0) notes.push(`${discovery.skippedLarge} file(s) over ${formatSize(AUTO_READ_ALL_MAX_FILE_BYTES)} skipped`);
+  if (discovery.skippedOther > 0) notes.push(`${discovery.skippedOther} unreadable path(s) skipped`);
+  if (discovery.skippedByName > 0) notes.push(`${discovery.skippedByName} file(s) skipped by name (${AUTO_READ_ALL_EXCLUDED_NAMES.join(", ")})`);
+  const listed = omitted.slice(0, MAX_REPORTED_OMISSIONS).join(", ");
+  const more = omitted.length > MAX_REPORTED_OMISSIONS ? `, ... (+${omitted.length - MAX_REPORTED_OMISSIONS} more)` : "";
+  const omissionNote = omitted.length > 0 ? ` Not attached: ${listed}${more}. Use read for those.` : "";
+  const summary = notes.length > 0 ? notes.join("; ") + "." : "all discovered files attached.";
+  return `[hashline auto-read-all: ${attached} file(s) attached from ${discovery.source}; ${summary}${omissionNote}]`;
+}
+
+export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on"): Promise<AutoReadAllInjection | undefined> {
+  const discovery = await discoverAutoReadAllFiles(cwd, mode);
+  if (discovery.files.length === 0) return undefined;
+  const sections: string[] = [];
+  const omitted: string[] = [];
+  let bytes = 0;
+  for (const file of discovery.files) {
+    const section = await renderFile(file, cwd);
+    if (section === undefined) {
+      omitted.push(file);
+      continue;
+    }
+    const sectionBytes = Buffer.byteLength(section, "utf-8") + 1;
+    if (sections.length > 0 && bytes + sectionBytes > budgetBytes) {
+      omitted.push(file);
+      continue;
+    }
+    sections.push(section);
+    bytes += sectionBytes;
+  }
+  if (sections.length === 0) return undefined;
+  const text = `${HEADER}\n\n${sections.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}`;
+  return { text, files: sections.length, bytes, omitted };
+}
+
+export function autoReadAllBudget(model: { contextWindow?: number } | undefined): number {
+  const contextWindow = typeof model?.contextWindow === "number" && model.contextWindow > 0 ? model.contextWindow : 0;
+  const fromContext = Math.floor(contextWindow * 1.5);
+  return Math.min(AUTO_READ_ALL_MAX_BUDGET_BYTES, Math.max(AUTO_READ_ALL_MIN_BUDGET_BYTES, fromContext));
+}

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 files on the first turn: off, on, git (git repos only)", enabled: (config.autoReadAll ?? "off") !== "off", mode: config.autoReadAll ?? "off", cycle: ["off", "on", "git"] },
     { 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

@@ -4,6 +4,8 @@ import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
 export type BoundaryDedupMode = "on" | "off" | "strict";
+export type AutoReadAllMode = "off" | "on" | "git";
+const AUTO_READ_ALL_MODES: AutoReadAllMode[] = ["off", "on", "git"];
 
 export const DEFAULT_DIFF_CONTEXT_LINES = 1;
 export const MIN_DIFF_CONTEXT_LINES = 0;
@@ -12,6 +14,7 @@ export const MAX_DIFF_CONTEXT_LINES = 10;
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
+  autoReadAll?: AutoReadAllMode;
   requirePath?: boolean;
   strictInput?: boolean;
   boundaryDedupMode?: BoundaryDedupMode;
@@ -21,6 +24,7 @@ export interface Config {
 const DEFAULT_CONFIG: Config = {
   autoRead: true,
   anchorGrepEnabled: true,
+  autoReadAll: "off",
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
@@ -36,6 +40,13 @@ function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMo
   return DEFAULT_CONFIG.boundaryDedupMode ?? "on";
 }
 
+function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
+  if (value === "off" || value === "on" || value === "git") return value;
+  if (value === true) return "on";
+  if (value === false) return "off";
+  return DEFAULT_CONFIG.autoReadAll ?? "off";
+}
+
 export function normalizeDiffContextLines(value: unknown): number {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_DIFF_CONTEXT_LINES;
   const floored = Math.floor(value);
@@ -50,15 +61,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: parseAutoReadAllMode(autoReadAll),
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
@@ -92,17 +105,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 +138,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 +183,25 @@ 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" | "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 async function cycleAutoReadAllMode(): Promise<AutoReadAllMode> {
+  let next: AutoReadAllMode = "off";
+  await updateConfig((c) => {
+    const current = c.autoReadAll ?? "off";
+    next = AUTO_READ_ALL_MODES[(AUTO_READ_ALL_MODES.indexOf(current) + 1) % AUTO_READ_ALL_MODES.length] ?? "off";
+    c.autoReadAll = next;
+  });
+  return next;
 }
+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/edit-common.ts

@@ -45,6 +45,9 @@ export function withReplacePrompts(base: { description: string; snippet: string;
     descriptionParts.push("Also give `path` matching the file the anchors were served for; it is required and must match anchor ownership.");
     snippetParts.push("; include `path` (required)");
     guidelines.push("`replace`: include `path` matching the file the anchors were served for; it is required.");
+  } else {
+    descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
+    guidelines.push("`replace`: path resolution is anchor-only; don't pass `path`.");
   }
   if (flags.strictInput) {
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
@@ -74,6 +77,9 @@ export function withInsertPrompts(base: { description: string; snippet: string;
     descriptionParts.push("Also give `path` matching the file the anchor was served for; it is required and must match anchor ownership.");
     snippetParts.push("; include `path` (required)");
     guidelines.push("`insert`: include `path` matching the file the anchor was served for; it is required.");
+  } else {
+    descriptionParts.push("Path resolution is anchor-only; do not pass `path`.");
+    guidelines.push("`insert`: path resolution is anchor-only; don't pass `path`.");
   }
   if (flags.strictInput) {
     descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");

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;