dsh-hashline-edit 0.2.1 → 0.2.2

package/src/edit-undo.ts

@@ -1,4 +1,6 @@
-import { withFileMutationQueue as piFileMutationQueue } from "./host-utils.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { withFileMutationQueue as piFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
 import {
   readUndo,
   writeUndo,
@@ -19,14 +21,13 @@ import {
 import { loadHashStore } from "./hash-store.js";
 import { sessionKeyFor } from "./served-session/session.js";
 import { readBytes, resolveTarget, writeAtomic } from "./fs-write.js";
-import { pruneEmptyDirs, removeFile, renameFile } from "./fs-lifecycle.js";
 import { toCwd } from "./paths.js";
 import { DEFERRED_STORE_SYNC_WARNING } from "./constants.js";
 import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./edit-diff.js";
 import { visLines, splitLines, errCode } from "./utils.js";
+import { loadP, loadGuide } from "./prompts.js";
 import { buildMetrics, type EditDetails } from "./edit-response.js";
 import { DomainError, withPayloadSubject } from "./domain-errors.js";
-import type { UndoLifecycle } from "./undo-store.js";
 import { ANCHOR_GENERATION, lineHashes } from "./hashline/hash-identity.js";
 
 /**
@@ -67,16 +68,6 @@ export interface UndoEntry {
   rawPre?: string | null;
   /** The anchor generation the stored hashes were derived under (0 = pre-generation). */
   anchorGeneration?: number | null;
-  /** The lifecycle action this entry reverses; absent/null is an ordinary edit. */
-  lifecycle?: UndoLifecycle | null;
-  /** Move: the absolute pre-transaction path. */
-  fromPath?: string | null;
-  /** Move: the absolute committed path. */
-  toPath?: string | null;
-  /** The raw post-transaction text when the commit wrote non-canonical bytes (pure move). */
-  rawPost?: string | null;
-  /** Add: directories the add created, outermost first. */
-  createdDirs?: readonly string[] | null;
 }
 
 export async function saveUndo(
@@ -98,11 +89,6 @@ export async function saveUndo(
       snapshotHash: entry.snapshotHash ?? snapshotHashFor(entry.content),
       transactionId: entry.transactionId ?? null,
       rawPre: entry.rawPre ?? null,
-      lifecycle: entry.lifecycle ?? null,
-      fromPath: entry.fromPath ?? null,
-      toPath: entry.toPath ?? null,
-      rawPost: entry.rawPost ?? null,
-      createdDirs: entry.createdDirs ?? null,
       // WHY: ADR-0031 §4 — forward the payload generation so the store stamp (upsertUndo)
       // WHY: can preserve it on replay; absent (ordinary edit) defaults to ANCHOR_GENERATION there.
       anchorGeneration: entry.anchorGeneration ?? ANCHOR_GENERATION,
@@ -135,7 +121,7 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       await removeUndo(path);
       return undefined;
     }
-    const entry: UndoEntry = {
+    return {
       content: record.content,
       bom: record.bom,
       originalEnding,
@@ -145,15 +131,6 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       transactionId: record.transactionId ?? null,
       anchorGeneration: record.anchorGeneration ?? 0,
     };
-    if (record.lifecycle !== null && record.lifecycle !== undefined)
-      entry.lifecycle = record.lifecycle;
-    if (record.fromPath !== null && record.fromPath !== undefined) entry.fromPath = record.fromPath;
-    if (record.toPath !== null && record.toPath !== undefined) entry.toPath = record.toPath;
-    if (record.rawPost !== null && record.rawPost !== undefined) entry.rawPost = record.rawPost;
-    if (record.createdDirs !== null && record.createdDirs !== undefined) {
-      entry.createdDirs = record.createdDirs;
-    }
-    return entry;
   } catch (error) {
     // SAFETY: best-effort undo load — failures return undefined (no history) and caller reports "No undo history"; stale or corrupt store is recoverable on next edit, not silent undefined without log.
     reportDiagnostic("edit-undo", "Failed to load undo entry:", error);
@@ -185,16 +162,6 @@ interface UndoMember {
   rawPre: string | null;
   /** The anchor generation the stored hashes were derived under (0 = pre-generation). */
   anchorGeneration: number;
-  /** Lifecycle action this row reverses; `edit` is the back-compatible default. */
-  lifecycle: UndoLifecycle;
-  /** Move: absolute pre-transaction path. */
-  fromPath: string | null;
-  /** Move: absolute committed path. */
-  toPath: string | null;
-  /** The raw post bytes when the commit wrote a non-canonical image (pure move). */
-  rawPost: string | null;
-  /** Add: the directories the add created, outermost first. */
-  createdDirs: readonly string[];
 }
 
 function toMember(row: UndoRecord & { path: string }, displayPath: string): UndoMember | undefined {
@@ -211,11 +178,6 @@ function toMember(row: UndoRecord & { path: string }, displayPath: string): Undo
     snapshotHash: row.snapshotHash ?? null,
     rawPre: row.rawPre ?? null,
     anchorGeneration: row.anchorGeneration ?? 0,
-    lifecycle: (row.lifecycle as UndoLifecycle | null) ?? "edit",
-    fromPath: row.fromPath ?? null,
-    toPath: row.toPath ?? null,
-    rawPost: row.rawPost ?? null,
-    createdDirs: row.createdDirs ?? [],
   };
 }
 
@@ -274,18 +236,6 @@ async function undoCorrelatedTransaction(
     };
   }
 
-  // WHY: a row whose lifecycle is anything but `edit` reverses a namespace action (add/delete/
-  // WHY: move). Those need path-level restore steps, not `writeAtomic(pre)`; one lifecycle-aware
-  // WHY: executor handles every member of the batch (including the edit members beside them).
-  if (members.some((m) => m.lifecycle !== "edit")) {
-    return await undoLifecycleTransaction(
-      txnId,
-      requestedAbsolutePath,
-      requestedDisplayPath,
-      members,
-      ctx,
-    );
-  }
   const sessionKeyForUndo = sessionKeyFor(
     // SAFETY: ctx is untyped at the pi boundary — cast validated by pi's runtime shape
     ctx as unknown as { sessionManager?: { getSessionId(): string } },
@@ -613,330 +563,6 @@ async function undoCorrelatedTransaction(
   );
 }
 
-/**
- * Undo ONE correlated transaction that contains lifecycle members (apply_patch's Add/Delete/Move
- * batch, possibly beside ordinary text edits). Same durable recipe as `undoCorrelatedTransaction`:
- * validate every member by BYTES first, land the revert intent before the first write, complete a
- * partially failed revert inline, fail closed with `E_UNDO_REVERT_FAILED` only when completion is
- * itself defeated. The namespace steps are the only addition: an add undo removes the created
- * file (and the empty directories it made), a delete undo re-creates it from the raw pre-image,
- * and a move undo renames back before restoring the pre bytes.
- */
-async function undoLifecycleTransaction(
-  txnId: string,
-  requestedAbsolutePath: string,
-  requestedDisplayPath: string,
-  members: UndoMember[],
-  ctx: unknown,
-): Promise<UndoLastEditResult> {
-  const sessionKeyForUndo = sessionKeyFor(
-    // SAFETY: ctx is untyped at the pi boundary — cast validated by pi's runtime shape
-    ctx as unknown as { sessionManager?: { getSessionId(): string } },
-  );
-  const names = members.map((member) => member.displayPath).join(", ");
-  const fileExists = async (path: string): Promise<boolean> => {
-    try {
-      await readBytes(path);
-      return true;
-    } catch (error) {
-      if (errCode(error) === "ENOENT") return false;
-      throw error;
-    }
-  };
-  const stale = (member: UndoMember, reason: "deleted" | "modified"): UndoLastEditResult => ({
-    content: [
-      {
-        type: "text" as const,
-        text: new DomainError("E_UNDO_STALE", { path: member.displayPath, reason }).message,
-      },
-    ],
-    isError: true,
-    details: {},
-  });
-
-  return withSortedMutationQueues(
-    members.map((member) => member.absolutePath),
-    async () => {
-      // WHY: STEP 1 — validate EVERY member before reverting ANY. A delete row's post state
-      // WHY: is "absent"; every other row's post state is its bytes. A move's pre path must not exist.
-      for (const member of members) {
-        const committedPath =
-          member.lifecycle === "move"
-            ? (member.toPath ?? member.absolutePath)
-            : member.absolutePath;
-        if (member.lifecycle === "delete") {
-          if (await fileExists(committedPath)) return stale(member, "modified");
-          continue;
-        }
-        let bytes: Buffer;
-        try {
-          bytes = await readBytes(committedPath);
-        } catch (error) {
-          if (errCode(error) === "ENOENT") return stale(member, "deleted");
-          throw error;
-        }
-        const expectedPost =
-          member.rawPost !== null
-            ? Buffer.from(member.rawPost, "utf-8")
-            : Buffer.from(
-                member.bom + restoreEndings(member.resultContent, member.ending),
-                "utf-8",
-              );
-        if (!bytes.equals(expectedPost)) return stale(member, "modified");
-        if (member.lifecycle === "move" && member.fromPath !== null) {
-          if (await fileExists(member.fromPath)) return stale(member, "modified");
-        }
-      }
-
-      // WHY: STEP 2 — prepare every restore IN MEMORY (no write side touched yet).
-      interface RestorePlan {
-        member: UndoMember;
-        restorePath: string;
-        restoreBytes: Buffer | null;
-        removeOnly: boolean;
-        moveFrom: string | null;
-        moveTo: string | null;
-        dirs: readonly string[];
-        content: string;
-        currentNormalized: string;
-        diff: string;
-        servedRows: ServedRow[];
-        restoredContentHash: string;
-        restoredLineCount: number;
-        restoredHashes: string[];
-        displacedAnchors: string[];
-      }
-      const plans: RestorePlan[] = [];
-      for (const member of members) {
-        const isDelete = member.lifecycle === "delete";
-        const isAdd = member.lifecycle === "add";
-        const isMove = member.lifecycle === "move";
-        const committedPath = isMove ? (member.toPath ?? member.absolutePath) : member.absolutePath;
-        const restorePath = isMove ? (member.fromPath ?? member.absolutePath) : member.absolutePath;
-        const currentNormalized = isDelete ? "" : member.resultContent;
-        const content = isDelete || isMove || !isAdd ? member.content : "";
-        const storedIsCurrentGeneration = member.anchorGeneration === ANCHOR_GENERATION;
-        const restoredContentHash =
-          storedIsCurrentGeneration && member.lifecycle !== "add"
-            ? (member.snapshotHash ?? snapshotHashFor(content))
-            : snapshotHashFor(content);
-        const restoredLineCount = visLines(content).length;
-        let restoredHashes: string[] = [];
-        if (!isAdd) {
-          try {
-            restoredHashes = await restoreHashes(content, restorePath);
-          } catch (error) {
-            reportDiagnostic("edit-undo", "Failed to derive lifecycle restore anchors:", error);
-            restoredHashes = [];
-          }
-        }
-        const currentHashes = isAdd
-          ? await restoreHashes(member.resultContent, committedPath)
-          : isDelete
-            ? []
-            : await restoreHashes(member.resultContent, restorePath);
-        const undoDenseRows = denseServeRows(restoredHashes);
-        const curSet = new Set(currentHashes);
-        const restoredSet = new Set(restoredHashes);
-        const displacedAnchors = [...curSet].filter((hash) => !restoredSet.has(hash));
-        const undoDiff = isAdd
-          ? genDiff(currentNormalized, "", 1, [], currentHashes).diff
-          : isDelete
-            ? genDiff("", content, 1, restoredHashes, []).diff
-            : genDiff(currentNormalized, content, 1, restoredHashes, currentHashes).diff;
-        const restoreBytes = isAdd
-          ? null
-          : member.rawPre !== null
-            ? Buffer.from(member.rawPre, "utf-8")
-            : Buffer.from(member.bom + restoreEndings(content, member.ending), "utf-8");
-        plans.push({
-          member,
-          restorePath,
-          restoreBytes,
-          removeOnly: isAdd,
-          moveFrom: isMove ? restorePath : null,
-          moveTo: isMove ? committedPath : null,
-          dirs: member.createdDirs,
-          content,
-          currentNormalized,
-          diff: undoDiff,
-          servedRows: undoDenseRows,
-          restoredContentHash,
-          restoredLineCount,
-          restoredHashes,
-          displacedAnchors,
-        });
-      }
-
-      // WHY: STEP 3 — durable revert intent BEFORE the first write.
-      await saveCutIntent(txnId, requestedAbsolutePath, "revert");
-      const undoCtx = ctx as { onBeforeUndoWrites?: () => void | Promise<void> };
-      if (undoCtx?.onBeforeUndoWrites) await undoCtx.onBeforeUndoWrites();
-
-      // WHY: STEP 4 — apply the restore steps; a failed step first COMPLETES the remaining members.
-      const applyRestore = async (plan: RestorePlan): Promise<void> => {
-        if (plan.removeOnly) {
-          if (await fileExists(plan.restorePath)) await removeFile(plan.restorePath);
-          await pruneEmptyDirs(plan.dirs);
-          return;
-        }
-        if (plan.moveFrom !== null && plan.moveTo !== null) {
-          if (await fileExists(plan.moveTo)) await renameFile(plan.moveTo, plan.moveFrom);
-        }
-        if (plan.restoreBytes !== null) await writeAtomic(plan.restorePath, plan.restoreBytes);
-      };
-      const reverted = new Set<string>();
-      let defeated: UndoMember | undefined;
-      for (const plan of plans) {
-        try {
-          await applyRestore(plan);
-          reverted.add(plan.member.absolutePath);
-        } catch (error) {
-          reportDiagnostic(
-            "edit-undo",
-            "Lifecycle undo write failed; completing the revert:",
-            error,
-          );
-          for (const rest of plans) {
-            if (reverted.has(rest.member.absolutePath)) continue;
-            try {
-              await applyRestore(rest);
-              reverted.add(rest.member.absolutePath);
-            } catch (completionError) {
-              reportDiagnostic(
-                "edit-undo",
-                "Failed to complete the interrupted lifecycle revert:",
-                completionError,
-              );
-              defeated ??= rest.member;
-            }
-          }
-          break;
-        }
-      }
-      if (defeated !== undefined) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: new DomainError("E_UNDO_REVERT_FAILED", { path: defeated.displayPath }).message,
-            },
-          ],
-          isError: true,
-          details: {},
-        };
-      }
-
-      // WHY: STEP 5 — store commit for every restored file (a removed add owns no snapshot).
-      const deferredSyncWarnings: string[] = [];
-      const servedRowsAll: ServedRow[] = [];
-      const sections: { plan: RestorePlan }[] = [];
-      for (const plan of plans) {
-        if (plan.removeOnly) {
-          sections.push({ plan });
-          continue;
-        }
-        try {
-          await adoptPinnedSnapshotFor(
-            {
-              path: plan.restorePath,
-              snapshotHash: plan.restoredContentHash,
-              lineCount: plan.restoredLineCount,
-              hashes: plan.restoredHashes,
-              content: plan.content,
-            },
-            {
-              retireLeases: true,
-              leases: { sessionKey: sessionKeyForUndo, rows: plan.servedRows },
-              servedMirror: {
-                sessionKey: sessionKeyForUndo,
-                rows: plan.servedRows,
-                shape: { lineCount: plan.restoredLineCount, clearFrom: 0 },
-                retireAnchors: plan.displacedAnchors,
-              },
-            },
-          );
-        } catch (error) {
-          reportDiagnostic("edit-undo", "Failed to commit the lifecycle undo restore:", error);
-          deferredSyncWarnings.push(DEFERRED_STORE_SYNC_WARNING);
-        }
-        servedRowsAll.push(...plan.servedRows);
-        sections.push({ plan });
-      }
-
-      await clearUndoTransaction(txnId);
-      try {
-        await dropCutIntent(txnId);
-      } catch (error) {
-        reportDiagnostic("edit-undo", "Failed to clear the revert intent after commit:", error);
-      }
-
-      const parts: string[] = ["Undone last edit on " + names + "."];
-      for (const { plan } of sections) {
-        switch (plan.member.lifecycle) {
-          case "add":
-            parts.push("Removed the created file " + plan.member.displayPath + ".");
-            break;
-          case "delete":
-            parts.push("Restored the deleted file " + plan.member.displayPath + ".");
-            break;
-          case "move":
-            parts.push(
-              "Moved " +
-                (plan.member.toPath ?? plan.member.absolutePath) +
-                " back to " +
-                plan.restorePath +
-                ".",
-            );
-            break;
-          default:
-            break;
-        }
-      }
-      parts.push(
-        deferredSyncWarnings.length > 0
-          ? "Files reverted; store synchronization is deferred (see the warning below)."
-          : "Files reverted; diff rows carry fresh anchors for follow-up edits.",
-      );
-      parts.push(...deferredSyncWarnings);
-
-      const totalAdded = plans.reduce(
-        (total, plan) =>
-          total +
-          Math.max(0, visLines(plan.content).length - visLines(plan.currentNormalized).length),
-        0,
-      );
-      const totalRemoved = plans.reduce(
-        (total, plan) =>
-          total +
-          Math.max(0, visLines(plan.currentNormalized).length - visLines(plan.content).length),
-        0,
-      );
-      const details: EditDetails = {
-        diff: sections
-          .map(({ plan }) => "--- " + plan.restorePath + " ---\n" + plan.diff)
-          .join("\n"),
-        resultLineCount: visLines(plans[0]!.content).length,
-        servedRows: servedRowsAll,
-        contentHash: plans[0]!.restoredContentHash,
-        ...(deferredSyncWarnings.length > 0 ? { warnings: deferredSyncWarnings } : {}),
-        metrics: buildMetrics({
-          classification: "applied",
-          editsAttempted: plans.length,
-          noopEditsCount: 0,
-          warningsCount: deferredSyncWarnings.length,
-          addedLines: totalAdded,
-          removedLines: totalRemoved,
-        }),
-      };
-      return {
-        content: [{ type: "text" as const, text: parts.join("\n") }],
-        details,
-      };
-    },
-  );
-}
-
 /**
  * Execution facts one host supplies for the undo use case: the directory relative `path` resolves
  * against, and the session whose served anchors the restore re-leases.
@@ -1258,3 +884,23 @@ export async function executeUndoLastEdit(
     throw withPayloadSubject(error, "undo_last_edit");
   }
 }
+
+export function regEditUndo(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "undo_last_edit",
+    label: "Undo Last Edit",
+    description: loadP("../prompts/undo-last-edit.md"),
+    promptSnippet: loadP("../prompts/undo-last-edit-snippet.md"),
+    promptGuidelines: loadGuide("../prompts/undo-last-edit-guidelines.md"),
+    parameters: Type.Object({
+      path: Type.String({
+        description: "Path to the file to undo",
+      }),
+    }),
+
+    // WHY: the registration owns only the pi wire shape; the use case lives in the host-agnostic seam.
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      return executeUndoLastEdit(params, ctx as unknown as UndoLastEditContext);
+    },
+  });
+}

package/src/edit.ts

@@ -0,0 +1,136 @@
+/** SAFETY: Edit tool — thin adapter over deep EditTool + TuiPresenter.
+ *
+ * Clean Architecture: this module is the Interface Adapter seam.
+ * It owns the pi ToolDefinition wiring only; Use Case lives in EditTool,
+ * Framework (pi TUI) lives in TuiPresenter.
+ */
+
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "typebox";
+import {
+  prepareEditArguments,
+  EDIT_DESCRIPTION,
+  type NormalizedEditRequest,
+  type EditItem,
+  editToolSchema,
+  editItemSchema,
+  anchorFromSchema,
+  anchorToSchema,
+  editFileSchema,
+  editModeSchema,
+  assertReq,
+} from "./payload-contract.js";
+import { withPayloadSubject } from "./domain-errors.js";
+import { attributePayloadSubject } from "./error-envelope.js";
+import { createEditTool, type PreviewContext } from "./edit-tool.js";
+import { createTuiPresenter } from "./tui-presenter.js";
+import { loadP, loadGuide } from "./prompts.js";
+import type { EditDetails } from "./edit-response.js";
+import type { RPreview, RRState } from "./edit-render.js";
+
+void EDIT_DESCRIPTION;
+/** SAFETY: @deprecated Import from "./payload-contract.js" — single source per ADR-0007 */
+export { assertReq };
+/** SAFETY: @deprecated Import from "./payload-contract.js" — single source per ADR-0007. Re-exports retained for compatibility until next MAJOR. `replaceWithSchema` is REMOVED: the ticket-04 wire has no `replace_with` fold. */
+export {
+  editToolSchema,
+  editItemSchema,
+  anchorFromSchema,
+  anchorToSchema,
+  editFileSchema,
+  editModeSchema,
+};
+export { reuseText, reuseMarkdown } from "./tui-presenter.js";
+
+/** The wire item (ticket-04): exactly one payload — `text` or `text_ref` — plus optional `at`. */
+export type EditParams = EditItem;
+
+export type EditRequest = NormalizedEditRequest;
+
+export async function compPreview(
+  request: unknown,
+  cwd: string,
+  ctx: PreviewContext,
+): Promise<RPreview> {
+  const tool = createEditTool();
+  return tool.preview(request, cwd, ctx);
+}
+
+type ToolDef = ToolDefinition<TSchema, EditDetails, RRState> & {
+  renderShell?: "default" | "self";
+};
+
+export function buildToolDef(
+  getSessionManager?: () => { getSessionId(): string } | undefined,
+): ToolDef {
+  const E_DESC = loadP("../prompts/edit.md");
+  const E_SNIPPET = loadP("../prompts/edit-snippet.md");
+  const E_GUIDE = loadGuide("../prompts/edit-guidelines.md");
+  const parameters = editToolSchema;
+  const tool = createEditTool();
+  const presenter = createTuiPresenter(
+    // SAFETY: fire-time read is paired with the arm-time getSessionId below; DebouncedPreview
+    // SAFETY: drops the compute if the serving session changed between arming and firing.
+    (req, cwd) => {
+      // SAFETY: the fire-time read stays inside the call so the ctx names the session serving anchors now.
+      const sessionManager = getSessionManager?.();
+      return tool.preview(req, cwd, sessionManager === undefined ? {} : { sessionManager });
+    },
+    () => getSessionManager?.()?.getSessionId(),
+  );
+  return {
+    name: "edit",
+    label: "Edit",
+    description: E_DESC,
+    parameters,
+    promptSnippet: E_SNIPPET,
+    promptGuidelines: E_GUIDE,
+    // WHY: an admission refusal raised here carries no subject, so it must name the edit tool.
+    // WHY: Without the stamp the model reads the neutral wording — the analyzer names no caller.
+    prepareArguments: (args: unknown) => {
+      try {
+        return prepareEditArguments(args);
+      } catch (error) {
+        throw withPayloadSubject(error, "edit");
+      }
+    },
+    renderShell: "default",
+    // SAFETY: presenter owns TUI casts — asToolDef returns ToolDefinition-typed renders, edit.ts has zero direct TUI casts
+    ...presenter.asToolDef(),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      // SAFETY: pi execute boundary is untyped — ctx narrowed via sessionKeyFor, signal is AbortSignal validated by engine
+      try {
+        const res = await tool.execute(
+          params,
+          signal as AbortSignal | undefined,
+          // SAFETY: ctx is untyped at the pi boundary — cast validated by pi's runtime shape
+          ctx as unknown as {
+            cwd: string;
+            sessionManager?: { getSessionId(): string };
+          },
+        );
+        // SAFETY: res is validated tool result after tool.execute — cast to pi ToolDef return type for registration
+        return res as unknown as ReturnType<ToolDef["execute"]> extends Promise<infer R>
+          ? R
+          : never;
+      } catch (error) {
+        throw attributePayloadSubject(error, "edit");
+      }
+    },
+  };
+}
+
+export function regEdit(pi: ExtensionAPI): void {
+  // WHY: (#165) pi's ToolRenderContext carries no session, so the preview pane's session is
+  // WHY: captured from the session_start ctx — the same session reads serve anchors to.
+  // WHY: session_start fires for startup/reload/new/resume/fork, so the capture tracks switches.
+  // WHY: (#168-class) tracking a switch is only safe if the *pending* compute re-checks it:
+  // WHY: buildToolDef below exposes getSessionId so DebouncedPreview binds the serving session
+  // WHY: at arm time and drops (cancels) a compute whose session changed before the timer fires,
+  // WHY: instead of verifying anchors against a session that never served them.
+  let sessionManager: { getSessionId(): string } | undefined;
+  pi.on("session_start", (_event, ctx) => {
+    sessionManager = ctx.sessionManager;
+  });
+  pi.registerTool(buildToolDef(() => sessionManager));
+}

package/src/file-content/index.ts

@@ -32,7 +32,7 @@ import {
 } from "./preview.js";
 import { findStatSnapshotFor } from "../snapshot-store";
 import type { ServedRow } from "../served-session/serve-render.js";
-import type { TruncationResult } from "../host-utils.js";
+import type { TruncationResult } from "@earendil-works/pi-coding-agent";
 
 export type { FileStats, LFile, LoadFileOptions } from "./detection.js";
 export { decodeUtf8Strict, loadFileKindAndText } from "./detection.js";

package/src/file-content/preview.ts

@@ -4,7 +4,7 @@ import {
   DEFAULT_MAX_LINES,
   DEFAULT_MAX_BYTES,
   type TruncationResult,
-} from "../host-utils.js";
+} from "@earendil-works/pi-coding-agent";
 import { MAX_READ_WINDOWS, MAX_READ_WINDOWS_MESSAGE } from "../constants.js";
 import { DomainError } from "../domain-errors.js";
 import {

package/src/file-content/served-header.ts

@@ -5,7 +5,7 @@
  * WHY: one result. Both builders live here, so a header's shape has ONE definition site and the footer
  * WHY: they replaced cannot come back from a call site.
  */
-import { formatSize } from "../host-utils.js";
+import { formatSize } from "@earendil-works/pi-coding-agent";
 
 /** The lines a page rendered, 1-based and inclusive. */
 interface RenderedRange {

package/src/hash-store.ts

@@ -156,16 +156,7 @@ function openDb(storePath: string, budget?: BusyBudget): OpenedDb {
 const MIGRATION_COLUMNS = {
   cut_intent: { direction: "TEXT" },
   file_snapshots: { stat_key: "TEXT" },
-  file_undo: {
-    snapshot_hash: "TEXT",
-    transaction_id: "TEXT",
-    raw_pre: "TEXT",
-    lifecycle: "TEXT",
-    from_path: "TEXT",
-    to_path: "TEXT",
-    raw_post: "TEXT",
-    created_dirs: "TEXT",
-  },
+  file_undo: { snapshot_hash: "TEXT", transaction_id: "TEXT", raw_pre: "TEXT" },
   served: { retired: "TEXT", canons: "TEXT", snapshotId: "TEXT" },
   undo: { result_content: "TEXT NOT NULL DEFAULT ''" },
 } as const;
@@ -634,14 +625,6 @@ export function ensureFileUndoSchema(db: DatabaseSync): void {
   addColumnIfMissing(db, "file_undo", "snapshot_hash");
   addColumnIfMissing(db, "file_undo", "transaction_id");
   addColumnIfMissing(db, "file_undo", "raw_pre");
-  // WHY: apply_patch lifecycle rows are still edit-shaped rows: one file_undo row per member,
-  // WHY: one shared transaction id. These columns only widen what a row can describe — an
-  // WHY: existing row (all NULL) stays an ordinary edit, so the addition is back-compatible.
-  addColumnIfMissing(db, "file_undo", "lifecycle");
-  addColumnIfMissing(db, "file_undo", "from_path");
-  addColumnIfMissing(db, "file_undo", "to_path");
-  addColumnIfMissing(db, "file_undo", "raw_post");
-  addColumnIfMissing(db, "file_undo", "created_dirs");
   // WHY: versions the persisted anchor set — existing rows keep 0 (never current),
   // WHY: so a pre-bump store is refused, not migrated, on first open after upgrade.
   // WHY: `canon_version` (pre-rename builds) is renamed in place, preserving stamped values.