@selesai/code 0.13.1 → 0.13.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.2] - 2026-08-30
+
+### Added
+- **Rewind submodule support.** `pi-rewind-hook` now snapshots gitlink commits and restores submodule worktrees to their target commits during exact rewind, with safety checks: submodule paths must stay unchanged, worktrees must be clean and initialized, and target commits must be available locally. Unsupported submodule states (dirty, uninitialized, added/removed paths, nested submodules) are refused with a clear error instead of being reported as exact restores.
+- **Rewind retention sweep concurrency safety.** The retention sweep now uses a compare-and-swap on the store ref with retries, so concurrent sessions adding snapshots mid-sweep are preserved instead of being clobbered; the startup sweep is reused across session replacement instead of racing a second sweep.
+
+### Changed
+- **Herdr status bridge drops agent scoping.** `pi-subagents` no longer passes `--agent pi` / `--applies-to-source herdr:pi` to Herdr `report-metadata` calls; state labels are reported under the `pi-subagents:herdr` source directly.
+- **Rewind extension packaging.** `pi-rewind-hook` declares `@selesai/code` as a peer dependency (was devDependency) and bumps to 1.8.6.
+
 ## [0.13.1] - 2026-08-30
 
 ### Fixed

package/dist/extensions/pi-rewind-hook/README.md

@@ -12,7 +12,7 @@ Rewind metadata lives in the session itself as hidden entries, so rewind history
 
 ## Requirements
 
-- Pi agent v0.65.0+
+- Pi agent v0.74.0+
 - Node.js (for installation)
 - Git repository
 
@@ -181,6 +181,8 @@ Rewind restores the exact file state for the snapshot domain it owns:
 
 Before restoring target contents, it deletes paths present in the current snapshot but absent from the target snapshot, then restores the target snapshot into the worktree only.
 
+Submodules are supported only when their paths stay unchanged, their worktrees are clean and initialized, and each target commit is already available locally. Rewind checks out those target commits without fetching. Exact restore is refused with a clear error for dirty or unavailable submodule state, added or removed submodule paths, and nested submodules; uncommitted files inside submodules are not part of snapshots.
+
 Out of scope:
 
 - ignored files
@@ -240,6 +242,7 @@ grep '"customType":"rewind-' ~/.pi/agent/sessions/**/*.jsonl
 ## Limitations
 
 - Only works in git repositories
+- Submodule snapshots contain gitlink commits, not uncommitted nested files; unsupported submodule states are refused instead of reported as exact restores
 - Session metadata grows append-only; retention only trims git reachability
 - Discovery for retention is best-effort across discovered Pi session roots and explicit `parentSession` ancestors
 - Ignored files and empty directories are outside the snapshot model

package/dist/extensions/pi-rewind-hook/index.ts

@@ -17,6 +17,8 @@ const RETENTION_SWEEP_THRESHOLD = 50;
 const RETENTION_VERSION = 2;
 const EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 
+class UnsupportedSubmoduleStateError extends Error {}
+
 type ExecFn = (cmd: string, args: string[]) => Promise<{ stdout: string; stderr: string; code: number }>;
 
 type GitExecResult = Awaited<ReturnType<ExecFn>>;
@@ -70,6 +72,11 @@ interface ExactState {
   treeSha: string;
 }
 
+interface GitlinkEntry {
+  path: string;
+  commitSha: string;
+}
+
 interface ActiveBranchState {
   currentCommitSha?: string;
   currentTreeSha?: string;
@@ -387,7 +394,7 @@ export default function rewindExtension(pi: ExtensionAPI) {
   let pendingTreeState: PendingResultingState | null = null;
   let activePromptText: string | null = null;
   let newSnapshotsSinceSweep = 0;
-  let sweepRunning = false;
+  let retentionSweep: Promise<void> | undefined;
   let sweepCompletedThisSession = false;
   let forceConversationOnlyOnNextFork = false;
   let forceConversationOnlySource: string | null = null;
@@ -461,6 +468,87 @@ export default function rewindExtension(pi: ExtensionAPI) {
     return repoRoot;
   }
 
+  async function getGitlinkEntries(treeSha: string, gitPrefix: string[] = []): Promise<GitlinkEntry[]> {
+    const result = await execGitChecked([...gitPrefix, "ls-tree", "-r", "-z", treeSha, "--"]);
+    return parseGitlinkEntries(result.stdout);
+  }
+
+  function parseGitlinkEntries(output: string): GitlinkEntry[] {
+    return output.split("\0").flatMap((record) => {
+      const separator = record.indexOf("\t");
+      if (separator < 0) return [];
+
+      const [mode, type, commitSha] = record.slice(0, separator).split(/\s+/);
+      if (mode !== "160000" || type !== "commit" || !commitSha) return [];
+      return [{ path: record.slice(separator + 1), commitSha }];
+    });
+  }
+
+  async function getIndexedGitlinkEntries(): Promise<GitlinkEntry[]> {
+    const result = await execGitChecked(["ls-files", "--stage", "-z"]);
+    return parseGitlinkEntries(result.stdout);
+  }
+
+  async function assertSubmoduleWorktreesClean(root: string, entries: GitlinkEntry[], action: string) {
+    for (const entry of entries) {
+      const submodulePath = resolve(root, entry.path);
+      if (!isInsidePath(submodulePath, root)) {
+        throw new UnsupportedSubmoduleStateError(`refusing ${action} for submodule path outside repo root: ${entry.path}`);
+      }
+
+      const status = await pi.exec("git", ["-C", submodulePath, "status", "--porcelain", "--untracked-files=all"]);
+      if (status.code !== 0) {
+        throw new UnsupportedSubmoduleStateError(`cannot ${action} with uninitialized submodule: ${entry.path}`);
+      }
+      if (status.stdout.trim()) {
+        throw new UnsupportedSubmoduleStateError(`cannot ${action} with dirty submodule: ${entry.path}`);
+      }
+    }
+  }
+
+  async function prepareSubmoduleRestore(root: string, currentEntries: GitlinkEntry[], targetEntries: GitlinkEntry[]) {
+    const currentPaths = new Set(currentEntries.map((entry) => entry.path));
+    const targetPaths = new Set(targetEntries.map((entry) => entry.path));
+    const changedPaths = [...new Set([...currentPaths, ...targetPaths])]
+      .filter((entryPath) => !currentPaths.has(entryPath) || !targetPaths.has(entryPath));
+    if (changedPaths.length > 0) {
+      throw new UnsupportedSubmoduleStateError(
+        `exact rewind does not support adding or removing submodules: ${changedPaths.join(", ")}`,
+      );
+    }
+
+    await assertSubmoduleWorktreesClean(root, currentEntries, "restore exact files");
+
+    const commitsToInspect = new Map<string, GitlinkEntry>();
+    for (const entry of [...currentEntries, ...targetEntries]) {
+      commitsToInspect.set(`${entry.path}\0${entry.commitSha}`, entry);
+    }
+
+    for (const entry of commitsToInspect.values()) {
+      const entryPath = entry.path;
+      const commitSha = entry.commitSha;
+      const submodulePath = resolve(root, entryPath);
+      const commit = await pi.exec("git", ["-C", submodulePath, "cat-file", "-e", `${commitSha}^{commit}`]);
+      if (commit.code !== 0) {
+        throw new UnsupportedSubmoduleStateError(
+          `cannot inspect submodule ${entryPath}: commit ${commitSha.slice(0, 12)} is unavailable locally`,
+        );
+      }
+
+      const targetTreeSha = (await execGitChecked(["-C", submodulePath, "show", "-s", "--format=%T", commitSha])).stdout.trim();
+      const nestedEntries = await getGitlinkEntries(targetTreeSha, ["-C", submodulePath]);
+      if (nestedEntries.length > 0) {
+        throw new UnsupportedSubmoduleStateError(`cannot restore nested submodules: ${entryPath}`);
+      }
+    }
+  }
+
+  async function restoreSubmodules(root: string, entries: GitlinkEntry[]) {
+    for (const entry of entries) {
+      await execGitChecked(["-C", resolve(root, entry.path), "checkout", "--detach", entry.commitSha]);
+    }
+  }
+
   async function captureWorktreeTree(): Promise<{ treeSha: string }> {
     const root = await getRepoRoot(pi.exec);
     const tempDir = await mkdtemp(join(tmpdir(), "pi-rewind-"));
@@ -470,7 +558,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
       const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
       await execAsync("git add -A", { cwd: root, env });
       const { stdout } = await execAsync("git write-tree", { cwd: root, env });
-      return { treeSha: stdout.trim() };
+      const treeSha = stdout.trim();
+      const entriesByPath = new Map<string, GitlinkEntry>();
+      for (const entry of await getIndexedGitlinkEntries()) entriesByPath.set(entry.path, entry);
+      for (const entry of await getGitlinkEntries(treeSha)) entriesByPath.set(entry.path, entry);
+      await assertSubmoduleWorktreesClean(root, [...entriesByPath.values()], "capture exact files");
+      return { treeSha };
     } finally {
       await rm(tempDir, { recursive: true, force: true }).catch(() => {
         // Best effort cleanup for temporary index directory.
@@ -542,19 +635,38 @@ export default function rewindExtension(pi: ExtensionAPI) {
       return "preserved-empty";
     }
 
-    let head: string | undefined;
-    for (const commitSha of uniqueLiveCommits) {
-      head = await createStoreKeepaliveCommit(commitSha, head);
-    }
+    let attempts = 0;
+    let lastError: unknown;
+    let preserveConcurrentHead = false;
+
+    while (attempts < 5) {
+      attempts += 1;
+      const oldHead = await getStoreHead();
+      // A failed compare-and-swap means another session added snapshots while
+      // this sweep was running. Preserve that new reachability and let a later
+      // uncontended sweep prune anything no longer retained.
+      let head = preserveConcurrentHead ? oldHead : undefined;
+      for (const commitSha of uniqueLiveCommits) {
+        head = await createStoreKeepaliveCommit(commitSha, head);
+      }
 
-    const oldHead = await getStoreHead();
-    if (oldHead) {
-      await execGitChecked(["update-ref", STORE_REF, head!, oldHead]);
-      return "rewritten";
+      try {
+        if (oldHead) {
+          await execGitChecked(["update-ref", STORE_REF, head!, oldHead]);
+        } else {
+          await execGitChecked(["update-ref", STORE_REF, head!, LEGACY_ZERO_SHA]);
+        }
+        return "rewritten";
+      } catch (error) {
+        // Retry if another process updated the store ref concurrently.
+        // Keep the most recent error for actionable failure context.
+        lastError = error;
+        preserveConcurrentHead = true;
+      }
     }
 
-    await execGitChecked(["update-ref", STORE_REF, head!, LEGACY_ZERO_SHA]);
-    return "rewritten";
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`failed to rewrite rewind store ref: ${detail}`);
   }
 
   async function ensureSnapshotForTree(treeSha: string): Promise<string> {
@@ -606,6 +718,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const { treeSha: currentTreeSha } = await captureWorktreeTree();
     const targetTreeSha = await getCommitTreeSha(targetCommitSha);
 
+    const currentSubmodules = await getGitlinkEntries(currentTreeSha);
+    const targetSubmodules = await getGitlinkEntries(targetTreeSha);
+    if (currentSubmodules.length > 0 || targetSubmodules.length > 0) {
+      await prepareSubmoduleRestore(repoRoot!, currentSubmodules, targetSubmodules);
+    }
+
     if (currentTreeSha === targetTreeSha) {
       lastExact = { commitSha: targetCommitSha, treeSha: targetTreeSha };
       return { changed: false, targetTreeSha };
@@ -615,6 +733,13 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const pathsToDelete = await getDeletedPaths(currentTreeSha, targetTreeSha);
     await deletePathsFromWorkingTree(pathsToDelete);
     await execGitChecked(["restore", `--source=${targetCommitSha}`, "--worktree", "--", "."]);
+    if (targetSubmodules.length > 0) {
+      await restoreSubmodules(repoRoot!, targetSubmodules);
+      const { treeSha: restoredTreeSha } = await captureWorktreeTree();
+      if (restoredTreeSha !== targetTreeSha) {
+        throw new Error(`submodule restore did not produce target tree ${targetTreeSha}`);
+      }
+    }
     lastExact = { commitSha: targetCommitSha, treeSha: targetTreeSha };
     return { changed: true, undoCommitSha, targetTreeSha };
   }
@@ -964,13 +1089,13 @@ export default function rewindExtension(pi: ExtensionAPI) {
     if (reason === "new-snapshots" && newSnapshotsSinceSweep < RETENTION_SWEEP_THRESHOLD) return;
     if (reason === "shutdown" && sweepCompletedThisSession && newSnapshotsSinceSweep < RETENTION_SWEEP_THRESHOLD) return;
     if (!repoRoot) return;
-    if (sweepRunning) return;
-    sweepRunning = true;
-    try {
-      await runRetentionSweep(ctx, reason);
-    } finally {
-      sweepRunning = false;
-    }
+    // Session replacement invalidates ctx after session_shutdown resolves, so reuse
+    // the in-flight startup sweep and let shutdown await it before returning.
+    if (retentionSweep) return retentionSweep;
+    retentionSweep = runRetentionSweep(ctx, reason).finally(() => {
+      retentionSweep = undefined;
+    });
+    return retentionSweep;
   }
 
   async function runRetentionSweep(ctx: ExtensionContext, reason: "startup" | "new-snapshots" | "shutdown") {
@@ -1127,7 +1252,12 @@ export default function rewindExtension(pi: ExtensionAPI) {
     }
 
     await getRepoRoot(pi.exec);
-    await reconstructState(ctx);
+    try {
+      await reconstructState(ctx);
+    } catch (error) {
+      if (!(error instanceof UnsupportedSubmoduleStateError)) throw error;
+      notify(ctx, `Rewind unavailable: ${error.message}`, "warning");
+    }
     updateStatus(ctx);
     maybeSweepRetention(ctx, "startup").catch((error) => {
       notify(ctx, `Rewind retention startup sweep failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -1151,7 +1281,7 @@ export default function rewindExtension(pi: ExtensionAPI) {
     const ctx = activeContext;
     if (!ctx) return;
 
-    checkpointEntry(ctx, data.entryId).catch((error) => {
+    return checkpointEntry(ctx, data.entryId).catch((error) => {
       notify(ctx, `Rewind: failed to checkpoint ${data.entryId} (${error instanceof Error ? error.message : String(error)})`, "warning");
     });
   });

package/dist/extensions/pi-rewind-hook/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-rewind-hook",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Rewind extension for Pi agent - automatic git checkpoints with file/conversation restore",
   "repository": {
     "type": "git",
@@ -18,12 +18,14 @@
   "author": "nicobailon",
   "license": "MIT",
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "scripts": {
     "test": "npx --yes tsx --tsconfig tsconfig.test.json --test index.test.ts"
   },
-  "devDependencies": {
+  "peerDependencies": {
     "@selesai/code": "*"
   }
 }

package/dist/extensions/pi-subagents/src/integrations/herdr-status.ts

@@ -205,8 +205,6 @@ export function registerHerdrStatusBridge(options: HerdrStatusBridgeOptions): He
 			enqueue([
 				"pane", "report-metadata", paneId,
 				"--source", DEFAULT_SOURCE,
-				"--agent", "pi",
-				"--applies-to-source", "herdr:pi",
 				"--clear-state-labels",
 				"--clear-token", "summary",
 				"--clear-token", "title-suffix",
@@ -220,8 +218,6 @@ export function registerHerdrStatusBridge(options: HerdrStatusBridgeOptions): He
 		enqueue([
 			"pane", "report-metadata", paneId,
 			"--source", DEFAULT_SOURCE,
-			"--agent", "pi",
-			"--applies-to-source", "herdr:pi",
 			"--state-label", `idle=${text}`,
 			"--state-label", `done=${text}`,
 			"--state-label", `working=${text}`,

package/dist/extensions/pi-subagents/test/unit/herdr-status-bridge.test.ts

@@ -159,17 +159,15 @@ describe("Herdr status bridge", () => {
 			label: "⏳ 1 subagent (worker)",
 		}]);
 		assert.equal(commands.length, 1);
-		assert.deepEqual(commands[0]?.slice(0, 8), [
+		assert.deepEqual(commands[0]?.slice(0, 4), [
 			"pane",
 			"report-metadata",
 			"w1:p1",
 			"--source",
-			"pi-subagents:herdr",
-			"--agent",
-			"pi",
-			"--applies-to-source",
 		]);
-		assert.ok(commands[0]?.includes("herdr:pi"));
+		assert.ok(commands[0]?.includes("pi-subagents:herdr"));
+		assert.ok(!commands[0]?.includes("--agent"));
+		assert.ok(!commands[0]?.includes("--applies-to-source"));
 		assert.ok(commands[0]?.includes("--state-label"));
 		assert.ok(commands[0]?.includes("working=⏳ 1 subagent (worker)"));
 		assert.ok(commands[0]?.includes("idle=⏳ 1 subagent (worker)"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {

package/dist/extensions/ascii.txt

@@ -1,9 +0,0 @@
- ____    ____    __       ____    ____        ______  ______     
-/\  _`\ /\  _`\ /\ \     /\  _`\ /\  _`\     /\  _  \/\__  _\    
-\ \,\L\_\ \ \L\_\ \ \    \ \ \L\_\ \,\L\_\   \ \ \L\ \/_/\ \/    
- \/_\__ \\ \  _\L\ \ \  __\ \  _\L\/_\__ \    \ \  __ \ \ \ \    
-   /\ \L\ \ \ \L\ \ \ \L\ \\ \ \L\ \/\ \L\ \   \ \ \/\ \ \_\ \__ 
-   \ `\____\ \____/\ \____/ \ \____/\ `\____\   \ \_\ \_\/\_____\
-    \/_____/\/___/  \/___/   \/___/  \/_____/    \/_/\/_/\/_____/
-                                                                 
-