pi-hashline-edit-pro 4.4.3 → 4.5.0

package/index.ts

@@ -3,6 +3,7 @@ import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-
 import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regInsert } from "./src/insert";
+import { regCopy, regMove } from "./src/copy-move";
 import { regGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
@@ -18,13 +19,14 @@ import {
   toggleAutoRead,
   cycleAutoReadAllMode,
   toggleAnchorGrep,
+  toggleCopyMove,
   toggleRequirePath,
   toggleStrictInput,
   adjustDiffContextLines,
   setAutoReadAllIgnoreFromText,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession } from "./src/anchor-registry";
+import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
 import { currentEditFlags } from "./src/edit-common";
@@ -42,6 +44,8 @@ export default function (pi: ExtensionAPI): void {
 
   regReplace(pi);
   regInsert(pi);
+  regCopy(pi);
+  regMove(pi);
   regGrep(pi);
   regUndo(pi);
   registerWriteHook(pi);
@@ -58,6 +62,8 @@ export default function (pi: ExtensionAPI): void {
       regRead(pi, flags);
       regReplace(pi, flags);
       regInsert(pi, flags);
+      regCopy(pi, flags);
+      regMove(pi, flags);
       regUndo(pi, flags);
     } catch (error) {
       console.error("Failed to refresh edit tools:", error);
@@ -90,9 +96,11 @@ export default function (pi: ExtensionAPI): void {
     autoReadAllInjected = sessionBranch.some((entry) => entry.type === "custom_message" && entry.customType === AUTO_READ_ALL_CUSTOM_TYPE);
     await refreshEditTools();
     pi.setActiveTools(
-      pi.getActiveTools().filter((t) =>
-        config.anchorGrepEnabled ? t !== "grep" : t !== "anchor_grep",
-      ),
+      pi.getActiveTools().filter((t) => {
+        if (config.anchorGrepEnabled ? t === "grep" : t === "anchor_grep") return false;
+        if (config.copyMoveEnabled === false && (t === "copy" || t === "move")) return false;
+        return true;
+      }),
     );
     const debugValue = process.env.PI_HASHLINE_DEBUG;
     if (debugValue === "1" || debugValue === "true") {
@@ -125,7 +133,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.registerCommand("hashline-config", {
-    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders/files, diff context, grep, path, strict input)",
+    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders/files, diff context, grep, copy/move, path, strict input)",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("/hashline-config requires interactive mode", "error");
@@ -146,6 +154,11 @@ export default function (pi: ExtensionAPI): void {
               const active = pi.getActiveTools();
               pi.setActiveTools(enabled ? [...new Set([...active.filter((t) => t !== "grep"), "anchor_grep"])] : [...new Set([...active.filter((t) => t !== "anchor_grep"), ...(grepWasActive ? ["grep"] : [])])]);
             }
+            else if (key === "copyMoveEnabled") {
+              const enabled = await toggleCopyMove();
+              const active = pi.getActiveTools();
+              pi.setActiveTools(enabled ? [...new Set([...active, "copy", "move"])] : active.filter((t) => t !== "copy" && t !== "move"));
+            }
             else if (key === "requirePath") await toggleRequirePath();
             else if (key === "strictInput") await toggleStrictInput();
             await refreshEditTools();
@@ -217,10 +230,11 @@ export default function (pi: ExtensionAPI): void {
         );
         const fileLines = splitLines(normalized);
         serveRows(absolutePath, fileHashes, fileLines, preview.servedHashes);
+        const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
         return {
           content: [
             ...(event.content ?? []),
-            { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
+            { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}${reclaimNotice !== undefined ? `\n\n${reclaimNotice}` : ""}` },
           ],
         };
       } catch (error) {
@@ -238,6 +252,8 @@ export default function (pi: ExtensionAPI): void {
     if (
       event.toolName !== "replace" &&
       event.toolName !== "insert" &&
+      event.toolName !== "copy" &&
+      event.toolName !== "move" &&
       event.toolName !== "undo_last_change"
     ) return;
     if (!autoRead) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
@@ -41,12 +41,12 @@
   "dependencies": {
     "diff": "^9.0.0",
     "file-type": "^22.0.2",
-    "typebox": "^1.3.7",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.84.0",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "engines": {
     "node": ">=22.19.0"
@@ -65,6 +65,7 @@
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4.1.11",
     "eslint": "^10.9.1",
+    "typebox": "^1.3.7",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.68.0",
     "vitest": "^4.1.11"

package/prompts/copy-guidelines.md

@@ -0,0 +1 @@
+- `copy`: the same anchor in `source_from` and `source_to` copies one line; copied lines get fresh anchors in the post-edit diff and the source rows keep theirs.

package/prompts/copy-snippet.md

@@ -0,0 +1 @@
+Copy lines to another position by anchor: `source_from`/`source_to` mark the range, the copy lands after `insert_after`; the anchors resolve both files

package/prompts/copy.md

@@ -0,0 +1,3 @@
+Copy a range of lines to another position, targeted by 4-character anchors from any served anchor│content row. Give `source_from` and `source_to` as bare anchors marking the first and last line to copy in the source file, and `insert_after` as the bare anchor of the destination line after which the copy goes. `source_from` and `source_to` may belong to a different file than `insert_after`: the lines are copied from the source file and inserted into the destination file, and an empty destination file is seeded with the copied lines. The source lines stay in place, and the copied lines are written exactly as the source file holds them.
+
+Example: read served `Hasu│old` in `a.ts` and `Qwer│top` in `b.ts`. Call { "source_from": "Hasu", "source_to": "Hasu", "insert_after": "Qwer" } copies `old` from `a.ts` into `b.ts` below `top`; the source `Hasu│old` row stays live.

package/prompts/grep.md

@@ -1 +1 @@
-Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace or insert without a new read; the `=== path ===` header and line numbers locate the match. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` / narrow path.
+Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace, insert, copy, or move without a new read; the `=== path ===` header and line numbers locate the match. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` / narrow path.

package/prompts/insert.md

@@ -1,3 +1,3 @@
-Insert lines after or before one existing line in a text file, addressed by a bare anchor from any served anchor│content row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes, no embedded newlines. Inserted lines are written exactly as given; nothing else in the file changes.
+Insert lines after or before one existing line in a text file, addressed by a bare anchor from any served anchor│content row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escape sequences such as `\n` or `\u200b` are not decoded. Inserted lines are written exactly as given; nothing else in the file changes.
 
 Same-file calls in one message batch: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.

package/prompts/move-guidelines.md

@@ -0,0 +1 @@
+- `move`: a cross-file move records one undo entry per file — undo both sides or the moved lines stay duplicated or missing. Lines between source and target may be re-anchored.

package/prompts/move-snippet.md

@@ -0,0 +1 @@
+Move lines to another position by anchor: `source_from`/`source_to` mark the range, it lands after `insert_after`; the anchors resolve both files

package/prompts/move.md

@@ -0,0 +1,3 @@
+Move a range of lines to another position, targeted by 4-character anchors from any served anchor│content row. Give `source_from` and `source_to` as bare anchors marking the first and last line to move in the source file, and `insert_after` as the bare anchor of the destination line after which the range goes. `source_from` and `source_to` may belong to a different file than `insert_after`: the range is removed from the source file and inserted into the destination file in one call, and an empty destination file is seeded with the moved lines. `insert_after` must sit outside the source range when both anchors share a file; moving a range in one file to where it already sits reports no change.
+
+Example: read served `Hasu│a` in `lib.ts` and `Qwer│top` in `app.ts`. Call { "source_from": "Hasu", "source_to": "Hasu", "insert_after": "Qwer" } moves `a` from `lib.ts` into `app.ts` below `top`.

package/prompts/read-guidelines.md

@@ -1,2 +1,3 @@
 - `read`: call again after an edit when you need anchors you lack — post-edit diff `+anchor│`/` anchor│` rows and any served `anchor│content` rows already carry fresh anchors for the changed range.
-- `read`: `E_AUTO_READ_ALL` on an attached file means its content is still exactly as it was when attached at the start of this session.
+- `read`: `E_AUTO_READ_ALL` on an attached file means its content is still exactly as it was when attached at the start of this session.
+- `read`: `[W_ANCHOR_RECLAIMED]` means the session's anchor quota was tight and the listed files' anchors were freed; read a freed file again before editing it.

package/prompts/replace-guidelines.md

@@ -1,6 +1,4 @@
 - `replace`: `-anchor│` rows in a post-edit diff are dead anchors; only `+anchor│` and ` anchor│` rows are live. Check the post-edit diff before the next turn's edits on that file.
 - `replace`: same-file same-message calls batch: disjoint ranges, one undo. A call whose anchors resolve nowhere fails alone; its file's batch still commits.
-- `replace`: `[E_STALE_ANCHOR]` means the anchor is not owned in this session: call `read` on the file for fresh anchors. `[E_RANGE_STALE]` means a line in the range changed since it was shown, or was never shown: retry with the fresh anchors the error returns.
-- `replace`: `[E_BATCH_OVERLAP]` means two batch calls share lines: retry with disjoint ranges. `[E_OP_ABORTED]` means another batch call failed or the file changed: fix that call, then retry, or call `read` for fresh anchors.
 - `replace`: use `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
 - `replace`: `replacement_lines`: one string per line, `[""]` is one blank line, `[]` deletes. Pasted `anchor│` prefixes are stripped. Single line: same anchor for `remove_from` and `remove_to`.

package/prompts/replace.md

@@ -1,4 +1,4 @@
-Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from any served anchor│content row. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes and no embedded newlines; `[]` deletes the range.
+Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from any served anchor│content row. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes. An element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escape sequences such as `\n` or `\u200b` are not decoded. `[]` deletes the range.
 
 Same-file calls in one message batch: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
 

package/prompts/undo-last-change-guidelines.md

@@ -1 +1,2 @@
-- `undo_last_change`: only the last `replace`/`insert` per file is undoable; a `write` clears it, so undo right after a bad diff — review the diff's `-anchor│` rows first to confirm what you're restoring.
+- `undo_last_change`: only the last `replace`/`insert`/`copy`/`move` per file is undoable; a `write` clears it, so undo right after a bad diff — review the diff's `-anchor│` rows first to confirm what you're restoring.
+- `undo_last_change`: a cross-file `move` records one undo entry per file; undo both the source and the destination to revert the whole move, because undoing one side alone leaves the moved lines duplicated or missing.

package/prompts/undo-last-change-snippet.md

@@ -1 +1 @@
-Single-level undo: reverts a file's last `replace` or `insert`
+Single-level undo: reverts a file's last `replace`, `insert`, `copy`, or `move`

package/prompts/undo-last-change.md

@@ -1 +1 @@
-Undo the last replace or insert on a file, restoring the previous content, BOM, and line endings. Use it when an edit removed or changed the wrong lines. If the file changed since that edit, the undo is refused with `[E_UNDO_STALE]` and nothing is modified: the record is kept, so verify the current state with read and stop instead of forcing the undo. A file deleted since the edit is restored. If the output says truncated, use read to see the full file.
+Undo the last replace, insert, copy, or move on a file, restoring the previous content, BOM, and line endings. Use it when an edit removed or changed the wrong lines. If the file changed since that edit, the undo is refused with `[E_UNDO_STALE]` and nothing is modified: the record is kept, so verify the current state with read and stop instead of forcing the undo. A file deleted since the edit is restored. If the output says truncated, use read to see the full file.

package/src/anchor-registry.ts

@@ -11,7 +11,7 @@ import { errCode, splitLines } from "./utils";
 import * as Diff from "diff";
 import { lineChecksum } from "./hashline";
 import { getAllocatedState, persistSnapshot, type HashStore } from "./hash-store";
-import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
+import { ANCHOR_POOL_EXHAUSTED_PREFIX, ANCHOR_RECLAIM_WARNING_CODE, MAX_RECLAIMED_PATHS_REPORTED } from "./constants";
 
 export type RegistryEvent =
   | { kind: "session"; sessionFile: string }
@@ -153,6 +153,10 @@ interface SessionState {
 	everMinted: AnchorMintedSet;
 	probe: number;
 	allocatedChecksum: Map<string, string>;
+	lastUsedAt: Map<string, number>;
+	usageClock: number;
+	reclaimed: string[];
+	shadow?: boolean;
 }
 
 const SIDECAR_SUFFIX = ".registry.jsonl";
@@ -176,7 +180,7 @@ function newSessionState(seed?: string): SessionState {
 			probe = (probe * 256 + byte) % ANCHOR_COUNT;
 		}
 	}
-	return { owned: new Map(), served: new Map(), everMinted: new Set(), probe, allocatedChecksum: new Map() };
+	return { owned: new Map(), served: new Map(), everMinted: new Set(), probe, allocatedChecksum: new Map(), lastUsedAt: new Map(), usageClock: 0, reclaimed: [] };
 }
 
 function seedServedFromOwned(state: SessionState): void {
@@ -195,9 +199,12 @@ export function foldRegistryEvents(events: RegistryEvent[], seed?: string): Sess
   for (const event of events) {
     if (event.kind === "clear") {
       state.owned.clear();
+      state.lastUsedAt.clear();
     } else if (event.kind === "minted") {
       for (const anchor of event.anchors) state.everMinted.add(anchor);
     } else if (event.kind === "allocate") {
+      state.usageClock += 1;
+      state.lastUsedAt.set(event.path, state.usageClock);
       for (const [anchor, checksum] of event.rows) {
         state.owned.set(anchor, { path: event.path, checksum });
         state.everMinted.add(anchor);
@@ -213,9 +220,15 @@ export function foldRegistryEvents(events: RegistryEvent[], seed?: string): Sess
             state.owned.delete(anchor);
           }
         }
+        state.lastUsedAt.delete(event.path);
       }
     }
   }
+  const ownedPaths = new Set<string>();
+  for (const entry of state.owned.values()) ownedPaths.add(entry.path);
+  for (const path of [...state.lastUsedAt.keys()]) {
+    if (!ownedPaths.has(path)) state.lastUsedAt.delete(path);
+  }
   return state;
 }
 
@@ -468,32 +481,96 @@ function fingerprintIndex(state: SessionState, path: string): Map<string, string
 
 export const MINT_PROBE_LIMIT = 8192;
 
-export function mintAnchor(state: SessionState): string {
-  for (let probe = 0; probe < MINT_PROBE_LIMIT; probe++) {
-    state.probe = (state.probe + HASH_PROBE_STRIDE) % ANCHOR_COUNT;
-    const candidate = anchorAt(state.probe);
-    if (!state.owned.has(candidate) && !state.everMinted.has(candidate)) {
-      return candidate;
+function touchPath(state: SessionState, path: string): void {
+	state.usageClock += 1;
+	state.lastUsedAt.set(path, state.usageClock);
+}
+
+function hasOwnedPath(state: SessionState, path: string): boolean {
+	for (const entry of state.owned.values()) {
+		if (entry.path === path) return true;
+	}
+	return false;
+}
+
+function evictPath(state: SessionState, path: string): string[] {
+	const anchors: string[] = [];
+	for (const [anchor, entry] of [...state.owned]) {
+		if (entry.path === path) {
+			anchors.push(anchor);
+			state.owned.delete(anchor);
+		}
+	}
+	state.served.delete(path);
+	state.lastUsedAt.delete(path);
+	if (anchors.length > 0 && state === current()) {
+		appendEvent({ kind: "free", path, anchors });
+	}
+	return anchors;
+}
+
+export function reclaimAnchorSpace(state: SessionState, protectPath?: string): string | undefined {
+	if (state.shadow) return undefined;
+	let victim: string | undefined;
+	let victimTime = Number.POSITIVE_INFINITY;
+	for (const [, entry] of state.owned) {
+		if (entry.path === protectPath) continue;
+		const time = state.lastUsedAt.get(entry.path) ?? -1;
+		if (time < victimTime) {
+			victimTime = time;
+			victim = entry.path;
+		}
+	}
+	if (victim === undefined) return undefined;
+	evictPath(state, victim);
+	state.reclaimed.push(victim);
+	return victim;
+}
+
+export function mintAnchor(state: SessionState, protectPath?: string): string {
+  for (;;) {
+    for (let probe = 0; probe < MINT_PROBE_LIMIT; probe++) {
+      state.probe = (state.probe + HASH_PROBE_STRIDE) % ANCHOR_COUNT;
+      const candidate = anchorAt(state.probe);
+      if (!state.owned.has(candidate) && !state.everMinted.has(candidate)) {
+        return candidate;
+      }
     }
-  }
-  for (let step = 1; step <= ANCHOR_COUNT; step++) {
-    const candidate = anchorAt((state.probe + step) % ANCHOR_COUNT);
-    if (!state.owned.has(candidate)) {
-      for (const served of state.served.values()) served.delete(candidate);
-      return candidate;
+    for (let step = 1; step <= ANCHOR_COUNT; step++) {
+      const candidate = anchorAt((state.probe + step) % ANCHOR_COUNT);
+      if (!state.owned.has(candidate)) {
+        for (const served of state.served.values()) served.delete(candidate);
+        return candidate;
+      }
     }
+    if (reclaimAnchorSpace(state, protectPath) === undefined) break;
   }
   throw new Error(
     `${ANCHOR_POOL_EXHAUSTED_PREFIX}; use write for very large files.`,
   );
 }
 
+export function takeReclaimedPaths(): string[] {
+	const state = current();
+	if (!state || state.reclaimed.length === 0) return [];
+	return state.reclaimed.splice(0, state.reclaimed.length);
+}
+
+export function formatAnchorReclaimNotice(paths: string[]): string | undefined {
+	const unique = [...new Set(paths)];
+	if (unique.length === 0) return undefined;
+	const shown = unique.slice(0, MAX_RECLAIMED_PATHS_REPORTED);
+	const more = unique.length - shown.length;
+	const list = more > 0 ? `${shown.join(", ")} (+${more} more)` : shown.join(", ");
+	return `${ANCHOR_RECLAIM_WARNING_CODE} The session's anchor quota is nearly exhausted; freed all anchors of ${list}, the files least recently read or edited. Read each freed file again before editing it; for read-heavy work, ask the user to run /clear-anchors or start a new session.`;
+}
+
 export function allocateAnchor(path: string, checksum: string): string {
   const state = current();
   if (!state) {
     throw new Error("[E_REGISTRY] The anchor registry is not initialized; call initRegistry on session_start first.");
   }
-  const anchor = mintAnchor(state);
+  const anchor = mintAnchor(state, path);
   state.everMinted.add(anchor);
   state.owned.set(anchor, { path, checksum });
   appendEvent({ kind: "allocate", path, rows: [[anchor, checksum]] });
@@ -505,26 +582,21 @@ export function allocateAnchor(path: string, checksum: string): string {
 export function freeAnchors(path: string, anchors?: string[]): void {
 	const state = current();
 	if (!state) return;
+	if (!anchors) {
+		evictPath(state, path);
+		return;
+	}
 	const freed: string[] = [];
-	if (anchors) {
-		for (const anchor of anchors) {
-			if (state.owned.has(anchor)) {
-				freed.push(anchor);
-				state.owned.delete(anchor);
-				state.served.get(path)?.delete(anchor);
-			}
+	for (const anchor of anchors) {
+		if (state.owned.has(anchor)) {
+			freed.push(anchor);
+			state.owned.delete(anchor);
+			state.served.get(path)?.delete(anchor);
 		}
-	} else {
-		for (const [anchor, entry] of [...state.owned]) {
-			if (entry.path === path) {
-				freed.push(anchor);
-				state.owned.delete(anchor);
-			}
-		}
-		state.served.delete(path);
 	}
 	if (freed.length > 0) {
-		appendEvent({ kind: "free", path, anchors: anchors ?? undefined });
+		if (!hasOwnedPath(state, path)) state.lastUsedAt.delete(path);
+		appendEvent({ kind: "free", path, anchors });
 	}
 }
 
@@ -534,6 +606,8 @@ export function clearRegistry(): void {
 	state.owned.clear();
 	state.served.clear();
 	state.allocatedChecksum.clear();
+	state.lastUsedAt.clear();
+	state.reclaimed.length = 0;
 	appendEvent({ kind: "clear" });
 }
 
@@ -609,6 +683,10 @@ export function shadowStateFrom(state: SessionState): SessionState {
 		everMinted: new ShadowMintedSet(state.everMinted),
 		probe: state.probe,
 		allocatedChecksum: state.allocatedChecksum,
+		lastUsedAt: new Map(state.lastUsedAt),
+		usageClock: state.usageClock,
+		reclaimed: [],
+		shadow: true,
 	};
 }
 
@@ -721,7 +799,7 @@ export function alignOwnershipWithSpans(
     }
     for (let k = 0; k < span.replacementCount; k++) {
       if (replacement[k] !== undefined) continue;
-      const anchor = mintAnchor(state);
+      const anchor = mintAnchor(state, path);
       const checksum = newChecksums[start + k]!;
       minted.push({ index: start + k, anchor, checksum });
       state.owned.set(anchor, { path, checksum });
@@ -769,7 +847,7 @@ export function alignOwnership(
     if (part.added) {
       for (let k = 0; k < count; k++) {
         const checksum = newChecksums[newIdx + k]!;
-        const anchor = mintAnchor(state);
+        const anchor = mintAnchor(state, path);
         state.everMinted.add(anchor);
         state.owned.set(anchor, { path, checksum });
         minted.push({ index: newIdx + k, anchor, checksum });
@@ -792,7 +870,7 @@ export function alignOwnership(
         const entry = state.owned.get(anchor);
         const checksum = newChecksums[newIdx + k]!;
         if (entry && entry.path !== path) {
-          const fresh = mintAnchor(state);
+          const fresh = mintAnchor(state, path);
           state.owned.set(fresh, { path, checksum });
           anchors[newIdx + k] = fresh;
         } else {
@@ -834,6 +912,7 @@ export async function allocateFileAnchors(
   ensureRegistry();
   const registry = current();
   const shadow = options?.shadow === true;
+  if (!shadow && registry) touchPath(registry, path);
   const lines = splitLines(content);
   const checksums = lines.map(lineChecksum);
   if (options?.previous?.spans) {
@@ -870,7 +949,7 @@ export async function allocateFileAnchors(
           const candidates = reuseIndex.get(checksum) ?? [];
           const taken = reuseTaken.get(checksum) ?? 0;
           reuseTaken.set(checksum, taken + 1);
-          const anchor = taken < candidates.length ? candidates[taken]! : mintAnchor(state);
+          const anchor = taken < candidates.length ? candidates[taken]! : mintAnchor(state, path);
           state.everMinted.add(anchor);
           state.owned.set(anchor, { path, checksum });
           return anchor;
@@ -890,6 +969,7 @@ export async function allocateFileAnchors(
 export function adoptAnchors(path: string, entries: Map<string, string>): void {
 	ensureRegistry();
 	const state = current()!;
+	touchPath(state, path);
 	let served = state.served.get(path);
 	if (!served) {
 		served = new Map();
@@ -967,12 +1047,17 @@ function isClaimedSidecar(sidecar: string): boolean {
   return false;
 }
 
+function isExpectedAccessError(error: unknown): boolean {
+  const code = errCode(error);
+  return code === "EPERM" || code === "EACCES";
+}
+
 export async function gcRegistrySidecars(): Promise<void> {
   let names: string[];
   try {
     names = await readdir(sessionClaimsDir());
   } catch (error) {
-    if (errCode(error) !== "ENOENT") console.error("Failed to list registry sidecars:", error);
+    if (errCode(error) !== "ENOENT" && !isExpectedAccessError(error)) console.error("Failed to list registry sidecars:", error);
     return;
   }
   for (const name of names) {
@@ -982,7 +1067,7 @@ export async function gcRegistrySidecars(): Promise<void> {
         const tmpStat = await stat(tmpPath);
         if (Date.now() - tmpStat.mtimeMs > 60 * 60 * 1000) await rm(tmpPath, { force: true });
       } catch (error) {
-        if (errCode(error) !== "ENOENT") console.error("Failed to inspect registry sidecar:", error);
+        if (errCode(error) !== "ENOENT" && !isExpectedAccessError(error)) console.error("Failed to inspect registry sidecar:", error);
       }
       continue;
     }
@@ -995,8 +1080,12 @@ export async function gcRegistrySidecars(): Promise<void> {
       await stat(sessionFile);
     } catch (error) {
       if (errCode(error) === "ENOENT") {
-        await rm(sidecar, { force: true });
-      } else {
+        try {
+          await rm(sidecar, { force: true });
+        } catch (removeError) {
+          if (!isExpectedAccessError(removeError)) throw removeError;
+        }
+      } else if (!isExpectedAccessError(error)) {
         console.error("Failed to inspect registry sidecar:", error);
       }
     }

package/src/auto-read-all.ts

@@ -11,6 +11,7 @@ import {
 } from "./constants";
 import { normalizeAutoReadAllIgnoreEntry, type AutoReadAllMode } from "./config";
 import { serveRows } from "./served";
+import { formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { resolveRgPath } from "./grep";
 import { globToRegex } from "./glob";
@@ -438,7 +439,8 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   const coverage = `[coverage: ${completeFiles} complete]`;
   const completeNames = sections.map((section) => section.file);
   const machineList = `[files complete: ${JSON.stringify(completeNames)} omitted: ${JSON.stringify(omitted)}]`;
-  const text = `${HEADER}\n\n${coverage}\n${machineList}\n\n${sectionTexts.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}`;
+  const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
+  const text = `${HEADER}\n\n${coverage}\n${machineList}\n\n${sectionTexts.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}${reclaimNotice !== undefined ? `\n${reclaimNotice}` : ""}`;
   return { text, files: sections.length, bytes, omitted, completeFiles };
 }