dsh-hashline-edit 0.2.2 → 0.2.3

package/src/cut-repair.ts

@@ -1,5 +1,6 @@
 import { restoreEndings, type LineEnding } from "./edit-diff.js";
 import { readBytes, writeAtomic } from "./fs-write.js";
+import { pathKind, removeFile, renameFile } from "./fs-lifecycle.js";
 import { withSortedMutationQueues } from "./mutation-queue.js";
 import { errCode } from "./utils.js";
 import { loadHashStore, type HashStore } from "./hash-store.js";
@@ -73,20 +74,87 @@ function candidateFor(row: MemberRow, which: "pre" | "post"): Buffer | undefined
 }
 
 async function stateOf(row: MemberRow): Promise<MemberState> {
-  let bytes: Buffer;
-  try {
-    bytes = await readBytes(row.path);
-  } catch (error) {
-    if (errCode(error) === "ENOENT") return "other";
-    throw error;
-  }
+  const lifecycle = row.lifecycle ?? "edit";
   const post = candidateFor(row, "post");
-  if (post !== undefined && bytes.equals(post)) return "post";
   const pre = candidateFor(row, "pre");
+  const readOrUndefined = async (path: string | null | undefined): Promise<Buffer | undefined> => {
+    if (path === null || path === undefined) return undefined;
+    try {
+      return await readBytes(path);
+    } catch (error) {
+      if (errCode(error) === "ENOENT") return undefined;
+      throw error;
+    }
+  };
+  if (lifecycle === "add") {
+    const bytes = await readOrUndefined(row.path);
+    if (bytes === undefined) return "pre";
+    return post !== undefined && bytes.equals(post) ? "post" : "other";
+  }
+  if (lifecycle === "delete") {
+    const bytes = await readOrUndefined(row.path);
+    if (bytes === undefined) return "post";
+    return pre !== undefined && bytes.equals(pre) ? "pre" : "other";
+  }
+  if (lifecycle === "move") {
+    const to = await readOrUndefined(row.path);
+    const from = await readOrUndefined(row.fromPath);
+    if (to !== undefined && post !== undefined && to.equals(post)) return "post";
+    if (from !== undefined && pre !== undefined && from.equals(pre)) return "pre";
+    // WHY: crash after the rename but before the content rewrite — the destination holds the raw
+    // WHY: pre bytes and the source is gone. That is the PRE state of an as-yet-unapplied move.
+    if (to !== undefined && pre !== undefined && to.equals(pre) && from === undefined) return "pre";
+    return "other";
+  }
+  const bytes = await readOrUndefined(row.path);
+  if (bytes === undefined) return "other";
+  if (post !== undefined && bytes.equals(post)) return "post";
   if (pre !== undefined && bytes.equals(pre)) return "pre";
   return "other";
 }
 
+/** Write one lifecycle row to its named state; returns false when the row cannot express it. */
+async function writeState(row: MemberRow, which: "pre" | "post"): Promise<boolean> {
+  const lifecycle = row.lifecycle ?? "edit";
+  const bytes = candidateFor(row, which);
+  if (lifecycle === "add") {
+    if (which === "post") {
+      if (bytes === undefined) return false;
+      await writeAtomic(row.path, bytes);
+      return true;
+    }
+    if ((await pathKind(row.path)) !== "absent") await removeFile(row.path);
+    return true;
+  }
+  if (lifecycle === "delete") {
+    if (which === "post") {
+      if ((await pathKind(row.path)) !== "absent") await removeFile(row.path);
+      return true;
+    }
+    if (bytes === undefined) return false;
+    await writeAtomic(row.path, bytes);
+    return true;
+  }
+  if (lifecycle === "move") {
+    const source = row.fromPath;
+    if (source === null || source === undefined) return false;
+    if (which === "post") {
+      if ((await pathKind(row.path)) === "absent") {
+        if ((await pathKind(source)) === "absent") return false;
+        await renameFile(source, row.path);
+      }
+      if (bytes !== undefined) await writeAtomic(row.path, bytes);
+      return true;
+    }
+    if ((await pathKind(row.path)) !== "absent") await renameFile(row.path, source);
+    if (bytes !== undefined) await writeAtomic(source, bytes);
+    return true;
+  }
+  if (bytes === undefined) return false;
+  await writeAtomic(row.path, bytes);
+  return true;
+}
+
 /** Returns true when the resolution completed (bytes written or nothing to write) and the intent retired. */
 async function applyResolution(
   store: HashStore,
@@ -106,9 +174,7 @@ async function applyResolution(
         if (now !== expected) return false;
       }
       for (const row of toWrite) {
-        const bytes = candidateFor(row, which);
-        if (bytes === undefined) return false;
-        await writeAtomic(row.path, bytes);
+        if (!(await writeState(row, which))) return false;
       }
       deleteCutIntent(store, txnId);
       return true;

package/src/domain-errors.ts

@@ -54,19 +54,27 @@ export type DomainErrorCode =
   | "E_UNDO_REVERT_FAILED"
   | "E_UNKNOWN"
   | "E_LARGE_FILE"
-  | "E_INTERNAL_INVARIANT";
+  | "E_INTERNAL_INVARIANT"
+  // WHY: apply_patch's two genuinely new codes (E_STALE_ANCHOR already exists above).
+  | "E_PATCH_SYNTAX"
+  | "E_UNIQUE_MATCH";
 
 /**
  * The registered tool whose call produced an `E_BAD_PAYLOAD`. WHY the registered name: the model
  * reads the tool list, so `undo_last_edit` names the call it must repair and a short form would
  * name nothing. A tool belongs here only after a live path is measured, never by assumption.
  */
-export type PayloadSubject = "read" | "edit" | "undo_last_edit";
+export type PayloadSubject = "read" | "edit" | "apply_patch" | "undo_last_edit";
 
 // WHY: this is the runtime companion of the `PayloadSubject` union, like `isDomainErrorCode`.
 // WHY: Only a member may name a tool.
 // WHY: A non-member renders the neutral wording instead.
-const PAYLOAD_SUBJECTS: readonly PayloadSubject[] = ["read", "edit", "undo_last_edit"];
+const PAYLOAD_SUBJECTS: readonly PayloadSubject[] = [
+  "read",
+  "edit",
+  "apply_patch",
+  "undo_last_edit",
+];
 
 export function isPayloadSubject(value: unknown): value is PayloadSubject {
   return typeof value === "string" && (PAYLOAD_SUBJECTS as readonly string[]).includes(value);
@@ -252,6 +260,20 @@ export interface ErrorPayloadMap {
      */
     subject?: PayloadSubject;
   };
+  E_PATCH_SYNTAX: {
+    message: string;
+    path?: string;
+    patchLine?: number;
+    servedRows?: ServedRow[];
+    servedBlock?: string;
+  };
+  E_UNIQUE_MATCH: {
+    message: string;
+    path?: string;
+    patchLine?: number;
+    servedRows?: ServedRow[];
+    servedBlock?: string;
+  };
 }
 
 export interface CodeSpec<P> {
@@ -578,6 +600,16 @@ export const ERROR_REGISTRY: { [K in DomainErrorCode]: CodeSpec<ErrorPayloadMap[
     // WHY: no options — read needs `mode: "verbatim"` and edit needs a split, but the payload
     // WHY: names neither tool. Add `subject` before serving advice (ADR-0047).
   },
+  E_PATCH_SYNTAX: {
+    audience: "MODEL",
+    // WHY: the parser already rendered every problem with its patch line; the envelope carries
+    // WHY: that aggregate so one resubmission can fix every syntax problem.
+    format: ({ message }) => message,
+  },
+  E_UNIQUE_MATCH: {
+    audience: "MODEL",
+    format: ({ message }) => message,
+  },
 };
 
 export interface WarningPayloadMap {

package/src/edit-undo.ts

@@ -1,6 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue as piFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { withFileMutationQueue as piFileMutationQueue } from "./host-utils.js";
 import {
   readUndo,
   writeUndo,
@@ -21,13 +19,14 @@ 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";
 
 /**
@@ -68,6 +67,16 @@ 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(
@@ -89,6 +98,11 @@ 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,
@@ -121,7 +135,7 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       await removeUndo(path);
       return undefined;
     }
-    return {
+    const entry: UndoEntry = {
       content: record.content,
       bom: record.bom,
       originalEnding,
@@ -131,6 +145,15 @@ 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);
@@ -162,6 +185,16 @@ 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 {
@@ -178,6 +211,11 @@ 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 ?? [],
   };
 }
 
@@ -236,6 +274,18 @@ 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 } },
@@ -563,6 +613,330 @@ 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.
@@ -884,23 +1258,3 @@ 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/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 "@earendil-works/pi-coding-agent";
+import type { TruncationResult } from "../host-utils.js";
 
 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 "@earendil-works/pi-coding-agent";
+} from "../host-utils.js";
 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 "@earendil-works/pi-coding-agent";
+import { formatSize } from "../host-utils.js";
 
 /** The lines a page rendered, 1-based and inclusive. */
 interface RenderedRange {