pi-hashline-edit-pro 6.4.5 → 6.4.7

package/README.md

@@ -302,6 +302,7 @@ Output is capped at `limit` matched lines, 2000 rows, and 50KB of text, whicheve
 
 - History is per-file and single-level: only the most recent `replace`, `replace_match`, `insert`, `copy`, or `move` can be reverted. A same-message batch of `replace`/`insert` calls on one file counts as one entry: one undo reverts the whole batch.
 - History is persisted and survives session restarts. A failed `write` does not clear it.
+- Undo records older than `undoRetentionDays` (default 30; `0` keeps them forever) are deleted when the store opens.
 - Every applied `replace`, `replace_match`, `insert`, `copy`, or `move` is undoable; the undo record is saved before the edit is written.
 - A cross-file `move` stores one undo entry per file; `undo_last_change` reverts the file you name, so revert both sides to undo the whole move; a batched cross-file `move` reverts its destination side with the batch's undo and its source side with its own entry.
 - A successful `write` clears the history for that file.
@@ -353,7 +354,7 @@ The setting lives in `/hashline-config` as Auto-read all and in `config.json` as
 
 | Command | Description |
 | --- | --- |
-| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, git repos only, ignore folders/files, disable on models, read on disabled models, diff context lines, `grep` tool, copy/move tools, replace_match tool, required `path`, and strict input. Persists across sessions. |
+| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, git repos only, ignore folders/files, disable on models, read on disabled models, diff context lines, `grep` tool, copy/move tools, replace_match tool, required `path`, strict input, and undo retention. Persists across sessions. |
 | `/clear-anchors` | Clear the session's anchor claims. Anchors are re-claimed on the next `read`. |
 
 Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a setting is first changed in `/hashline-config`:
@@ -370,6 +371,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
   "requirePath": false,
   "strictInput": false,
   "diffContextLines": 1,
+  "undoRetentionDays": 30,
   "disableOnModels": [],
   "readOnDisabledModels": "vanilla"
 }
@@ -389,6 +391,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
 | `diffContextLines` | Diff context | `1` | Surrounding lines in post-edit diffs, 0-10 (needs Auto-read). |
 | `disableOnModels` | Disable on models | `[]` | Model globs matched case-insensitively against `provider/id`, the bare `id`, and `api`, with `*` and `?` wildcards. A matching model gets no anchored edit tools, no auto-read, and no write-echo refusal; `read` stays available as pi's ordinary read unless Read on disabled models is `remove`. |
 | `readOnDisabledModels` | Read on disabled models | `"vanilla"` | `read` for a model matched by `disableOnModels`: `"vanilla"` keeps pi's ordinary `read` active while the anchored edit tools stay off; `"remove"` disables `read` with the rest of the anchored tools. |
+| `undoRetentionDays` | Undo retention | `30` | Days to keep undo history; records older than this are deleted when the store opens. `0` keeps them forever (0-3650). |
 
 `disableOnModels` turns off the whole anchored surface for the models you name, so another edit tool (`apply_patch`, a shell read) can own the session without competing instructions. A match removes `replace`, `replace_match`, `insert`, `copy`, `move`, `grep`, and `undo_last_change` from the active tools, and also `read` when Read on disabled models is `remove`, registering pi's plain `grep` for those models, and it also skips the auto-read-all injection, the auto-read block after `write`, the post-edit diff substitution, and the `write` hook that refuses a `write` echoing a served anchor. Because the extension's `read` replaces the built-in one, a matched model has no `read` at all under `remove` unless another extension provides one; the default `vanilla` gives those models pi's ordinary `read` while the anchored edit tools stay off. The list is checked on `session_start`, on `model_select`, and again on `before_agent_start`, so a model change inside a session switches the surface immediately and another extension cannot re-add the tools mid-session. The default `[]` leaves every model unchanged.
 
@@ -411,6 +414,7 @@ When `PI_HASHLINE_DIR` is unset or empty, non-Windows platforms honor `XDG_CONFI
 | Auto-read all budget | 200KB floor; 2MB ceiling in `full` | total injection size derived from the model context window; `outline` is not capped at 2MB |
 | Stale-range feedback | first 100 lines | rows returned with `[E_RANGE_STALE]` |
 | Session anchors | 1,353,139 anchors in use | all tools; the least recently read or edited files are freed when the quota is exhausted (`[W_ANCHOR_RECLAIMED]`) |
+| Undo retention | 30 days by default (`undoRetentionDays` 0-3650) | `undo_last_change` history |
 
 `grep` uses the same 100MB file-size cutoff as `read`. Files over the line cap are skipped silently in directory searches.
 
@@ -418,9 +422,9 @@ When `PI_HASHLINE_DIR` is unset or empty, non-Windows platforms honor `XDG_CONFI
 
 All eight tools return machine-readable metadata in `details` alongside the model-visible text.
 
-All eight tools also declare an `outputSchema` and return `structuredContent`, so codemode scripts receive anchors, line numbers, diffs, and errors as data instead of parsing the rendered text. The model still receives `content`. Every structured result is either `{ ok: true, kind, ... }` or `{ ok: false, kind: "error", error: { code, message } }`; a failed call is still a tool error (`isError: true`) and also carries `structuredContent`, so a script can branch on the code without matching the message.
+All eight tools also declare an `outputSchema` and return `structuredContent`, so codemode scripts receive anchors, line numbers, diffs, and errors as data instead of parsing the rendered text. For `read`, `text` is the raw file content of the served window and `lines` carries the anchored rows, so a script parses the file without anchor prefixes. The model still receives `content`. Every structured result is either `{ ok: true, kind, ... }` or `{ ok: false, kind: "error", error: { code, message } }`; a failed call is still a tool error (`isError: true`) and also carries `structuredContent`, so a script can branch on the code without matching the message.
 
-`read` returns `{ kind: "read", path, text, lines, totalLines, startLine, nextOffset, truncated, blockedByLongLine, hadUtf8DecodeErrors }`, where each entry of `lines` is `{ line, text, anchor, rendered }` for a row that was served (`text` is what was shown, so an oversized line appears as its marker while keeping its anchor). An image read returns `{ kind: "image", path, mimeType }`.
+`read` returns `{ kind: "read", path, text, lines, totalLines, startLine, nextOffset, truncated, blockedByLongLine, hadUtf8DecodeErrors, notices }`, where `text` is the raw file content of the served window (no anchors, no footers) and each entry of `lines` is `{ line, text, anchor, rendered }` for a row that was served (`text` there is what was shown, so an oversized line appears as its marker while keeping its anchor). `notices` carries non-file notes such as the UTF-8 rewrite note and `[W_ANCHOR_RECLAIMED]`. An image read returns `{ type: "image", data, mimeType, note }`.
 
 `replace`, `replace_match`, `insert`, `copy`, `move`, and `undo_last_change` return `{ kind: "edit", verb, classification, path, text, diff, warnings, hints, firstChangedLine, anchors, anchorsOmitted }`, where `verb` is `"replaced"`, `"inserted"`, `"copied"`, `"moved"`, or `"undone"`, `anchors` are the live rows of the post-edit diff, and `anchorsOmitted` is true when the diff was truncated or carried no rows, meaning a fresh read is needed. A cross-file move reports the destination file and its anchors.
 
@@ -482,12 +486,12 @@ Full reference:
 | `[E_UNDO_NONE]` | `undo_last_change` found no recorded edit for the file. Nothing was changed; make an edit first. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown; a pure deletion checks only its first and last line). The edit was refused; the current range is returned with fresh anchors. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
-| `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
+| `[E_REGISTRY]` | The anchor registry was not initialized, or the session's registry was released because the session was replaced or reloaded; a serve or edit ran without a usable session. Retry the operation in the current session. |
 | `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line reproduces a served row for this file (a bare `anchor│` read row, a `+anchor│`, ` anchor│`, or `-anchor│` diff row, or a `lineNumber:│ anchor│content` grep row). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched edit calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
-| `[E_OP_ABORTED]` | A batch-level failure aborted the edit before writing (the base read failed, a cross-file member could not be prepared, the file changed or was deleted during the batch, or the composed result exceeded a limit). Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |
+| `[E_OP_ABORTED]` | The edit was aborted before writing: the file changed or was deleted after it was read (a single edit or a cross-file move reports the file; a batch reports the batch and the failing call), the base read failed, a cross-file member could not be prepared, or the composed result exceeded a limit. Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The batch abort names the failing call and its error code when one is known. |
 | `[E_GREP_FAILED]` | `grep` could not start ripgrep or ripgrep exited with an error (for example a pattern with backreferences or look-around, which ripgrep's regex engine does not support); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. |
 | `[E_GREP_TIMEOUT]` | `grep` timed out after 10 seconds; narrow `path` or simplify `pattern` and retry. |
 
@@ -513,7 +517,7 @@ All state lives under the config directory (see [Configuration](#configuration))
 | `hash-store.sqlite` (+ `-wal`, `-shm`) | Per-file snapshots of allocated anchors keyed by content checksum, plus the undo table. |
 | `sessions/<key>.registry.jsonl` | The session's anchor ownership log (`allocate`/`free`/`clear` events). |
 
-The undo table contains the complete pre-edit and post-edit text for the latest edit to each file, so treat the store as sensitive data. On POSIX systems the state directory is restricted to mode `0700` and the SQLite database plus its WAL/SHM sidecars to `0600`. Sidecar logs whose session file is gone are garbage-collected at startup (never the sidecar of a session that is currently loaded in this process); the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use. Served records live in memory only and are recomputed on the next read.
+The undo table contains the complete pre-edit and post-edit text for the latest edit to each file, so treat the store as sensitive data. Undo records older than `undoRetentionDays` are deleted when the store opens, and SQLite's `secure_delete` overwrites deleted content. On POSIX systems the state directory is restricted to mode `0700` and the SQLite database plus its WAL/SHM sidecars to `0600`. Sidecar logs whose session file is gone are garbage-collected at startup (never the sidecar of a session that is currently loaded in this process); the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use. Served records live in memory only and are recomputed on the next read.
 
 ### Isolated state
 

package/index.ts

@@ -29,11 +29,13 @@ import {
   toggleRequirePath,
   toggleStrictInput,
   adjustDiffContextLines,
+  adjustUndoRetentionDays,
+  getUndoRetentionDays,
   setAutoReadAllIgnoreFromText,
   setDisableOnModelsFromText,
 } from "./src/config";
-import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
+import { loadHashStore, pruneExpiredUndo, pruneMissing } from "./src/hash-store";
+import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, sessionContextReadable, 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";
@@ -69,6 +71,7 @@ export default function (pi: ExtensionAPI): void {
   let autoReadAllRequireGit = true;
   let disableOnModels: string[] = [];
   let readOnDisabledModels: ReadOnDisabledModels = "vanilla";
+  let codemodeActive = false;
   let readFlavor: "anchored" | "vanilla" = "anchored";
   let readFlavorCwd: string | undefined;
   let autoReadAllInjected = false;
@@ -81,7 +84,8 @@ export default function (pi: ExtensionAPI): void {
 
   async function refreshEditTools(): Promise<void> {
     try {
-      const flags = await currentEditFlags(pi.getActiveTools().includes("codemode"));
+      codemodeActive = pi.getActiveTools().includes("codemode");
+      const flags = await currentEditFlags(codemodeActive);
       if (readFlavor !== "vanilla") regRead(pi, flags);
       regReplace(pi, flags);
       regReplaceMatch(pi, flags);
@@ -154,14 +158,7 @@ export default function (pi: ExtensionAPI): void {
     const key = sessionKeyFor(ctx);
     const entry: PendingRegistrySession = {
       key,
-      alive: () => {
-        try {
-          void ctx?.sessionManager;
-          return true;
-        } catch {
-          return false;
-        }
-      },
+      alive: () => sessionContextReadable(ctx),
     };
     const index = key === undefined ? -1 : pendingRegistrySessions.findIndex((candidate) => candidate.key === key);
     if (index >= 0) pendingRegistrySessions[index] = entry;
@@ -174,7 +171,8 @@ export default function (pi: ExtensionAPI): void {
     releaseRegistrySession(key);
   }
 
-  async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
+  async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T | undefined> {
+    if (!sessionContextReadable(ctx)) return undefined;
     captureRegistrySession(ctx);
     return withAnchorSession(ctx, fn);
   }
@@ -190,6 +188,11 @@ export default function (pi: ExtensionAPI): void {
     loadHashStore()
       .then(async store => {
         freeAnchorsForPaths(await pruneMissing(store));
+        try {
+          pruneExpiredUndo(store, await getUndoRetentionDays());
+        } catch (error) {
+          console.error("Failed to prune expired undo records:", error);
+        }
       })
       .catch(err => {
         console.error("Failed to load hash store:", err);
@@ -258,6 +261,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.on("before_agent_start", async (_event, ctx) => withRegistrySession(ctx, async () => {
+    if (pi.getActiveTools().includes("codemode") !== codemodeActive) await refreshEditTools();
     await syncModelGate(ctx.model, ctx.cwd);
     if (autoReadAll === "off" || autoReadAllInjected) return;
     if (modelDisabled(ctx.model, disableOnModels)) return;
@@ -294,6 +298,7 @@ export default function (pi: ExtensionAPI): void {
             else if (key === "disableOnModels") disableOnModels = await setDisableOnModelsFromText(value ?? "");
             else if (key === "readOnDisabledModels") readOnDisabledModels = await cycleReadOnDisabledModels(delta);
             else if (key === "diffContextLines") await adjustDiffContextLines(delta ?? 1);
+            else if (key === "undoRetentionDays") await adjustUndoRetentionDays((delta ?? 1) * 5);
             else if (key === "anchorGrepEnabled") {
               const enabled = await toggleAnchorGrep();
               grepEnabled = enabled;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.5",
+  "version": "6.4.7",
   "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",

package/src/anchor-registry.ts

@@ -406,7 +406,7 @@ async function ensureRegistryForKey(key: string, sessionFile: string | undefined
   try {
     await promise;
   } finally {
-    pendingInits.delete(key);
+    if (pendingInits.get(key) === promise) pendingInits.delete(key);
   }
 }
 
@@ -435,6 +435,15 @@ function sessionFileFor(ctx: AnchorSessionContext | undefined): string | undefin
   return typeof sessionFile === "string" && sessionFile.length > 0 ? sessionFile : undefined;
 }
 
+export function sessionContextReadable(ctx: AnchorSessionContext | undefined): boolean {
+  try {
+    void ctx?.sessionManager;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function withAnchorSession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
   const key = sessionKeyFor(ctx);
   if (key === undefined) return fn();
@@ -712,6 +721,9 @@ export function ownersForPath(path: string): Map<string, string> {
 export function ensureRegistry(): void {
   const key = activeKey();
   if (key && registries.has(key)) return;
+  if (sessionScope.getStore() !== undefined) {
+    throw new Error("[E_REGISTRY] The anchor registry for this session is no longer available; the session was replaced or reloaded. Retry the operation in the new session.");
+  }
   initRegistry(undefined).catch(() => undefined);
 }
 
@@ -973,8 +985,18 @@ export async function allocateFileAnchors(
     if (previousState && snapshotMatchesAllocation(registry, path, previousState.contentChecksum)) {
       prevAnchors = previousState.anchors;
       prevChecksums = previousState.checksums;
-      if (!prevChecksums && previousState.contentChecksum === contentChecksum(content)) {
-        prevChecksums = checksums;
+      if (!prevChecksums) {
+        if (previousState.contentChecksum === contentChecksum(content)) {
+          prevChecksums = checksums;
+        } else if (!shadow) {
+          const state = current();
+          const stale = state && prevAnchors ? prevAnchors.filter((anchor) => state.owned.get(anchor)?.path === path) : [];
+          if (state && stale.length > 0) {
+            const usedAt = state.lastUsedAt.get(path);
+            freeAnchors(path, stale);
+            if (usedAt !== undefined) state.lastUsedAt.set(path, usedAt);
+          }
+        }
       }
     }
   }

package/src/batch.ts

@@ -505,7 +505,7 @@ function batchPlaceholder(member: PlannedMember, piece: BatchPiece, snapshotId:
     edits_noop: piece.noop ? 1 : 0,
     warnings: 0,
     classification: piece.noop ? "noop" : "applied",
-    ...(piece.noop ? {} : { added_lines: added, removed_lines: piece.end - piece.start + 1 }),
+    ...(piece.noop ? {} : { added_lines: added, removed_lines: Math.max(0, piece.end - piece.start + 1 - piece.foldedLines) }),
   };
   const structuredContent: EditStructured = {
     ok: true,
@@ -1102,7 +1102,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   let added = 0;
   let removed = 0;
   for (const piece of appliedPieces) {
-    removed += piece.end - piece.start + 1;
+    removed += Math.max(0, piece.end - piece.start + 1 - piece.foldedLines);
     added += Math.max(0, piece.newLines.length - piece.foldedLines);
   }
   const verb = batchVerb(runtime);

package/src/commit.ts

@@ -14,6 +14,28 @@ import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { applyEndingOverrides, joinSeparators, separatorsForSpans } from "./line-endings";
 import { toEditVerb } from "./structured";
+export type FileStateSinceRead = "unchanged" | "deleted" | "changed";
+
+export async function fileStateSinceRead(
+  mutationTargetPath: string,
+  displayPath: string,
+  expectedNormalized: string,
+  signal?: AbortSignal,
+): Promise<FileStateSinceRead> {
+  abortIf(signal);
+  let raw: string | undefined;
+  try {
+    raw = await readFile(mutationTargetPath, "utf-8");
+  } catch (error) {
+    const code = errCode(error);
+    if (code === "ENOENT") raw = undefined;
+    else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${displayPath}`);
+    else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${displayPath}`);
+    else throw mapIoError(error, "read", displayPath);
+  }
+  if (raw === undefined) return "deleted";
+  return toLF(stripBOM(raw).text) === expectedNormalized ? "unchanged" : "changed";
+}
 export interface CommitMeta {
   editAnchors?: [string, string];
   anchorCarry?: number;
@@ -91,21 +113,11 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
-  abortIf(signal);
-  let currentRaw: string | undefined;
-  try {
-    currentRaw = await readFile(mutationTargetPath, "utf-8");
-  } catch (error) {
-    const code = errCode(error);
-    if (code === "ENOENT") currentRaw = undefined;
-    else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${path}`);
-    else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
-    else throw mapIoError(error, "read", path);
-  }
-  if (currentRaw === undefined) {
+  const state = await fileStateSinceRead(mutationTargetPath, path, pipe.originalNormalized, signal);
+  if (state === "deleted") {
     throw new Error(`[E_OP_ABORTED] Edit aborted: the file was deleted after the edit started.`);
   }
-  if (toLF(stripBOM(currentRaw).text) !== pipe.originalNormalized) {
+  if (state === "changed") {
     throw new Error(`[E_OP_ABORTED] Edit aborted: the file changed after the edit started. Call read for fresh anchors and retry.`);
   }
   const undo = await saveUndo(mutationTargetPath, {
@@ -141,7 +153,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     firstChangedLine: pipe.firstChangedLine,
     lastChangedLine: pipe.lastChangedLine,
     addedLines: Math.max(0, pipe.totalAddedLines - (meta.foldedAnchorLines ?? 0)),
-    removedLines: pipe.totalRemovedLines,
+    removedLines: Math.max(0, pipe.totalRemovedLines - (meta.foldedAnchorLines ?? 0)),
   };
 
   let resultHashes: string[];

package/src/config-ui.ts

@@ -1,8 +1,8 @@
 import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { readConfig, type Config } from "./config";
+import { DEFAULT_UNDO_RETENTION_DAYS, readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllRequireGit" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "readOnDisabledModels";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllRequireGit" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "readOnDisabledModels" | "undoRetentionDays";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -40,6 +40,7 @@ export function configRows(config: Config): ConfigRow[] {
     { key: "strictInput", group: "Edit behavior", depth: 0, label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
     { key: "disableOnModels", group: "Model gating", depth: 0, label: "Disable on models", hint: "Model globs that turn off anchored tools (comma-separated)", enabled: (config.disableOnModels ?? []).length > 0, entries: config.disableOnModels ?? [] },
     { key: "readOnDisabledModels", group: "Model gating", depth: 1, dependsOn: "disableOnModels", gated: true, label: "Read on disabled models", hint: "Keep read available for models disabled above", enabled: (config.readOnDisabledModels ?? "vanilla") !== "remove", mode: config.readOnDisabledModels ?? "vanilla", cycle: ["remove", "vanilla"] },
+    { key: "undoRetentionDays", group: "State", depth: 0, label: "Undo retention", hint: "Days to keep undo history; 0 keeps it forever", enabled: (config.undoRetentionDays ?? DEFAULT_UNDO_RETENTION_DAYS) > 0, value: config.undoRetentionDays ?? DEFAULT_UNDO_RETENTION_DAYS },
   ];
   for (const row of rows) {
     if (row.gated !== true || row.dependsOn === undefined) continue;

package/src/config.ts

@@ -12,6 +12,9 @@ const READ_ON_DISABLED_MODELS: ReadOnDisabledModels[] = ["remove", "vanilla"];
 export const DEFAULT_DIFF_CONTEXT_LINES = 1;
 export const MIN_DIFF_CONTEXT_LINES = 0;
 export const MAX_DIFF_CONTEXT_LINES = 10;
+export const DEFAULT_UNDO_RETENTION_DAYS = 30;
+export const MIN_UNDO_RETENTION_DAYS = 0;
+export const MAX_UNDO_RETENTION_DAYS = 3650;
 
 export interface Config {
   autoRead: boolean;
@@ -26,6 +29,7 @@ export interface Config {
   diffContextLines?: number;
   disableOnModels?: string[];
   readOnDisabledModels?: ReadOnDisabledModels;
+  undoRetentionDays?: number;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -41,6 +45,7 @@ const DEFAULT_CONFIG: Config = {
   diffContextLines: DEFAULT_DIFF_CONTEXT_LINES,
   disableOnModels: [],
   readOnDisabledModels: "vanilla",
+  undoRetentionDays: DEFAULT_UNDO_RETENTION_DAYS,
 };
 
 function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
@@ -101,6 +106,14 @@ export function normalizeDiffContextLines(value: unknown): number {
   return floored;
 }
 
+export function normalizeUndoRetentionDays(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_UNDO_RETENTION_DAYS;
+  const floored = Math.floor(value);
+  if (floored < MIN_UNDO_RETENTION_DAYS) return MIN_UNDO_RETENTION_DAYS;
+  if (floored > MAX_UNDO_RETENTION_DAYS) return MAX_UNDO_RETENTION_DAYS;
+  return floored;
+}
+
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
   if (!isRec(parsed) || (parsed.autoRead !== undefined && typeof parsed.autoRead !== "boolean")) {
@@ -118,6 +131,7 @@ function parseConfig(content: string): Config {
   const autoReadAllIgnore = parsed.autoReadAllIgnore;
   const disableOnModels = parsed.disableOnModels;
   const readOnDisabledModels = parsed.readOnDisabledModels;
+  const undoRetentionDays = parsed.undoRetentionDays;
   const legacyDisableReadOnModels = parsed.disableReadOnModels;
   return {
     autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
@@ -132,6 +146,7 @@ function parseConfig(content: string): Config {
     autoReadAllIgnore: parseAutoReadAllIgnore(autoReadAllIgnore),
     disableOnModels: parseDisableOnModels(disableOnModels),
     readOnDisabledModels: parseReadOnDisabledModels(readOnDisabledModels, legacyDisableReadOnModels),
+    undoRetentionDays: normalizeUndoRetentionDays(undoRetentionDays),
   };
 }
 
@@ -277,6 +292,9 @@ export const toggleStrictInput = (): Promise<boolean> => toggleFlag("strictInput
 export async function getDiffContextLines(): Promise<number> {
   return normalizeDiffContextLines((await readConfig()).diffContextLines);
 }
+export async function getUndoRetentionDays(): Promise<number> {
+  return normalizeUndoRetentionDays((await readConfig()).undoRetentionDays);
+}
 export async function adjustDiffContextLines(delta: number): Promise<number> {
   let next = DEFAULT_DIFF_CONTEXT_LINES;
   await updateConfig((c) => {
@@ -285,6 +303,14 @@ export async function adjustDiffContextLines(delta: number): Promise<number> {
   });
   return next;
 }
+export async function adjustUndoRetentionDays(delta: number): Promise<number> {
+  let next = DEFAULT_UNDO_RETENTION_DAYS;
+  await updateConfig((c) => {
+    next = normalizeUndoRetentionDays(normalizeUndoRetentionDays(c.undoRetentionDays) + delta);
+    c.undoRetentionDays = next;
+  });
+  return next;
+}
 export async function setAutoReadAllIgnore(dirs: string[]): Promise<string[]> {
   let next: string[] = [];
   await updateConfig((c) => {

package/src/copy-move.ts

@@ -3,7 +3,7 @@ import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, withFil
 import { Type } from "typebox";
 import { constants } from "node:fs";
 import { execPipeline, noteAnchorError, previewFromPipe, previewError, type PipelineResult, type ReplaceDetails } from "./replace";
-import { commitEdit } from "./commit";
+import { commitEdit, fileStateSinceRead } from "./commit";
 import { readNormFile, safeSnapId, type NormFile } from "./file-reader";
 import { preEditSnapshotFor } from "./pre-edit-snapshot";
 import {
@@ -377,6 +377,17 @@ async function commitMovePair(input: {
     warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
   }
 
+  const destinationState = await fileStateSinceRead(input.destination.mutationTargetPath, input.destination.displayPath, input.destination.pipe.originalNormalized, input.signal);
+  if (destinationState !== "unchanged") {
+    const verb = destinationState === "deleted" ? "was deleted" : "changed";
+    throw new Error(`[E_OP_ABORTED] Edit aborted: ${input.destination.displayPath} ${verb} after the move started. Call read for fresh anchors and retry.`);
+  }
+  const sourceState = await fileStateSinceRead(input.source.mutationTargetPath, input.source.displayPath, input.source.pipe.originalNormalized, input.signal);
+  if (sourceState !== "unchanged") {
+    const verb = sourceState === "deleted" ? "was deleted" : "changed";
+    throw new Error(`[E_OP_ABORTED] Edit aborted: ${input.source.displayPath} ${verb} after the move started. Call read for fresh anchors and retry.`);
+  }
+
   const undoDestination = await saveUndo(input.destination.mutationTargetPath, pairEntry(input.destination.pipe, destinationSeparators));
   if (!undoDestination.persisted) {
     throw new Error(`[E_UNDO_UNAVAILABLE] Could not persist undo history for ${input.destination.displayPath}. Nothing was written.`);
@@ -451,7 +462,7 @@ async function commitMovePair(input: {
       firstChangedLine: input.destination.pipe.firstChangedLine,
       lastChangedLine: input.destination.pipe.lastChangedLine,
       addedLines: Math.max(0, input.destination.pipe.totalAddedLines - input.destination.foldedAnchorLines),
-      removedLines: input.destination.pipe.totalRemovedLines,
+      removedLines: Math.max(0, input.destination.pipe.totalRemovedLines - input.destination.foldedAnchorLines),
     },
     ...(destinationSpan !== undefined ? { spans: [destinationSpan] } : {}),
   }, "moved", contextLines);
@@ -932,6 +943,7 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
       ],
     },
     flags,
+    { scriptGuidelines: kind === "copy" },
   );
   return {
     name: kind,

package/src/edit-common.ts

@@ -55,6 +55,13 @@ const SHARED_PAYLOAD_OPS = ["replace", "replace_match", "insert"];
 const SHARED_DIFF_OPS = ["replace", "replace_match", "insert", "copy", "move", "undo_last_change"];
 const RESULT_CONTRACT_GUIDELINE =
   'When called from a codemode script, failures resolve to `{ ok: false, kind: "error", error: { code, message } }`; branch on `ok` instead of `try`/`catch`.';
+const READ_SCRIPT_GUIDELINE =
+  '`read`: a codemode script receives `{ text, lines, notices }`; `text` is the raw file content of the served window and `lines[].anchor` is the editable anchor. An image read resolves to an image block.';
+const GREP_SCRIPT_GUIDELINE =
+  '`grep`: a codemode script receives `{ text, results }`; each `results[].lines[]` entry carries the matching line\'s `anchor` and `text`, so a result is editable without a fresh read.';
+function editScriptGuideline(flags: EditToolFlags): string {
+  return `${operationNames(SHARED_EDIT_OPS, flags)}: a codemode script receives \`{ ok, kind: "edit", classification, diff, anchors, anchorsOmitted }\`; reuse \`anchors[].anchor\` to chain the next edit, and read again when \`anchorsOmitted\` is true.`;
+}
 const SCRIPT_BATCH_GUIDELINE =
   "Script calls apply immediately in order, and only the most recent edit per file is undoable.";
 const SCRIPT_TRANSFER_GUIDELINE =
@@ -106,31 +113,20 @@ function strictInputGuideline(flags: EditToolFlags): string {
   return `${tools}: strict-input mode is on; auto-fixable slips are rejected instead of fixed with warnings.`;
 }
 
-function finalizePrompts(
-  description: string,
-  snippet: string,
-  guidelines: string[],
-  flags: EditToolFlags,
-  options?: { stringPayload?: boolean },
-): { description: string; snippet: string; guidelines: string[] } {
+export function withReplacePrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  let description = base.description;
   const shared = [batchGuideline(flags), pathGuideline(flags)];
-  if (flags.codemode) shared.push(RESULT_CONTRACT_GUIDELINE);
+  if (flags.codemode) shared.push(editScriptGuideline(flags));
   if (flags.autoRead) shared.push(diffGuideline(flags));
-  if (options?.stringPayload !== false) shared.push(payloadGuideline(flags));
+  shared.push(payloadGuideline(flags));
   if (flags.strictInput) shared.push(strictInputGuideline(flags));
-  return { description, snippet, guidelines: [...guidelines, ...shared] };
-}
-
-export function withReplacePrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  let description = base.description;
-  const guidelines = [preferenceGuideline(flags), ...base.guidelines.map((guideline) => guideline.text)];
   if (!flags.replaceMatchEnabled) {
     description = description
       .split(/(?<=\.)\s+/)
       .filter((sentence) => !sentence.includes("`replace_match`"))
       .join(" ");
   }
-  return finalizePrompts(description, base.snippet, guidelines, flags);
+  return { description, snippet: base.snippet, guidelines: [...base.guidelines.map((guideline) => guideline.text), ...shared] };
 }
 
 function readGuidelineApplies(guideline: Guideline, flags: EditToolFlags): boolean {
@@ -141,7 +137,7 @@ function readGuidelineApplies(guideline: Guideline, flags: EditToolFlags): boole
 
 export function withReadPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
   const preference = preferenceGuideline(flags);
-  const script = flags.codemode ? [RESULT_CONTRACT_GUIDELINE] : [];
+  const script = flags.codemode ? [READ_SCRIPT_GUIDELINE, RESULT_CONTRACT_GUIDELINE] : [];
   const applicable = base.guidelines.filter((guideline) => readGuidelineApplies(guideline, flags));
   if (flags.autoReadAllActive) {
     const rewritten = applicable.filter((guideline) => guideline.id !== READ_REREAD_ID).map((guideline) => guideline.text);
@@ -153,16 +149,14 @@ export function withReadPrompts(base: { description: string; snippet: string; gu
   return { description: base.description, snippet: base.snippet, guidelines: [preference, ...guidelines, ...script] };
 }
 
-export function withInsertPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [preferenceGuideline(flags), ...base.guidelines.map((guideline) => guideline.text)];
-  return finalizePrompts(base.description, base.snippet, guidelines, flags);
+export function withInsertPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, _flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  return { description: base.description, snippet: base.snippet, guidelines: base.guidelines.map((guideline) => guideline.text) };
 }
 
 export function withReplaceMatchPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [preferenceGuideline(flags), ...base.guidelines.map((guideline) => guideline.text)];
-  const prompted = finalizePrompts(base.description, base.snippet, guidelines, flags);
-  if (flags.strictInput) prompted.guidelines.push("`replace_match`: strict-input mode rejects an `old_string` that covers the whole range or retypes unchanged text.");
-  return prompted;
+  const guidelines = base.guidelines.map((guideline) => guideline.text);
+  if (flags.strictInput) guidelines.push("`replace_match`: strict-input mode rejects an `old_string` that covers the whole range or retypes unchanged text.");
+  return { description: base.description, snippet: base.snippet, guidelines };
 }
 
 function gatedEditOps(ops: string[], flags: EditToolFlags): string[] {
@@ -183,8 +177,8 @@ function joinOps(ops: string[], options?: { backtick?: boolean; separator?: "/"
 }
 
 export function withGrepPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [preferenceGuideline(flags), ...base.guidelines.map((guideline) => guideline.text)];
-  if (flags.codemode) guidelines.push(RESULT_CONTRACT_GUIDELINE);
+  const guidelines = base.guidelines.map((guideline) => guideline.text);
+  if (flags.codemode) guidelines.push(GREP_SCRIPT_GUIDELINE);
   if (flags.copyMoveEnabled) return { description: base.description, snippet: base.snippet, guidelines };
   const description = base.description.replaceAll(GREP_OPS_PHRASE, joinOps(gatedEditOps(["replace", "insert", "copy", "move"], flags)));
   return { description, snippet: base.snippet, guidelines };
@@ -192,10 +186,9 @@ export function withGrepPrompts(base: { description: string; snippet: string; gu
 
 export function withUndoPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
   const ops = gatedEditOps(["replace", "replace_match", "insert", "copy", "move"], flags);
-  const script = flags.codemode ? [RESULT_CONTRACT_GUIDELINE, SCRIPT_UNDO_GUIDELINE] : [];
+  const script = flags.codemode ? [SCRIPT_UNDO_GUIDELINE] : [];
   let description = base.description;
   let guidelines = [
-    preferenceGuideline(flags),
     ...base.guidelines
       .filter((guideline) => flags.copyMoveEnabled || guideline.id !== UNDO_CROSS_FILE_MOVE_ID)
       .map((guideline) => (guideline.id === UNDO_WRITE_CLEARS_ID && !flags.autoRead ? NEUTRAL_UNDO_WRITE_CLEARS : guideline.text)),
@@ -208,9 +201,10 @@ export function withUndoPrompts(base: { description: string; snippet: string; gu
   return { description, snippet: base.snippet, guidelines };
 }
 
-export function withTransferPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [preferenceGuideline(flags), ...base.guidelines.map((guideline) => guideline.text), ...(flags.codemode ? [SCRIPT_TRANSFER_GUIDELINE] : [])];
-  return finalizePrompts(base.description, base.snippet, guidelines, flags, { stringPayload: false });
+export function withTransferPrompts(base: { description: string; snippet: string; guidelines: Guideline[] }, flags: EditToolFlags, options?: { scriptGuidelines?: boolean }): { description: string; snippet: string; guidelines: string[] } {
+  const guidelines = base.guidelines.map((guideline) => guideline.text);
+  if (flags.codemode && options?.scriptGuidelines !== false) guidelines.push(SCRIPT_TRANSFER_GUIDELINE);
+  return { description: base.description, snippet: base.snippet, guidelines };
 }
 
 function staleAnchorMessage(ref: string, hash: string, owners: Array<OwnedAnchor | undefined>): string {

package/src/hash-store.ts

@@ -136,6 +136,7 @@ interface Prepared {
   undoDelete: (...params: SqlParams) => void;
   snapshotTime: (...params: SqlParams) => Record<string, unknown> | undefined;
   undoTime: (...params: SqlParams) => Record<string, unknown> | undefined;
+  undoExpired: (...params: SqlParams) => Record<string, unknown>[];
 }
 
 export interface HashStore {
@@ -183,6 +184,7 @@ function addColumnIfMissing(db: RawDb, statement: string): void {
 function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
+  db.exec("PRAGMA secure_delete = ON");
   db.exec(
     "CREATE TABLE IF NOT EXISTS snapshots (" +
       "path TEXT PRIMARY KEY, " +
@@ -242,6 +244,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const undoDelStmt = db.prepare("DELETE FROM undo 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 undoExpiredStmt = db.prepare("SELECT path FROM undo WHERE updated_at < ?");
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
@@ -253,6 +256,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     undoDelete: retriedWrite(undoDelStmt),
     snapshotTime: (...params) => snapshotTimeStmt.get(...params) as Record<string, unknown> | undefined,
     undoTime: (...params) => undoTimeStmt.get(...params) as Record<string, unknown> | undefined,
+    undoExpired: (...params) => withBusyRetry(() => undoExpiredStmt.all(...params) as Record<string, unknown>[]),
   };
   return { db, stmts };
 }
@@ -651,6 +655,17 @@ export async function pruneMissing(store: HashStore): Promise<string[]> {
   for (const path of missing) snapshotCache.delete(path);
   return missing;
 }
+export function pruneExpiredUndo(store: HashStore, retentionDays: number, now = Date.now()): string[] {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return [];
+  const cutoff = now - retentionDays * 24 * 60 * 60 * 1000;
+  const rows = store.stmts.undoExpired(cutoff) as { path?: unknown }[];
+  const paths = rows.map((row) => row.path).filter((path): path is string => typeof path === "string");
+  if (paths.length === 0) return [];
+  withStore(() => {
+    for (const path of paths) store.stmts.undoDelete(path);
+  });
+  return paths;
+}
 
 
 

package/src/read.ts

@@ -346,8 +346,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 						context: typeof ctx,
 					) => ReturnType<typeof builtinRead.execute>;
 					const imageResult = await executeBuiltinRead(_toolCallId, params, signal, _onUpdate, ctx);
-					const imageStructured: ReadResult = { ok: true, kind: "image", path: rawPath, mimeType: file.mimeType };
-					return { ...imageResult, structuredContent: imageStructured };
+					return { ...imageResult, structuredContent: imageResult.structuredContent as ReadResult };
 				}
 	      const { normalized, fileHashes, hadUtf8DecodeErrors, absolutePath: resolvedPath } = await readNormFile(
 	        rawPath, ctx.cwd, { signal, preloadedFile: file, maxLines: MAX_HASH_LINES },
@@ -363,24 +362,27 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 				serveRows(resolvedPath, fileHashes, fileLines, preview.servedHashes);
 				const snapshotId = await safeSnapId(absolutePath, "read");
 				const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
-				const previewText = [
-					preview.text,
+				const notices = [
 					hadUtf8DecodeErrors ? "[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]" : undefined,
 					reclaimNotice,
-				].filter((part): part is string => part !== undefined).join("\n\n");
+				].filter((part): part is string => part !== undefined);
+				const previewText = [preview.text, ...notices].join("\n\n");
+				const servedRawText = preview.anchoredLines.map((row) => fileLines[row.line - 1] ?? "").join("\n");
+				const rawTruncation = servedRawText.length > 0 ? truncateHead(servedRawText, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES }) : undefined;
 
 				const structuredContent: ReadResult = {
 					ok: true,
 					kind: "read",
 					path: rawPath,
-					text: previewText,
+					text: rawTruncation?.content ?? "",
 					lines: preview.anchoredLines,
 					totalLines: preview.totalLines,
 					startLine: preview.startLine,
 					nextOffset: preview.nextOffset ?? null,
-					truncated: preview.truncation !== undefined,
+					truncated: preview.truncation !== undefined || rawTruncation?.truncated === true,
 					blockedByLongLine: preview.blockedByLongLine,
 					hadUtf8DecodeErrors,
+					notices,
 				};
 				return {
 					content: [{ type: "text", text: previewText }],

package/src/structured.ts

@@ -45,16 +45,17 @@ export type ReadTextResult = {
 	truncated: boolean;
 	blockedByLongLine: boolean;
 	hadUtf8DecodeErrors: boolean;
+	notices: string[];
 };
 
 export type ReadImageResult = {
-	ok: true;
-	kind: "image";
-	path: string;
+	type: "image";
+	data: string;
 	mimeType: string;
+	note: string;
 };
 
-export type ReadResult = ReadTextResult | ReadImageResult | StructuredError;
+export type ReadResult = ReadTextResult | ReadImageResult | string | StructuredError;
 
 export const readResultSchema = Type.Union([
 	Type.Object({
@@ -69,13 +70,15 @@ export const readResultSchema = Type.Union([
 		truncated: Type.Boolean(),
 		blockedByLongLine: Type.Boolean(),
 		hadUtf8DecodeErrors: Type.Boolean(),
+		notices: Type.Array(Type.String()),
 	}),
 	Type.Object({
-		ok: Type.Literal(true),
-		kind: Type.Literal("image"),
-		path: Type.String(),
+		type: Type.Literal("image"),
+		data: Type.String(),
 		mimeType: Type.String(),
+		note: Type.String(),
 	}),
+	Type.String(),
 	structuredErrorSchema,
 ]);
 

package/src/write-hook.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { HASH_CLASS } from "./hashline/alphabet";
 import { HASH_SEP } from "./hashline/hash";
-import { servedForPath, withAnchorSession } from "./anchor-registry";
+import { sessionContextReadable, servedForPath, withAnchorSession, type AnchorSessionContext } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec } from "./utils";
 import type { ModelLike } from "./model-gate";
@@ -31,8 +31,12 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} contains the copied ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
 }
 
+function withReadableSession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T | undefined> {
+  return sessionContextReadable(ctx) ? withAnchorSession(ctx, fn) : Promise.resolve(undefined);
+}
+
 export function registerWriteHook(pi: ExtensionAPI, isModelDisabled?: (model: ModelLike | undefined) => boolean): void {
-  pi.on("tool_call", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("tool_call", async (event, ctx) => withReadableSession(ctx, async () => {
     if (event.toolName !== "write") return;
     if (isModelDisabled?.(ctx.model)) return;
     const input = event.input as Record<string, unknown> | undefined;