@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.0

package/src/registry/agent-registry.ts

@@ -45,6 +45,8 @@ export interface AgentRef {
 	activity?: string;
 }
 
+export type AgentRefExpectation = AgentRef | AgentSession;
+
 export type RegistryEvent =
 	| { type: "registered"; ref: AgentRef }
 	| { type: "status_changed"; ref: AgentRef }
@@ -80,6 +82,10 @@ export class AgentRegistry {
 	readonly #refs = new Map<string, AgentRef>();
 	readonly #listeners = new Set<RegistryListener>();
 
+	#matchesExpected(ref: AgentRef, expected?: AgentRefExpectation): boolean {
+		return expected === undefined || ref === expected || ref.session === expected;
+	}
+
 	register(input: RegisterInput): AgentRef {
 		const now = Date.now();
 		const ref: AgentRef = {
@@ -98,15 +104,28 @@ export class AgentRegistry {
 		return ref;
 	}
 
-	setStatus(id: string, status: AgentStatus): void {
+	/**
+	 * Register a new id only when it is absent, or reuse the exact ref a parked
+	 * revival was authorized to revive. A missing expected ref is a failed CAS:
+	 * callers must never claim an id after its prior generation disappeared.
+	 */
+	registerIfAvailable(input: RegisterInput, expected: AgentRef | null): AgentRef | undefined {
+		const current = this.#refs.get(input.id);
+		if (expected === null) return current ? undefined : this.register(input);
+		return current === expected ? current : undefined;
+	}
+
+	setStatus(id: string, status: AgentStatus, expected?: AgentRefExpectation): boolean {
 		const ref = this.#refs.get(id);
-		if (!ref || ref.status === status) return;
+		if (!ref || !this.#matchesExpected(ref, expected)) return false;
+		if (ref.status === status) return true;
 		ref.status = status;
 		// Activity describes current work; it is meaningless once the agent
 		// leaves `running`, so drop it to avoid showing stale work in rosters.
 		if (status !== "running") ref.activity = undefined;
 		ref.lastActivity = Date.now();
 		this.#emit({ type: "status_changed", ref });
+		return true;
 	}
 
 	/**
@@ -133,25 +152,33 @@ export class AgentRegistry {
 		ref.activity = gist;
 	}
 
-	attachSession(id: string, session: AgentSession, sessionFile?: string | null): void {
+	attachSession(
+		id: string,
+		session: AgentSession,
+		sessionFile?: string | null,
+		expected?: AgentRefExpectation,
+	): boolean {
 		const ref = this.#refs.get(id);
-		if (!ref) return;
+		if (!ref || !this.#matchesExpected(ref, expected)) return false;
 		ref.session = session;
 		if (sessionFile !== undefined) ref.sessionFile = sessionFile;
 		ref.lastActivity = Date.now();
+		return true;
 	}
 
-	detachSession(id: string): void {
+	detachSession(id: string, expected?: AgentRefExpectation): boolean {
 		const ref = this.#refs.get(id);
-		if (!ref) return;
+		if (!ref || !this.#matchesExpected(ref, expected)) return false;
 		ref.session = null;
+		return true;
 	}
 
-	unregister(id: string): void {
+	unregister(id: string, expected?: AgentRefExpectation): boolean {
 		const ref = this.#refs.get(id);
-		if (!ref) return;
+		if (!ref || !this.#matchesExpected(ref, expected)) return false;
 		this.#refs.delete(id);
 		this.#emit({ type: "removed", ref });
+		return true;
 	}
 
 	get(id: string): AgentRef | undefined {

package/src/registry/persisted-agents.ts

@@ -1,22 +1,45 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { ADVISOR_TRANSCRIPT_FILENAME, isAdvisorTranscriptName } from "../advisor/transcript-recorder";
+import { SessionManager } from "../session/session-manager";
+import { persistedVibeChildIds } from "../vibe/runtime";
 import { type AgentRegistry, MAIN_AGENT_ID } from "./agent-registry";
 
+/**
+ * Child ids owned by the Vibe roster persisted in this session file. Vibe
+ * workers are revived through the Vibe registry's own journal, so the generic
+ * persisted-subagent scan must not register them as plain `sub` refs.
+ */
+async function readPersistedVibeChildIds(sessionFile: string): Promise<Set<string>> {
+	let sessionManager: SessionManager;
+	try {
+		sessionManager = await SessionManager.open(sessionFile, undefined, undefined, { suppressBreadcrumb: true });
+	} catch {
+		return new Set();
+	}
+	try {
+		return persistedVibeChildIds(sessionManager.getEntries());
+	} finally {
+		await sessionManager.close();
+	}
+}
+
 /** Register persisted subagent and advisor transcripts as parked registry refs. */
 export async function registerPersistedSubagents(
 	registry: AgentRegistry,
 	sessionFile: string | null | undefined,
 ): Promise<void> {
 	if (!sessionFile?.endsWith(".jsonl")) return;
+	const vibeOwnedIds = await readPersistedVibeChildIds(sessionFile);
 	const root = sessionFile.slice(0, -6);
-	await registerPersistedSubagentsFromDir(registry, root, undefined);
+	await registerPersistedSubagentsFromDir(registry, root, undefined, vibeOwnedIds);
 }
 
 async function registerPersistedSubagentsFromDir(
 	registry: AgentRegistry,
 	dir: string,
 	parentId: string | undefined,
+	vibeOwnedIds: ReadonlySet<string>,
 ): Promise<void> {
 	let entries: fs.Dirent[];
 	try {
@@ -58,6 +81,7 @@ async function registerPersistedSubagentsFromDir(
 			continue;
 		}
 		const id = entry.name.slice(0, -6);
+		if (vibeOwnedIds.has(id) && registry.get(id)?.sessionFile !== sessionFile) continue;
 		if (!registry.get(id)) {
 			registry.register({
 				id,
@@ -69,6 +93,6 @@ async function registerPersistedSubagentsFromDir(
 				status: "parked",
 			});
 		}
-		await registerPersistedSubagentsFromDir(registry, path.join(dir, id), id);
+		await registerPersistedSubagentsFromDir(registry, path.join(dir, id), id, vibeOwnedIds);
 	}
 }