pi-rewind-hook 1.8.2 → 1.8.4

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.8.4] - 2026-04-25
+
+### Added
+- Added `pi-custom-compaction` compatibility: custom message nodes can now receive exact Rewind checkpoints via the `rewind:checkpoint-entry` extension event.
+
+### Documentation
+- Documented seamless `pi-custom-compaction` compatibility and the `pi install npm:pi-custom-compaction` install command.
+
+## [1.8.3] - 2026-04-16
+
+### Fixed
+- `session_before_tree` now auto-keeps current files during [pi-boomerang](https://github.com/nicobailon/pi-boomerang) collapses instead of prompting with restore options.
+- Headless boomerang-triggered tree collapses now preserve rewind metadata instead of skipping the keep-current-files snapshot path.
+
 ## [1.8.2] - 2026-04-05
 
 ### Changed

package/README.md

@@ -29,6 +29,18 @@ This will:
 4. Remove legacy hooks/explicit rewind extension entries from `settings.json` if present
 5. Clean up old `hooks/rewind` directory (if present)
 
+## Works with pi-custom-compaction
+
+Rewind works seamlessly with [`pi-custom-compaction`](https://github.com/nicobailon/pi-custom-compaction). When `pi-custom-compaction` writes visible background-summary markers, it can ask Rewind to bind an exact file checkpoint to that marker’s own session-tree node. That means `/tree` can offer the normal `Restore files to that point` option directly on the custom compaction marker instead of falling back to a nearby parent node.
+
+Install the companion extension with:
+
+```bash
+pi install npm:pi-custom-compaction
+```
+
+This is optional. Pi’s default compaction and Rewind’s native compaction checkpoints continue to work without `pi-custom-compaction`.
+
 ## Configuration
 
 Optionally add settings to `~/.pi/agent/settings.json`.  For example:

package/index.test.ts

@@ -7,13 +7,15 @@ import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
 import rewindExtension from "./index.ts";
 
 const execFileAsync = promisify(execFile);
 const STORE_REF = "refs/pi-rewind/store";
 
 type RewindEntry = Record<string, unknown>;
-type EventHandler = (event: any, ctx: any) => Promise<any> | any;
+type EventHandler = (event: unknown, ctx: unknown) => Promise<unknown> | unknown;
 
 class SessionManagerStub {
   private readonly header: { type: "session"; version: number; id: string; timestamp: string; cwd: string; parentSession?: string };
@@ -97,11 +99,14 @@ async function runGit(repoRoot: string, args: string[]): Promise<{ stdout: strin
   try {
     const { stdout, stderr } = await execFileAsync("git", args, { cwd: repoRoot });
     return { stdout, stderr, code: 0 };
-  } catch (error: any) {
+  } catch (error: unknown) {
+    const execError = error && typeof error === "object"
+      ? error as Partial<{ stdout: string; stderr: string; message: string; code: number }>
+      : undefined;
     return {
-      stdout: error.stdout ?? "",
-      stderr: error.stderr ?? error.message ?? "",
-      code: error.code ?? 1,
+      stdout: execError?.stdout ?? "",
+      stderr: execError?.stderr ?? execError?.message ?? "",
+      code: execError?.code ?? 1,
     };
   }
 }
@@ -161,7 +166,7 @@ async function createHarness(options: {
   await runGitChecked(repoRoot, ["config", "user.email", "rewind@example.com"]);
 
   const handlers = new Map<string, EventHandler>();
-  const eventHandlers = new Map<string, (data: any) => void>();
+  const eventHandlers = new Map<string, (data: unknown) => void>();
   const execCalls: string[][] = [];
   const notifications: Array<{ message: string; level: string }> = [];
   const statusUpdates: Array<{ key: string; value: string | undefined }> = [];
@@ -200,15 +205,15 @@ async function createHarness(options: {
       handlers.set(eventName, handler);
     },
     events: {
-      on: (eventName: string, handler: (data: any) => void) => {
+      on: (eventName: string, handler: (data: unknown) => void) => {
         eventHandlers.set(eventName, handler);
       },
     },
-  } as any;
+  } satisfies Pick<ExtensionAPI, "exec" | "appendEntry" | "on" | "events">;
 
-  rewindExtension(api);
+  rewindExtension(api as ExtensionAPI);
 
-  function createContext(sessionManager: SessionManagerStub, hasUI = true): any {
+  function createContext(sessionManager: SessionManagerStub, hasUI = true) {
     return {
       cwd: repoRoot,
       hasUI,
@@ -259,7 +264,7 @@ async function createHarness(options: {
         entries: options.entries,
       });
     },
-    async invoke(eventName: string, event: any, sessionManager = activeSession, hasUI = true) {
+    async invoke(eventName: string, event: unknown, sessionManager = activeSession, hasUI = true) {
       const handler = handlers.get(eventName);
       assert.ok(handler, `missing handler for ${eventName}`);
       activeSession = sessionManager;
@@ -433,6 +438,151 @@ test("session_before_tree gracefully cancels when restore fails", async () => {
   }
 });
 
+test("session_before_tree restores directly from a custom message with a checkpoint", async () => {
+  const harness = await createHarness({
+    settings: { rewind: { silentCheckpoints: true } },
+  });
+
+  try {
+    await harness.writeRepoFile("notes.txt", "target state\n");
+    const targetCommit = await harness.captureSnapshot();
+    await harness.writeRepoFile("notes.txt", "current state\n");
+
+    harness.currentSession.replaceEntries([
+      {
+        type: "custom_message",
+        id: "marker-1",
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: "pi-custom-compaction.virtual-summary-marker",
+        content: "Older context was summarized in the background.",
+        display: true,
+      },
+      {
+        type: "custom",
+        id: "rewind-op-1",
+        parentId: "marker-1",
+        timestamp: new Date().toISOString(),
+        customType: "rewind-op",
+        data: { v: 2, snapshots: [targetCommit], bindings: [["marker-1", 0]] },
+      },
+    ]);
+
+    await harness.invoke("session_start", {});
+    harness.enqueueSelection("Restore files to that point");
+
+    const result = await harness.invoke("session_before_tree", { preparation: { targetId: "marker-1" } });
+    assert.equal(result, undefined);
+    assert.equal(harness.readRepoFile("notes.txt"), "target state\n");
+    assert.deepEqual(harness.selectCalls[0]?.options, ["Keep current files", "Restore files to that point", "Cancel navigation"]);
+  } finally {
+    await harness.cleanup();
+  }
+});
+
+test("rewind:checkpoint-entry binds the current tree to a custom message", async () => {
+  const harness = await createHarness({
+    settings: { rewind: { silentCheckpoints: true } },
+  });
+
+  try {
+    await harness.writeRepoFile("notes.txt", "target state\n");
+    harness.currentSession.replaceEntries([
+      {
+        type: "custom_message",
+        id: "marker-1",
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: "pi-custom-compaction.virtual-summary-marker",
+        content: "Older context was summarized in the background.",
+        display: true,
+      },
+    ]);
+
+    await harness.invoke("session_start", {});
+    harness.eventHandlers.get("rewind:checkpoint-entry")?.({ source: "pi-custom-compaction", entryId: "marker-1" });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await harness.writeRepoFile("notes.txt", "current state\n");
+
+    harness.enqueueSelection("Restore files to that point");
+    const result = await harness.invoke("session_before_tree", { preparation: { targetId: "marker-1" } });
+    assert.equal(result, undefined);
+    assert.equal(harness.readRepoFile("notes.txt"), "target state\n");
+  } finally {
+    await harness.cleanup();
+  }
+});
+
+test("session_before_tree auto-keeps current files during boomerang collapse", async () => {
+  const harness = await createHarness({
+    settings: { rewind: { silentCheckpoints: true } },
+  });
+
+  try {
+    await harness.writeRepoFile("notes.txt", "current state\n");
+
+    harness.currentSession.replaceEntries([
+      {
+        type: "message",
+        id: "user-1",
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        message: { role: "user", content: [{ type: "text", text: "Tree target" }] },
+      },
+    ]);
+
+    await harness.invoke("session_start", {});
+    (globalThis as typeof globalThis & { __boomerangCollapseInProgress?: boolean }).__boomerangCollapseInProgress = true;
+
+    const result = await harness.invoke("session_before_tree", { preparation: { targetId: "user-1" } });
+    assert.equal(result, undefined);
+    assert.equal(harness.selectCalls.length, 0);
+
+    await harness.invoke("session_tree", { summaryEntry: { id: "summary-1" } });
+
+    const rewindOps = harness.currentSession.getEntries().filter((entry) => entry.type === "custom" && entry.customType === "rewind-op");
+    assert.equal(rewindOps.length, 1);
+  } finally {
+    delete (globalThis as typeof globalThis & { __boomerangCollapseInProgress?: boolean }).__boomerangCollapseInProgress;
+    await harness.cleanup();
+  }
+});
+
+test("session_before_tree auto-keeps current files during headless boomerang collapse", async () => {
+  const harness = await createHarness({
+    settings: { rewind: { silentCheckpoints: true } },
+  });
+
+  try {
+    await harness.writeRepoFile("notes.txt", "current state\n");
+
+    harness.currentSession.replaceEntries([
+      {
+        type: "message",
+        id: "user-1",
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        message: { role: "user", content: [{ type: "text", text: "Tree target" }] },
+      },
+    ]);
+
+    await harness.invoke("session_start", {});
+    (globalThis as typeof globalThis & { __boomerangCollapseInProgress?: boolean }).__boomerangCollapseInProgress = true;
+
+    const result = await harness.invoke("session_before_tree", { preparation: { targetId: "user-1" } }, harness.currentSession, false);
+    assert.equal(result, undefined);
+    assert.equal(harness.selectCalls.length, 0);
+
+    await harness.invoke("session_tree", { summaryEntry: { id: "summary-1" } }, harness.currentSession, false);
+
+    const rewindOps = harness.currentSession.getEntries().filter((entry) => entry.type === "custom" && entry.customType === "rewind-op");
+    assert.equal(rewindOps.length, 1);
+  } finally {
+    delete (globalThis as typeof globalThis & { __boomerangCollapseInProgress?: boolean }).__boomerangCollapseInProgress;
+    await harness.cleanup();
+  }
+});
+
 test("first mutating turn creates a reachable store ref even when retention is omitted", async () => {
   const harness = await createHarness({
     settings: { rewind: { silentCheckpoints: true } },
@@ -600,4 +750,3 @@ test("retention rewrites the keepalive ref when a live snapshot exists", async (
     await harness.cleanup();
   }
 });
-

package/index.ts

@@ -1,10 +1,3 @@
-/**
- * Rewind Extension - session-ledger based exact file restoration for pi branching
- *
- * Rewind v2 stores exact rewind metadata in hidden session custom entries and keeps
- * snapshot commits reachable through a single repo-local store ref.
- */
-
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { exec as execCb } from "child_process";
 import { existsSync, readFileSync, realpathSync } from "fs";
@@ -18,6 +11,7 @@ const execAsync = promisify(execCb);
 const STORE_REF = "refs/pi-rewind/store";
 const STATUS_KEY = "rewind";
 const FORK_PREFERENCE_SOURCE_ALLOWLIST = new Set(["fork-from-first"]);
+const CHECKPOINT_SOURCE_ALLOWLIST = new Set(["pi-custom-compaction"]);
 const LEGACY_ZERO_SHA = "0000000000000000000000000000000000000000";
 const RETENTION_SWEEP_THRESHOLD = 50;
 const RETENTION_VERSION = 2;
@@ -323,7 +317,7 @@ function isRestorableTreeEntry(entry: SessionLikeEntry | undefined): boolean {
   if (entry.type === "message") {
     return entry.message.role === "user" || entry.message.role === "assistant";
   }
-  return entry.type === "branch_summary" || entry.type === "compaction";
+  return entry.type === "branch_summary" || entry.type === "compaction" || entry.type === "custom_message";
 }
 
 function isAssistantMessageEntry(entry: SessionLikeEntry): entry is SessionLikeMessageEntry {
@@ -783,14 +777,19 @@ export default function rewindExtension(pi: ExtensionAPI) {
       const lines = content.split("\n").filter(Boolean);
 
       for (const line of lines) {
-        let entry: any;
+        let entry: SessionLikeGenericEntry | null = null;
         try {
-          entry = JSON.parse(line);
+          const parsed = JSON.parse(line);
+          if (parsed && typeof parsed === "object") {
+            entry = parsed as SessionLikeGenericEntry;
+          }
         } catch {
           // Ignore malformed JSONL lines; retention discovery is best-effort.
           continue;
         }
 
+        if (!entry) continue;
+
         if (entry?.type === "session") {
           ledger.sessionId = entry.id;
           ledger.cwd = entry.cwd;
@@ -1090,7 +1089,27 @@ export default function rewindExtension(pi: ExtensionAPI) {
     updateStatus(ctx);
   }
 
+  let activeContext: ExtensionContext | undefined;
+
+  async function checkpointEntry(ctx: ExtensionContext, entryId: string) {
+    syncSessionIdentity(ctx);
+    if (!isGitRepo) return;
+    const entry = ctx.sessionManager.getEntry(entryId) as SessionLikeEntry | undefined;
+    if (!isRestorableTreeEntry(entry)) return;
+    if (entryToCommit.has(entryId)) return;
+
+    const currentCommitSha = await ensureSnapshotForCurrentWorktree();
+    appendRewindOp(ctx, {
+      v: RETENTION_VERSION,
+      snapshots: [currentCommitSha],
+      bindings: [[entryId, 0]],
+    });
+    await reconstructState(ctx);
+    updateStatus(ctx);
+  }
+
   async function initializeForSession(ctx: ExtensionContext) {
+    activeContext = ctx;
     resetState();
     syncSessionIdentity(ctx);
 
@@ -1115,14 +1134,28 @@ export default function rewindExtension(pi: ExtensionAPI) {
     });
   }
 
-  pi.events.on("rewind:fork-preference", (data: any) => {
-    if (data?.mode !== "conversation-only") return;
-    if (typeof data?.source !== "string") return;
+  pi.events.on("rewind:fork-preference", (data) => {
+    if (!data || typeof data !== "object") return;
+    if (!("mode" in data) || data.mode !== "conversation-only") return;
+    if (!("source" in data) || typeof data.source !== "string") return;
     if (!FORK_PREFERENCE_SOURCE_ALLOWLIST.has(data.source)) return;
     forceConversationOnlyOnNextFork = true;
     forceConversationOnlySource = data.source;
   });
 
+  pi.events.on("rewind:checkpoint-entry", (data) => {
+    if (!data || typeof data !== "object") return;
+    if (!("source" in data) || typeof data.source !== "string") return;
+    if (!CHECKPOINT_SOURCE_ALLOWLIST.has(data.source)) return;
+    if (!("entryId" in data) || typeof data.entryId !== "string") return;
+    const ctx = activeContext;
+    if (!ctx) return;
+
+    checkpointEntry(ctx, data.entryId).catch((error) => {
+      notify(ctx, `Rewind: failed to checkpoint ${data.entryId} (${error instanceof Error ? error.message : String(error)})`, "warning");
+    });
+  });
+
   pi.on("before_agent_start", async (event) => {
     activePromptText = event.prompt;
   });
@@ -1342,9 +1375,16 @@ export default function rewindExtension(pi: ExtensionAPI) {
   });
 
   pi.on("session_before_tree", async (event, ctx) => {
-    if (!isGitRepo || !ctx.hasUI) return;
+    if (!isGitRepo) return;
 
     try {
+      if ((globalThis as typeof globalThis & { __boomerangCollapseInProgress?: boolean }).__boomerangCollapseInProgress === true) {
+        pendingTreeState = { currentCommitSha: await ensureSnapshotForCurrentWorktree() };
+        return;
+      }
+
+      if (!ctx.hasUI) return;
+
       const targetEntry = ctx.sessionManager.getEntry(event.preparation.targetId) as SessionLikeEntry | undefined;
       const targetCommitSha = isRestorableTreeEntry(targetEntry)
         ? await resolveEntrySnapshotWithLineage(event.preparation.targetId, currentSessionFile)
@@ -1386,7 +1426,7 @@ export default function rewindExtension(pi: ExtensionAPI) {
       }
 
       if (!targetCommitSha) {
-        notify(ctx, "Exact file rewind is only available for user, assistant, compaction, and summary nodes", "error");
+        notify(ctx, "Exact file rewind is only available for user, assistant, custom message, compaction, and summary nodes", "error");
         return { cancel: true };
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-rewind-hook",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Rewind extension for Pi agent - automatic git checkpoints with file/conversation restore",
   "repository": {
     "type": "git",