pi-hashline-edit-pro 6.4.6 → 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.
 
@@ -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,10 +29,12 @@ import {
   toggleRequirePath,
   toggleStrictInput,
   adjustDiffContextLines,
+  adjustUndoRetentionDays,
+  getUndoRetentionDays,
   setAutoReadAllIgnoreFromText,
   setDisableOnModelsFromText,
 } from "./src/config";
-import { loadHashStore, pruneMissing } from "./src/hash-store";
+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";
@@ -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);
@@ -184,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);
@@ -252,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;
@@ -288,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.6",
+  "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/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

@@ -943,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,
 ]);