@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -7,9 +7,13 @@ import { fileURLToPath } from "node:url";
 import { describe, it } from "node:test";
 import {
 	buildSubagentToolDescription,
+	buildSubagentToolPromptMetadata,
 	COMPACT_SUBAGENT_TOOL_DESCRIPTION,
+	DEFAULT_SUBAGENT_TOOL_DESCRIPTION,
 	FULL_SUBAGENT_TOOL_DESCRIPTION,
 	SUBAGENT_SAFETY_GUIDANCE,
+	SUBAGENT_TOOL_PROMPT_GUIDELINES,
+	SUBAGENT_TOOL_PROMPT_SNIPPET,
 } from "../../src/extension/tool-description.ts";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
 
@@ -28,40 +32,73 @@ function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 }
 
 describe("registered subagent tool description", () => {
-	it("describes the four first-class execution modes", () => {
+	it("uses split metadata by default", () => {
+		const description = buildSubagentToolDescription();
+		const metadata = buildSubagentToolPromptMetadata();
+		assert.equal(description, DEFAULT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(Buffer.byteLength(description), 712);
+		assert.equal(metadata.promptSnippet, SUBAGENT_TOOL_PROMPT_SNIPPET);
+		assert.equal(Buffer.byteLength(metadata.promptSnippet!), 62);
+		assert.deepEqual(metadata.promptGuidelines, SUBAGENT_TOOL_PROMPT_GUIDELINES);
+		assert.equal(Buffer.byteLength(metadata.promptGuidelines!.join("\n")), 1249);
+		assert.match(metadata.promptGuidelines!.join("\n"), /Use subagent only when delegation is needed/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /action: \"list\".*executable, non-disabled/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /workflowScript for multi-step or parallel work/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /workflowScript means exactly one top-level subagent tool call with async:true/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /Inside it, use runs\.run\/runs\.all to launch children/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /do not make another top-level subagent call for those children/i);
+		assert.match(metadata.promptGuidelines!.join("\n"), /await runs\.all.*do not read \.output from unawaited runs\.run launches/i);
+	});
+
+	it("keeps the full description when configured", () => {
 		const description = buildSubagentToolDescription({ toolDescriptionMode: "full" });
-		assert.match(description, /^Delegate one child with \{ agent, task \}/i);
-		assert.match(description, /SINGLE: \{ agent, task\? \}/i);
-		assert.match(description, /CHAIN: \{ chain: \[\{ agent: "explorer"/i);
-		assert.match(description, /PARALLEL: \{ tasks:/i);
-		assert.match(description, /runs\.run for one child and runs\.all for parallel children/i);
+		assert.equal(buildSubagentToolPromptMetadata({ toolDescriptionMode: "full" }).promptSnippet, undefined);
+		assert.match(description, /^Run one child with \{ agent, task\? \}; use \{ workflowScript \} for orchestration/i);
+		assert.match(description, /SINGLE CHILD:.*starts exactly one direct child/i);
+		assert.match(description, /Do not combine agent\/task with action or workflowScript/i);
+		assert.match(description, /runs\.run for one child and await runs\.all.*ordinary parallel children/i);
+		assert.match(description, /do not read \.output from unawaited runs\.run launches/i);
+		assert.match(description, /runs\.steer\(key, message, \{mode\?, index\?, ackTimeoutMs\?\}\).*prior keyed child.*without exposing its run id/i);
+		assert.match(description, /receipts are queued, delivered, missed, or failed/i);
 		assert.match(description, /repository mutation lanes.*worktree:true.*runs\.run\/runs\.all.*managed isolation/i);
 		assert.match(description, /ordinary JavaScript statement body.*explicit return/i);
 		assert.match(description, /Sequential example/i);
 		assert.match(description, /Parallel example/i);
-		assert.match(description, /append-step/i);
-		assert.match(description, /approve-checkpoint and reject-checkpoint/i);
+		assert.match(description, /defaultSubagentContext wins over agent defaultContext/i);
+		assert.doesNotMatch(description, /Compatibility tasks\[\]|CHAIN EXAMPLES|PARALLEL \(compatibility\)/i);
+		assert.doesNotMatch(description, /append-step|approve-checkpoint|reject-checkpoint/);
 		assert.match(description, /cannot access filesystem, shell, arbitrary Pi tools, or host globals/i);
 		assert.match(description, /exactly one non-empty title or summary/i);
 		assert.match(description, /goal may only be true and requires budget:\{tokens\}/i);
 		assert.match(description, /SAFETY-CRITICAL SUBAGENT GUIDANCE/);
+		assert.match(description, /continue independent work only until its next dependency barrier; consume the result before work that depends on it/i);
+		assert.match(description, /children\.list.*resumable\/not-resumable reasons/i);
+		assert.match(description, /Resume only rows reported resumable/i);
+		assert.match(description, /implementation challenge.*\{action:\"resume\", id:\"run-id\", message:\"\.\.\.\"\}/i);
+		assert.match(description, /Resume keeps the stored agent\/model\/tool contract/i);
+		assert.match(description, /Oracle\/advisor consultations should use supervisor dialogue for material unknowns when available/i);
+		assert.match(description, /same-role fallback challenge and label it as fallback/i);
 		assert.match(description, /status\.json/);
 	});
 
-	it("includes legacy chain-control guidance when enabled", () => {
-		const description = buildSubagentToolDescription({ toolDescriptionMode: "full", legacyChainControls: true });
-		assert.match(description, /append-step.*step:/i);
-		assert.match(description, /approve-checkpoint|reject-checkpoint/);
-	});
-
-	it("offers a compact mode that keeps the cutover and safety guidance", () => {
-		const description = buildSubagentToolDescription({ toolDescriptionMode: "compact", legacyChainControls: true });
+	it("offers a compact mode that keeps the two-tier contract and safety guidance", () => {
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "compact" });
 		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
-		assert.match(description, /^Delegate one child with \{ agent, task \}/i);
-		assert.match(description, /runs\.run for one child and runs\.all for parallel work/i);
+		assert.match(description, /^Run one child with \{ agent, task\? \}; use \{ workflowScript \} for orchestration/i);
+		assert.match(description, /SINGLE .*starts exactly one direct child/i);
+		assert.match(description, /runs\.run for one child and await runs\.all.*ordinary parallel work/i);
+		assert.match(description, /do not read \.output from unawaited runs\.run launches/i);
+		assert.match(description, /runs\.steer\(key,message,options\?\).*prior keyed child/i);
+		assert.match(description, /never accepts a raw run id/i);
 		assert.match(description, /repository mutation lanes.*worktree:true.*runs\.run\/runs\.all.*managed isolation/i);
-		assert.match(description, /SINGLE \{agent, task\?\}|CHAIN \{chain:/i);
+		assert.doesNotMatch(description, /tasks\[\]|chain\[\]/i);
 		assert.match(description, /subagent_wait/i);
+		assert.match(description, /continue independent work only until its next dependency barrier; consume the result before work that depends on it/i);
+		assert.match(description, /children\.list.*resume only rows reported resumable/i);
+		assert.match(description, /\{action:\"resume\",id:\"run-id\",message:\"\.\.\.\"\} for a simple follow-up or challenge/i);
+		assert.match(description, /resume keeps the stored agent\/model\/tool contract/i);
+		assert.match(description, /Oracle\/advisor consultations use available supervisor dialogue/i);
+		assert.match(description, /same-role fallback challenge and label it as fallback/i);
 		assert.match(description, /exactly one non-empty title or summary/i);
 		assert.match(description, /goal may only be true and requires budget:\{tokens\}/i);
 		assert.ok(description.length < FULL_SUBAGENT_TOOL_DESCRIPTION.length);
@@ -147,33 +184,33 @@ describe("registered subagent tool description", () => {
 		assert.doesNotMatch(description, /decide a paused durable legacy chain checkpoint/);
 	});
 
-	it("falls back to compact mode when custom mode has no valid file", () => {
+	it("falls back to full mode when custom mode has no valid file", () => {
 		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
 		const warnings: string[] = [];
 
 		const description = buildSubagentToolDescription(
-			{ toolDescriptionMode: "custom", legacyChainControls: true },
+			{ toolDescriptionMode: "custom" },
 			{ cwd, agentDir, warn: (message) => warnings.push(message) },
 		);
 
-		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
-		assert.ok(warnings.some((message) => message.includes("using compact description")));
+		assert.equal(description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		assert.ok(warnings.some((message) => message.includes("using full description")));
 	});
 
-	it("falls back to compact mode when toolDescriptionMode is invalid", () => {
+	it("falls back to full mode when toolDescriptionMode is invalid", () => {
 		const warnings: string[] = [];
 
 		const description = buildSubagentToolDescription(
-			{ toolDescriptionMode: "tiny", legacyChainControls: true } as never,
+			{ toolDescriptionMode: "tiny" } as never,
 			{ warn: (message) => warnings.push(message) },
 		);
 
-		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 		assert.ok(warnings.some((message) => message.includes("Ignoring invalid toolDescriptionMode")));
 	});
 
-	function readRegisteredTool(agentDir: string): { description: string; properties: string[] } {
+	function readRegisteredTool(agentDir: string): { description: string; promptSnippet?: string; promptGuidelines?: string[]; properties: string[] } {
 		const script = String.raw`
 			import registerSubagentExtension from "./src/extension/index.ts";
 			const events = { on() { return () => {}; }, emit() {} };
@@ -194,7 +231,7 @@ describe("registered subagent tool description", () => {
 			});
 			registerSubagentExtension(fakePi);
 			if (!registeredTool) throw new Error("tool not registered");
-			process.stdout.write(JSON.stringify({ description: registeredTool.description, properties: Object.keys(registeredTool.parameters.properties) }));
+			process.stdout.write(JSON.stringify({ description: registeredTool.description, promptSnippet: registeredTool.promptSnippet, promptGuidelines: registeredTool.promptGuidelines, properties: Object.keys(registeredTool.parameters.properties) }));
 		`;
 		const output = execFileSync(
 			process.execPath,
@@ -208,7 +245,7 @@ describe("registered subagent tool description", () => {
 			],
 			{ cwd: projectRoot, env: parentToolEnv(agentDir), encoding: "utf-8" },
 		);
-		return JSON.parse(output) as { description: string; properties: string[] };
+		return JSON.parse(output) as { description: string; promptSnippet?: string; promptGuidelines?: string[]; properties: string[] };
 	}
 
 	function writeExtensionConfig(agentDir: string, config: Record<string, unknown>): void {
@@ -217,14 +254,27 @@ describe("registered subagent tool description", () => {
 		fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify(config), "utf-8");
 	}
 
-	it("registers full, compact, custom, and fallback descriptions from extension config", () => {
+	it("registers split, full, compact, custom, and fallback descriptions from extension config", () => {
 		const defaultAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-default-"));
-		writeExtensionConfig(defaultAgentDir, { toolDescriptionMode: "full", legacyChainControls: true });
-		assert.equal(readRegisteredTool(defaultAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(defaultAgentDir, {});
+		const defaultTool = readRegisteredTool(defaultAgentDir);
+		assert.equal(defaultTool.description, DEFAULT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(defaultTool.promptSnippet, SUBAGENT_TOOL_PROMPT_SNIPPET);
+		assert.deepEqual(defaultTool.promptGuidelines, SUBAGENT_TOOL_PROMPT_GUIDELINES);
+
+		const fullAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-full-"));
+		writeExtensionConfig(fullAgentDir, { toolDescriptionMode: "full" });
+		const fullTool = readRegisteredTool(fullAgentDir);
+		assert.equal(fullTool.description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(fullTool.promptSnippet, undefined);
+		assert.equal(fullTool.promptGuidelines, undefined);
 
 		const compactAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-compact-"));
-		writeExtensionConfig(compactAgentDir, { toolDescriptionMode: "compact", legacyChainControls: true });
-		assert.equal(readRegisteredTool(compactAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(compactAgentDir, { toolDescriptionMode: "compact" });
+		const compactTool = readRegisteredTool(compactAgentDir);
+		assert.equal(compactTool.description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.equal(compactTool.promptSnippet, undefined);
+		assert.equal(compactTool.promptGuidelines, undefined);
 
 		const customAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-custom-"));
 		writeExtensionConfig(customAgentDir, { toolDescriptionMode: "custom" });
@@ -234,28 +284,18 @@ describe("registered subagent tool description", () => {
 		assert.match(customDescription, /SAFETY-CRITICAL SUBAGENT GUIDANCE/);
 
 		const missingCustomAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
-		writeExtensionConfig(missingCustomAgentDir, { toolDescriptionMode: "custom", legacyChainControls: true });
-		assert.equal(readRegisteredTool(missingCustomAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(missingCustomAgentDir, { toolDescriptionMode: "custom" });
+		assert.equal(readRegisteredTool(missingCustomAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 
 		const invalidAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-invalid-"));
-		writeExtensionConfig(invalidAgentDir, { toolDescriptionMode: "tiny", legacyChainControls: true });
-		assert.equal(readRegisteredTool(invalidAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(invalidAgentDir, { toolDescriptionMode: "tiny" });
+		assert.equal(readRegisteredTool(invalidAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 	});
 
-	it("registers the full schema and chain description by default", () => {
+	it("registers the trimmed schema and description by default", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-trimmed-"));
 		const tool = readRegisteredTool(agentDir);
-		assert.equal(tool.properties.includes("step"), true);
-		assert.equal(tool.properties.includes("chain"), true);
-		assert.equal(tool.properties.includes("tasks"), true);
-		assert.match(tool.description, /CHAIN \{chain:/i);
-	});
-
-	it("registers the trimmed schema and description when legacyChainControls is false", () => {
-		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-legacy-"));
-		writeExtensionConfig(agentDir, { legacyChainControls: false });
-		const tool = readRegisteredTool(agentDir);
 		assert.equal(tool.properties.includes("step"), false);
-		assert.doesNotMatch(tool.description, /append-step/i);
+		assert.doesNotMatch(tool.description, /append-step|approve-checkpoint|reject-checkpoint/);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/tool-timeout.test.ts

@@ -100,10 +100,9 @@ describe("tool timeout formatting and keys", () => {
 });
 
 describe("toolTimeoutFromEnv", () => {
-	it("reads SELESAI_SUBAGENT_TOOL_TIMEOUT_MS from the process env, with PI_ fallback", () => {
+	it("reads SELESAI_SUBAGENT_TOOL_TIMEOUT_MS from the process env", () => {
 		assert.equal(TOOL_TIMEOUT_ENV, "SELESAI_SUBAGENT_TOOL_TIMEOUT_MS");
 		assert.equal(toolTimeoutFromEnv({ SELESAI_SUBAGENT_TOOL_TIMEOUT_MS: "123" }), "123");
-		assert.equal(toolTimeoutFromEnv({ PI_SUBAGENT_TOOL_TIMEOUT_MS: "456" }), "456");
 		assert.equal(toolTimeoutFromEnv({}), undefined);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/wait-subscriptions.test.ts

@@ -8,6 +8,7 @@ import { registerWaitTool } from "../../src/runs/background/wait-tool.ts";
 import { createWaitSubscriptionManager } from "../../src/runs/background/wait-subscriptions.ts";
 import { recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, type IntercomEventBus, type SubagentState } from "../../src/shared/types.ts";
 
 function writeStatus(asyncRoot: string, runId: string, state: string, extra: object = {}): void {
@@ -25,6 +26,23 @@ function writeStatus(asyncRoot: string, runId: string, state: string, extra: obj
 	}), "utf-8");
 }
 
+function writeRecoveryDescriptor(asyncRoot: string, runId: string, agent: string, sessionFile: string, cwd: string): void {
+	fs.writeFileSync(path.join(asyncRoot, runId, "recovery-descriptor.json"), JSON.stringify({
+		version: 1,
+		sourceRunId: runId,
+		agent,
+		sessionFile,
+		cwd,
+		systemPromptMode: "append",
+		outputMode: "inline",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		maxSubagentDepth: 0,
+		share: false,
+		runFanoutBudget: createRunFanoutBudget(runId, 64),
+	}), "utf-8");
+}
+
 function makeState(sessionId = "session-a"): SubagentState {
 	return {
 		baseCwd: "",
@@ -68,7 +86,7 @@ describe("non-blocking wait subscriptions", () => {
 			const asyncRoot = path.join(root, "runs");
 			writeStatus(asyncRoot, "run-alpha", "running", { sessionId: "session-a", pid: 999_999 });
 			let armed: { targetKind: "async" | "foreground"; runId: string; requestedId: string; timeoutMs: number } | undefined;
-			const result = await waitForSubagents({ id: "run-al", nonBlocking: true, timeoutMs: 5_000 }, undefined, {
+			const result = await waitForSubagents({ id: "run-alph", nonBlocking: true, timeoutMs: 5_000 }, undefined, {
 				state: makeState(),
 				asyncDirRoot: asyncRoot,
 				resultsDir: path.join(root, "results"),
@@ -82,7 +100,7 @@ describe("non-blocking wait subscriptions", () => {
 
 			assert.equal(result.isError, undefined);
 			assert.match(textOf(result), /Armed wait subscription wait-token/);
-			assert.deepEqual(armed, { targetKind: "async", runId: "run-alpha", requestedId: "run-al", timeoutMs: 5_000 });
+			assert.deepEqual(armed, { targetKind: "async", runId: "run-alpha", requestedId: "run-alph", timeoutMs: 5_000 });
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -107,9 +125,10 @@ describe("non-blocking wait subscriptions", () => {
 			} as never, state, true, {
 				arm() { throw new Error("headless calls must not arm subscriptions"); },
 			});
-			const result = await tool!.execute("wait", { id: "run-headless", nonBlocking: true }, undefined, undefined, { hasUI: false });
-			assert.equal(result.isError, true);
-			assert.match(textOf(result), /long-lived interactive subagent runtime/);
+			await assert.rejects(
+				tool!.execute("wait", { id: "run-headless", nonBlocking: true }, undefined, undefined, { hasUI: false }),
+				/long-lived interactive subagent runtime/,
+			);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -213,6 +232,7 @@ describe("non-blocking wait subscriptions", () => {
 			fs.writeFileSync(completedSessionFile, "{}\n", "utf-8");
 			fs.writeFileSync(failedSessionFile, "{}\n", "utf-8");
 			writeStatus(asyncRoot, "run-revive", "running", { sessionId: "session-a", pid: 999_999 });
+			writeRecoveryDescriptor(asyncRoot, "run-revive", "second", failedSessionFile, root);
 			manager.arm({ targetKind: "async", runId: "run-revive", requestedId: "run-revive", timeoutMs: 30_000 });
 
 			writeStatus(asyncRoot, "run-revive", "failed", {
@@ -370,7 +390,7 @@ describe("non-blocking wait subscriptions", () => {
 		}
 	});
 
-	it("wakes when async reconciliation throws", () => {
+	it("wakes when an exact async run cannot be reconciled", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-reconcile-error-"));
 		const asyncRoot = path.join(root, "not-a-directory");
 		const subscriptionsDir = path.join(root, "subscriptions");
@@ -385,7 +405,7 @@ describe("non-blocking wait subscriptions", () => {
 		try {
 			const registration = manager.arm({ targetKind: "async", runId: "run-error", requestedId: "run-error", timeoutMs: 30_000 });
 			manager.reconcile();
-			assert.match(sent[0] ?? "", /reconciliation failed/);
+			assert.match(sent[0] ?? "", /could not be reconciled/);
 			assert.equal(state.waitSubscriptions?.has(registration.token), false);
 			assert.equal(fs.existsSync(path.join(subscriptionsDir, `${registration.token}.json`)), false);
 		} finally {
@@ -432,3 +452,210 @@ describe("non-blocking wait subscriptions", () => {
 		}
 	});
 });
+
+describe("wait subscriptions armed by another session", () => {
+	function subscriptionFiles(dir: string): string[] {
+		try {
+			return fs.readdirSync(dir).filter((file) => file.endsWith(".json"));
+		} catch {
+			return [];
+		}
+	}
+
+	it("sweeps an expired record whose owning session never came back", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-orphan-"));
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const sent: string[] = [];
+		const pi = {
+			events: new TestBus(),
+			sendMessage(message: { content?: unknown }) { sent.push(String(message.content)); },
+		};
+		let now = 1_000;
+		const owner = makeState("session-a");
+		const armer = createWaitSubscriptionManager(pi as never, owner, {
+			subscriptionsDir,
+			pollIntervalMs: 60_000,
+			now: () => now,
+		});
+		try {
+			armer.arm({ targetKind: "async", runId: "run-orphan", requestedId: "run-orphan", timeoutMs: 100 });
+			assert.equal(subscriptionFiles(subscriptionsDir).length, 1);
+			armer.dispose();
+
+			// A different session starts well after the record expired. Before this
+			// swept, the file was never loaded, never reconciled and never timed
+			// out, so it stayed on disk forever.
+			now = 1_101 + 86400000;
+			const other = makeState("session-b");
+			const restarted = createWaitSubscriptionManager(pi as never, other, {
+				subscriptionsDir,
+				pollIntervalMs: 60_000,
+				now: () => now,
+			});
+			try {
+				restarted.restore();
+				assert.deepEqual(subscriptionFiles(subscriptionsDir), [], "expired foreign record is removed");
+				assert.equal(sent.length, 0, "no wake is delivered to the wrong session");
+			} finally {
+				restarted.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps another session's record until it expires", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-foreign-live-"));
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const pi = {
+			events: new TestBus(),
+			sendMessage() {},
+		};
+		let now = 1_000;
+		const owner = makeState("session-a");
+		const armer = createWaitSubscriptionManager(pi as never, owner, {
+			subscriptionsDir,
+			pollIntervalMs: 60_000,
+			now: () => now,
+		});
+		try {
+			armer.arm({ targetKind: "async", runId: "run-live", requestedId: "run-live", timeoutMs: 10_000 });
+			armer.dispose();
+
+			now = 1_500; // still well inside the window
+			const other = makeState("session-b");
+			const restarted = createWaitSubscriptionManager(pi as never, other, {
+				subscriptionsDir,
+				pollIntervalMs: 60_000,
+				now: () => now,
+			});
+			try {
+				restarted.restore();
+				assert.equal(subscriptionFiles(subscriptionsDir).length, 1, "an unexpired record still belongs to its owner");
+			} finally {
+				restarted.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("sweeps a foreign record that expires while another session stays open", () => {
+		// restore() only fires on session_start and reconcile() walks the in-memory
+		// map, which holds current-session records only. A record that is still live
+		// when the next session starts is therefore retained by restore() and, without
+		// a periodic sweep, never looked at again once it expires.
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-late-expiry-"));
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const pi = {
+			events: new TestBus(),
+			sendMessage() {},
+		};
+		let now = 1_000;
+		const armer = createWaitSubscriptionManager(pi as never, makeState("session-a"), {
+			subscriptionsDir,
+			pollIntervalMs: 60_000,
+			now: () => now,
+		});
+		try {
+			armer.arm({ targetKind: "async", runId: "run-late", requestedId: "run-late", timeoutMs: 30_000 });
+			armer.dispose();
+
+			const other = makeState("session-b");
+			const open = createWaitSubscriptionManager(pi as never, other, {
+				subscriptionsDir,
+				pollIntervalMs: 60_000,
+				now: () => now,
+			});
+			try {
+				open.restore();
+				assert.equal(subscriptionFiles(subscriptionsDir).length, 1, "still live, so retained");
+
+				// The other session stays open past the record's expiry and grace.
+				now = 1_000 + 30_000 + 86400000 + 120_000;
+				open.reconcile();
+				assert.deepEqual(subscriptionFiles(subscriptionsDir), [], "expired record is swept without a restart");
+			} finally {
+				open.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps an expired foreign record through the grace window", () => {
+		// The owner settles its own expired records with a timeout notice on its next
+		// restore(). Sweeping the instant it expires would take that away from a
+		// session that had simply not resumed yet.
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-grace-"));
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const pi = { events: new TestBus(), sendMessage() {} };
+		let now = 1_000;
+		const armer = createWaitSubscriptionManager(pi as never, makeState("session-a"), {
+			subscriptionsDir,
+			pollIntervalMs: 60_000,
+			now: () => now,
+		});
+		try {
+			armer.arm({ targetKind: "async", runId: "run-grace", requestedId: "run-grace", timeoutMs: 100 });
+			armer.dispose();
+
+			now = 1_101 + 60_000; // expired, but well inside the grace window
+			const other = createWaitSubscriptionManager(pi as never, makeState("session-b"), {
+				subscriptionsDir,
+				pollIntervalMs: 60_000,
+				now: () => now,
+			});
+			try {
+				other.restore();
+				assert.equal(subscriptionFiles(subscriptionsDir).length, 1, "owner can still collect its timeout notice");
+			} finally {
+				other.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("still gives the owning session its timeout notice after a restart", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-owner-timeout-"));
+		const asyncRoot = path.join(root, "runs");
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const sent: string[] = [];
+		const pi = {
+			events: new TestBus(),
+			sendMessage(message: { content?: unknown }) { sent.push(String(message.content)); },
+		};
+		let now = 1_000;
+		writeStatus(asyncRoot, "run-owned", "running", { sessionId: "session-a", pid: 999_997 });
+		const first = createWaitSubscriptionManager(pi as never, makeState("session-a"), {
+			asyncDirRoot: asyncRoot,
+			subscriptionsDir,
+			pollIntervalMs: 60_000,
+			now: () => now,
+			kill: () => true,
+		});
+		try {
+			first.arm({ targetKind: "async", runId: "run-owned", requestedId: "run-owned", timeoutMs: 100 });
+			first.dispose();
+
+			now = 1_101; // expired, but this session owns it
+			const resumed = createWaitSubscriptionManager(pi as never, makeState("session-a"), {
+				asyncDirRoot: asyncRoot,
+				subscriptionsDir,
+				pollIntervalMs: 60_000,
+				now: () => now,
+				kill: () => true,
+			});
+			try {
+				resumed.restore();
+				assert.match(sent.shift() ?? "", /timed out/, "the owner is still told its wait expired");
+				assert.deepEqual(subscriptionFiles(subscriptionsDir), []);
+			} finally {
+				resumed.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/watch-strategy.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { shouldUseNativeFsWatch, type FileWatchPurpose } from "../../src/shared/watch-strategy.ts";
+
+const purposes: FileWatchPurpose[] = [
+	"result-delivery",
+	"supervisor-channel",
+	"async-job-tracker",
+	"runner-control-inbox",
+	"child-steering-inbox",
+];
+
+describe("watch strategy", () => {
+	it("disables native filesystem watchers on Darwin", () => {
+		for (const purpose of purposes) assert.equal(shouldUseNativeFsWatch(purpose, "darwin"), false);
+	});
+
+	it("keeps native filesystem watchers on non-Darwin platforms", () => {
+		for (const purpose of purposes) {
+			assert.equal(shouldUseNativeFsWatch(purpose, "linux"), true);
+			assert.equal(shouldUseNativeFsWatch(purpose, "win32"), true);
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/watchdog-permission-arbiter.test.ts

@@ -76,4 +76,40 @@ describe("watchdog permission arbiter", () => {
 			fs.rmSync(dir, { recursive: true, force: true });
 		}
 	});
+
+	it("fails closed when watchdog model auth resolution stalls", async () => {
+		const stalledCtx = {
+			...ctx(),
+			modelRegistry: {
+				...ctx().modelRegistry,
+				getApiKeyAndHeaders: async () => new Promise(() => undefined),
+			},
+		} as never;
+
+		const result = await Promise.race([
+			createWatchdogPermissionArbiter()({
+				ctx: stalledCtx,
+				toolName: "write",
+				args: { path: "out.txt" },
+				rawWatchdogConfig: JSON.stringify({
+					enabled: true,
+					watchdogTailTimeoutMs: 1_000,
+					agentEndTimeoutMs: 5,
+					maxWarnings: null,
+					lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
+					autoFollowBlockers: false,
+					autoFollowMaxAttempts: null,
+					stalemateRepeats: 2,
+				}),
+			}),
+			new Promise((resolve) => setTimeout(() => resolve("hung"), 100)),
+		]);
+
+		assert.notEqual(result, "hung");
+		assert.deepEqual(result, {
+			approved: false,
+			reason: "Watchdog permission decision timed out.",
+			source: "watchdog",
+		});
+	});
 });