@ferris1225/pi-subagents 4.3.18 → 4.3.19

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 Release notes for `@ferris1225/pi-subagents`. Only the most recent releases
 are kept here; every published version is preserved as a GitHub Release.
 
+## 4.3.19
+
+- Scope session-start thread restore and recovery notices to the current
+  checkout. A second pi window in another project no longer announces the first
+  project's retained worktree, retries its leftover cleanup, or restores and
+  stops its interrupted children.
+- Cover sibling-window isolation with recovery announcement, leftover-cleanup,
+  and parked-thread restore checks across two checkouts that share one agent dir.
+
 ## 4.3.18
 
 - Keep known-context local changes in main and delegate only substantial,

package/README.md

@@ -12,6 +12,10 @@ default and delegates when an independent child has a concrete advantage.
 
 ## What's new
 
+**4.3.19** — session-start restore and recovery notices stay inside the current
+project. A second pi window no longer surfaces another checkout's retained
+worktree or restores (and would otherwise stop) that project's interrupted runs.
+
 **4.3.18** — main-first delegation: keep known-context local changes in main,
 use cleanup and review roles only where they add value, and configure process
 capacity with `maxConcurrentAgents`. See [Evaluate delegation](#evaluate-delegation)
@@ -298,9 +302,10 @@ Third-party Pi packages execute as trusted code and must be reviewed accordingly
   as a lane wait, not as slot queueing, and its process slot is already released.
 - Setup and integration failures keep the useful patch and worktree, and record
   where they are in `~/.pi/agent/ferris-pi-subagents/pi-subagents-recovery.json`.
-  start repeats that notice until you remove the artifacts. When the changes had
-  already been applied and only the cleanup failed, the next session start
-  removes the retained copy itself and clears the notice.
+  Later session starts in that same project repeat the notice until you remove
+  the artifacts. A different project's pi window does not show or retry them.
+  When the changes had already been applied and only the cleanup failed, the next
+  session start in that project removes the retained copy itself and clears the notice.
 
 ## Runs: status and stop
 
@@ -346,9 +351,10 @@ attempt. Worktree integration failures keep their recovery artifacts.
 
 Interrupted work retains a durable record and any session/worktree artifacts for
 manual recovery after reload or crash. Missing session files no longer discard
-isolated edits. Restore runs at session start; lookup tools, prompt injection, and
-fresh dispatch wait for that pass so an existing id cannot be reported missing or
-reused. Missing recorded worktrees surface as failures without discarding the
+isolated edits. Restore for this checkout runs at session start; lookup tools,
+prompt injection, and fresh dispatch wait for that pass so an existing id cannot
+be reported missing or reused. A sibling window in another project leaves those
+records untouched. Missing recorded worktrees surface as failures without discarding the
 remaining recovery evidence.
 
 Canonical managed-path and repository validation remains in place. Invalid records
@@ -612,7 +618,8 @@ Cleanup runs at session start and is deliberately conservative. A directory goes
 away only when the process that created it is gone and no valid manifest record still
 claims it, so a live sibling pi instance never loses state and interrupted or recovery-owned
 work outlives its own process by design. Thread and recovery references always beat an
-age rule.
+age rule. Restore and recovery notices themselves are scoped to the current checkout:
+opening pi in another project does not restore, announce, or stop the first project's runs.
 
 ## Development
 

package/index.ts

@@ -83,8 +83,8 @@ export default function (pi: ExtensionAPI): void {
 		},
 	});
 
-	pi.on("session_start", async () => {
-		await bootstrapDurableState(runtime);
+	pi.on("session_start", async (_event, ctx) => {
+		await bootstrapDurableState(runtime, ctx.cwd);
 	});
 	registerAnnouncements(pi, runtime);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "4.3.18",
+  "version": "4.3.19",
   "description": "A managed sub-agent team for pi: scout, artisan, steward, and sentinel roles, one-shot runs, read-only status, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/isolation/recovery.ts

@@ -5,8 +5,8 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
-import { getSubagentsRoot } from "../execution/spawn.ts";
-import { managedRecoveryGroup } from "./managed-paths.ts";
+import { getProjectRoot, getSubagentsRoot } from "../execution/spawn.ts";
+import { managedRecoveryGroup, samePath } from "./managed-paths.ts";
 import { removeWorktreeGroup, type WorktreeFinalization } from "./worktree.ts";
 
 export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
@@ -170,25 +170,37 @@ export function recoveryRecordFromFinalization(
 	};
 }
 
-/** Show retained recovery paths on every later session start until the user
- * removes the artifacts. Records whose changes already landed only need the
- * worktree group deleted — the step whose failure retained them — so each
- * session start retries that removal first and forgets records it completes.
- * Stale records are pruned automatically. */
+function recoveryBelongsToSession(
+	configPath: string,
+	cwd: string,
+	groupDir: string,
+): boolean {
+	return samePath(dirname(dirname(groupDir)), getProjectRoot(configPath, cwd));
+}
+
+/** Show retained recovery paths on later session starts in the same project
+ * until the user removes the artifacts. A sibling pi window in another checkout
+ * must not retry cleanup or surface another project's worktree. Records whose
+ * changes already landed only need the worktree group deleted — the step whose
+ * failure retained them — so that project's next session retries that removal
+ * first and forgets records it completes. Stale records are pruned automatically. */
 export async function announceRecoveryRecords(
 	configPath: string,
 	ctx: {
 		hasUI?: boolean;
+		cwd: string;
 		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
 	},
 ): Promise<void> {
 	if (ctx.hasUI === false) return;
 	const records = await readRecoveryRecords(configPath);
 	if (records.length === 0) return;
+	const local = new Set<RecoveryRecord>();
 	for (const record of records) {
-		if (!record.integrated || !record.worktreePath) continue;
 		const groupDir = await managedRecoveryGroup(configPath, record);
-		if (!groupDir) continue;
+		if (!groupDir || !recoveryBelongsToSession(configPath, ctx.cwd, groupDir)) continue;
+		local.add(record);
+		if (!record.integrated || !record.worktreePath) continue;
 		if (!existsSync(record.worktreePath) && !(record.patchPath ? existsSync(record.patchPath) : false)) continue;
 		await removeWorktreeGroup({
 			worktreePath: record.worktreePath,
@@ -204,6 +216,7 @@ export async function announceRecoveryRecords(
 		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
 	}
 	for (const record of live) {
+		if (!local.has(record)) continue;
 		const paths = [
 			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
 			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,

package/src/lifecycle/durable.ts

@@ -293,8 +293,8 @@ function projectManifestPaths(durableRoot: string): string[] {
 	}
 }
 
-/** Every parked record across all projects, for restore and the state-root
- * sweeps that must see references from anywhere. */
+/** Every parked record across all projects. Session restore filters to the
+ * current checkout; state-root sweeps still need references from anywhere. */
 export async function readThreadRecords(configPath: string): Promise<ThreadRecord[]> {
 	const manifests = await Promise.all(
 		projectManifestPaths(getSubagentsRoot(configPath))

package/src/lifecycle/thread-restore.ts

@@ -16,12 +16,14 @@ import { monitor } from "../presentation/monitor.ts";
 import { emptyUsage } from "../execution/rpc-control.ts";
 import type { SubagentRuntime, SubagentThread, ThreadState } from "./runtime.ts";
 import {
+	getProjectRoot,
 	getSubagentsRoot,
 	RpcRunControl,
 	sessionExists,
 	sweepProjectResultArtifacts,
 	type SingleResult,
 } from "../execution/spawn.ts";
+import { samePath } from "../isolation/managed-paths.ts";
 import { isProcessAlive, killProcessTree, sweepProjectDurableDirs, sweepProjectTempDirs } from "../isolation/temp-hygiene.ts";
 import { readRecoveryRecords, referencedRecoveryPaths } from "../isolation/recovery.ts";
 import {
@@ -78,13 +80,21 @@ function createRestoredThread(
 	return thread;
 }
 
-/** Rebuild interrupted records for manual recovery after reload. Orphaned children
- * are stopped first; missing session files do not discard isolated edits. Already-
- * settled records from older versions are removed with their managed artifacts. */
-export async function restoreDurableThreads(runtime: SubagentRuntime): Promise<number[]> {
+function belongsToSessionProject(configPath: string, cwd: string, record: ThreadRecord): boolean {
+	return samePath(getProjectRoot(configPath, record.cwd), getProjectRoot(configPath, cwd));
+}
+
+/** Rebuild interrupted records for this session's checkout after reload.
+ * Other projects' parked threads stay on disk for their own window; this process
+ * must not restore them or kill their children. Orphaned children of *this*
+ * checkout are stopped first; missing session files do not discard isolated
+ * edits. Already-settled records from older versions are removed with their
+ * managed artifacts. */
+export async function restoreDurableThreads(runtime: SubagentRuntime, cwd: string): Promise<number[]> {
 	const records = await readThreadRecords(runtime.configPath);
 	const restoredIds: number[] = [];
 	for (const record of records) {
+		if (!belongsToSessionProject(runtime.configPath, cwd, record)) continue;
 		if (runtime.threads.has(record.runId) || monitor.findRun(record.runId)) continue;
 		if (record.state !== "parked") {
 			await discardRestoredRecord(runtime, record);
@@ -182,10 +192,10 @@ export async function restoreDurableThreads(runtime: SubagentRuntime): Promise<n
  * so callers that must see restored threads await that pass alone and never the
  * hygiene sweeps behind it. Hygiene still runs after restore: pruning decides
  * what to delete from the records restore has already claimed. */
-export function bootstrapDurableState(runtime: SubagentRuntime): Promise<void> {
+export function bootstrapDurableState(runtime: SubagentRuntime, cwd: string): Promise<void> {
 	const restore = (async () => {
 		try {
-			runtime.restoredRunIds = await restoreDurableThreads(runtime);
+			runtime.restoredRunIds = await restoreDurableThreads(runtime, cwd);
 		} catch {
 			/* restore is best-effort */
 		}