@selesai/code 0.8.5 → 0.8.7

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

@@ -104,6 +104,19 @@ describe("resolveIntercomBridge", () => {
 		assert.equal(bridge.extensionDir, NATIVE_INTERCOM_EXTENSION_DIR);
 	});
 
+	it("uses a per-run override instead of the global config", () => {
+		const bridge = resolveIntercomBridge({
+			config: { mode: "always", resultDelivery: true },
+			override: { mode: "off" },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+
+		assert.equal(bridge.active, false);
+		assert.equal(bridge.mode, "off");
+		assert.equal(bridge.resultDelivery, false);
+	});
+
 	it("can disable external grouped-result delivery without disabling supervisor coordination", () => {
 		const bridge = resolveIntercomBridge({
 			config: { mode: "always", resultDelivery: false },
@@ -166,17 +179,18 @@ describe("applyIntercomBridgeToAgent", () => {
 		instruction: "Intercom orchestration channel:\n- Need a decision or blocked: contact_supervisor({ reason: \"need_decision\", message: \"<question>\" })\n- Blocked/update: contact_supervisor({ reason: \"progress_update\", message: \"UPDATE: <summary>\" })",
 	};
 
-	it("injects intercom tool and prompt instructions", () => {
+	it("injects contact_supervisor and prompt instructions", () => {
 		const updated = applyIntercomBridgeToAgent(makeAgent({ tools: ["read", "bash"] }), activeBridge);
-		assert.deepEqual(updated.tools, ["read", "bash", "intercom", "contact_supervisor"]);
+		assert.deepEqual(updated.tools, ["read", "bash", "contact_supervisor"]);
 		assert.match(updated.systemPrompt, /Intercom orchestration channel:/);
 		assert.match(updated.systemPrompt, /contact_supervisor/);
+		assert.doesNotMatch(updated.systemPrompt ?? "", /Generic intercom/);
 	});
 
 	it("is idempotent", () => {
 		const first = applyIntercomBridgeToAgent(makeAgent({ tools: ["read"] }), activeBridge);
 		const second = applyIntercomBridgeToAgent(first, activeBridge);
-		assert.equal(second.tools?.filter((tool) => tool === "intercom").length, 1);
+		assert.equal(second.tools?.filter((tool) => tool === "intercom").length, 0);
 		assert.equal(second.tools?.filter((tool) => tool === "contact_supervisor").length, 1);
 		assert.equal(second.systemPrompt, first.systemPrompt);
 	});
@@ -184,10 +198,15 @@ describe("applyIntercomBridgeToAgent", () => {
 	it("does not block native supervisor tools for agents with explicit extension allowlists", () => {
 		const agent = makeAgent({ tools: ["read"], extensions: ["/tmp/other-extension/index.ts"] });
 		const updated = applyIntercomBridgeToAgent(agent, activeBridge);
-		assert.deepEqual(updated.tools, ["read", "intercom", "contact_supervisor"]);
+		assert.deepEqual(updated.tools, ["read", "contact_supervisor"]);
 		assert.match(updated.systemPrompt, /contact_supervisor/);
 	});
 
+	it("preserves explicitly requested external intercom tools", () => {
+		const updated = applyIntercomBridgeToAgent(makeAgent({ tools: ["read", "intercom"] }), activeBridge);
+		assert.deepEqual(updated.tools, ["read", "intercom", "contact_supervisor"]);
+	});
+
 	it("does not widen explicit empty or MCP-only builtin allowlists", () => {
 		const emptyTools = applyIntercomBridgeToAgent(makeAgent({ tools: [] }), activeBridge);
 		assert.deepEqual(emptyTools.tools, []);

package/dist/extensions/pi-subagents/test/unit/llm-intent-arbiter.test.ts

@@ -4,6 +4,7 @@ import {
 	arbitrateCompletionGuardRescue,
 	createTaskMutationArbiter,
 	isCompletionGuardFailure,
+	mapArbiterDecision,
 	maybeRescueCompletionGuardFailure,
 	type TaskMutationArbiter,
 } from "../../src/runs/shared/llm-intent-arbiter.ts";
@@ -30,7 +31,7 @@ function stubArbiter(verdict: "read-only" | "implementation" | "unavailable" | "
 }
 
 describe("arbitrateCompletionGuardRescue", () => {
-	it("rescues only a confident read-only verdict", async () => {
+	it("rescues on a read-only verdict, keeps the failure otherwise", async () => {
 		const rescued = await arbitrateCompletionGuardRescue({
 			guardTriggered: true,
 			task: "t",
@@ -47,6 +48,18 @@ describe("arbitrateCompletionGuardRescue", () => {
 		}
 	});
 
+	it("never arbitrates from partial evidence on tasks over 8000 chars", async () => {
+		const middle = "And now apply the fix in the middle of this long task. ";
+		const longTask = "Review the setup. ".repeat(400) + middle + "Review more. ".repeat(400);
+		assert.ok(longTask.length > 8000);
+		const kept = await arbitrateCompletionGuardRescue({
+			guardTriggered: true,
+			task: longTask,
+			arbiter: stubArbiter("read-only"),
+		});
+		assert.deepEqual(kept, { triggered: true, rescued: false });
+	});
+
 	it("keeps the guard verdict without an arbiter or on arbiter failure", async () => {
 		assert.deepEqual(
 			await arbitrateCompletionGuardRescue({ guardTriggered: true, task: "t" }),
@@ -63,6 +76,48 @@ describe("arbitrateCompletionGuardRescue", () => {
 	});
 });
 
+describe("mapArbiterDecision", () => {
+	it("only a high-confidence read_only rescues", () => {
+		assert.equal(mapArbiterDecision({ classification: "read_only", confidence: "high" }), "read-only");
+		for (const confidence of ["low", "medium", undefined] as const) {
+			assert.equal(
+				mapArbiterDecision({ classification: "read_only", confidence }),
+				"implementation",
+				String(confidence),
+			);
+		}
+		assert.equal(mapArbiterDecision({ classification: "implementation", confidence: "high" }), "implementation");
+		assert.equal(mapArbiterDecision(undefined), "unavailable");
+	});
+});
+
+describe("arbiter auth receiver", () => {
+	it("resolves registry credentials through the registry receiver (class instance state)", async () => {
+		// Prototype method reading instance state: a detached call would lose
+		// `this` and fail auth. The fix must call it as a method on the registry.
+		class FakeRegistry {
+			readonly key = "instance-key";
+			async getApiKeyAndHeaders(_model: unknown) {
+				return { ok: true, apiKey: this.key };
+			}
+		}
+		let captured: Record<string, unknown> | undefined;
+		const ctx = {
+			model: { provider: "test", id: "model-1", api: "test-api" },
+			modelRegistry: new FakeRegistry(),
+		} as never;
+		const arbiter = createTaskMutationArbiter(ctx, {
+			streamFn: async (_model: unknown, _context: unknown, opts: Record<string, unknown>) => {
+				captured = opts;
+				throw new Error("stream fail");
+			},
+		})!;
+		const verdict = await arbiter("t");
+		assert.equal(verdict, "unavailable"); // stream deliberately fails
+		assert.equal(captured?.apiKey, "instance-key", "registry credential must reach the stream function");
+	});
+});
+
 describe("isCompletionGuardFailure", () => {
 	it("recognizes the guard error prefix", () => {
 		assert.equal(isCompletionGuardFailure({ error: GUARD_ERROR }), true);

package/dist/extensions/pi-subagents/test/unit/mission-goal-driver.test.ts

@@ -7,6 +7,7 @@ import { handleMissionAction } from "../../src/missions/actions.ts";
 import { collectGoalContinuationNotices } from "../../src/missions/goal-driver.ts";
 import { createMission, readMission, resolveMissionStoreLocation, updateMission } from "../../src/missions/store.ts";
 import { missionStatePath } from "../../src/missions/workflow-state.ts";
+import type { RetainedChild } from "../../src/runs/background/retained-children.ts";
 
 function fixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-goal-mission-"));
@@ -46,7 +47,7 @@ describe("goal mission continuation", () => {
 			const resumed = collectGoalContinuationNotices({
 				location: test.location,
 				ownerSessionId: "session-1",
-				retainedChildren: [{ runId: "child-review", parentRunId: "workflow-1", agent: "reviewer", taskSummary: "Review", completedAt: 1, sessionPath: "/tmp/child.jsonl" }],
+				retainedChildren: [{ runId: "child-review", parentRunId: "workflow-1", state: "complete", agent: "reviewer", taskSummary: "Review", completedAt: 1, sessionPath: "/tmp/child.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/child.jsonl" } }],
 				turnId: 3,
 			});
 			assert.equal(resumed.length, 1);
@@ -85,8 +86,8 @@ describe("goal mission continuation", () => {
 				location: test.location,
 				ownerSessionId: "session-1",
 				retainedChildren: [
-					{ runId: "child-old", parentRunId: "workflow-old", agent: "reviewer", taskSummary: "Old", completedAt: 2, sessionPath: "/tmp/old.jsonl" },
-					{ runId: "child-new", parentRunId: "workflow-new", agent: "reviewer", taskSummary: "New", completedAt: 1, sessionPath: "/tmp/new.jsonl" },
+					{ runId: "child-old", parentRunId: "workflow-old", state: "complete", agent: "reviewer", taskSummary: "Old", completedAt: 2, sessionPath: "/tmp/old.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/old.jsonl" } },
+					{ runId: "child-new", parentRunId: "workflow-new", state: "complete", agent: "reviewer", taskSummary: "New", completedAt: 1, sessionPath: "/tmp/new.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/new.jsonl" } },
 				],
 				turnId: 1,
 			});
@@ -99,6 +100,69 @@ describe("goal mission continuation", () => {
 		}
 	});
 
+	it("resumes a mission-linked child older than ten unrelated children", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Continue linked work",
+				objective: "Resume the linked worker",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			updateMission(test.location, mission.id, { addRuns: [{ runId: "workflow-mission", mode: "workflow", status: "complete" }] });
+			const retainedChildren: RetainedChild[] = [
+				...Array.from({ length: 10 }, (_, offset) => {
+					const index = 10 - offset;
+					return { runId: `child-${index}`, parentRunId: `workflow-unrelated-${index}`, state: "complete" as const, agent: "worker", taskSummary: "Unrelated", completedAt: index, resumability: { state: "resumable" as const, sessionPath: `/tmp/child-${index}.jsonl` } };
+				}),
+				{ runId: "child-0", parentRunId: "workflow-mission", state: "complete", agent: "worker", taskSummary: "Linked", completedAt: 0, resumability: { state: "resumable", sessionPath: "/tmp/child-0.jsonl" } },
+			];
+			const notices = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren,
+				turnId: 1,
+			});
+
+			assert.equal(retainedChildren.length, 11);
+			assert.equal(notices.length, 1);
+			assert.match(notices[0]!.message, /Resume retained child child-0 \(worker\)/);
+			assert.doesNotMatch(notices[0]!.message, /child-10/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not resume non-resumable retained children from goal notices", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Ship auth refresh",
+				objective: "Implement and validate token refresh",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			updateMission(test.location, mission.id, { addRuns: [{ runId: "workflow-stopped", mode: "workflow", status: "complete" }] });
+
+			const notices = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren: [{ runId: "child-stopped", parentRunId: "workflow-stopped", state: "stopped", agent: "worker", taskSummary: "Stopped", completedAt: 1, resumability: { state: "not-resumable", reason: "stopped run" } }],
+				turnId: 1,
+			});
+
+			assert.equal(notices.length, 1);
+			assert.doesNotMatch(notices[0]!.message, /Resume retained child/);
+			assert.match(notices[0]!.message, /Next ready action: Continue objective: Implement and validate token refresh/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
 	it("supports pause, resume, and opt-out through mission.update", () => {
 		const test = fixture();
 		try {

package/dist/extensions/pi-subagents/test/unit/mission-lifecycle.test.ts

@@ -17,7 +17,7 @@ function projectFixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-mission-lifecycle-"));
 	const projectRoot = path.join(root, "project");
 	fs.mkdirSync(projectRoot, { recursive: true });
-	return { root, projectRoot, missionConfig: { globalIndexDir: path.join(root, "global-index") } };
+	return { root, projectRoot, missionConfig: { directory: ".pi-subagents/missions", globalIndexDir: path.join(root, "global-index") } };
 }
 
 describe("mission launch lifecycle", () => {

package/dist/extensions/pi-subagents/test/unit/mission-store.test.ts

@@ -34,6 +34,20 @@ async function waitForFile(filePath: string, timeoutMs = 10_000): Promise<void>
 }
 
 describe("mission store", () => {
+	it("stores default missions outside the project and preserves configured project storage", () => {
+		const test = fixture();
+		try {
+			assert.equal(path.relative(test.projectRoot, test.location.missionDir).startsWith(".."), true);
+			assert.equal(test.location.missionDir.startsWith(path.join(test.agentDir, "missions", "projects")), true);
+			assert.equal(
+				resolveMissionStoreLocation({ projectRoot: test.projectRoot, agentDir: test.agentDir, config: { directory: ".pi/subagents/missions" } }).missionDir,
+				path.join(test.projectRoot, ".pi/subagents", "missions"),
+			);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
 	it("creates, reads, updates, lists, and globally indexes project missions", () => {
 		const test = fixture();
 		try {

package/dist/extensions/pi-subagents/test/unit/model-fallback.test.ts

@@ -68,6 +68,13 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("rejects fallback models that the active registry cannot resolve", () => {
+		assert.throws(
+			() => buildModelCandidates("gpt-5-mini", ["does-not-exist"], availableModels),
+			/Unknown subagent model 'does-not-exist'/,
+		);
+	});
+
 	it("detects retryable provider/model failures", () => {
 		assert.equal(isRetryableModelFailure("rate limit exceeded for provider"), true);
 		assert.equal(isRetryableModelFailure("model unavailable"), true);
@@ -161,6 +168,17 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
+	it("rejects explicit models that the active registry cannot resolve", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride("does-not-exist", parentModel, availableModels),
+			/Unknown subagent model 'does-not-exist'/,
+		);
+		assert.throws(
+			() => resolveSubagentModelOverride("does-not-exist:high", parentModel, availableModels),
+			/Unknown subagent model 'does-not-exist:high'/,
+		);
+	});
+
 	it("returns undefined when inheriting but no parent model is known", () => {
 		// No parent session model available: fall back to the prior behavior of
 		// emitting no override rather than inventing an invalid one.

package/dist/extensions/pi-subagents/test/unit/native-supervisor-channel.test.ts

@@ -150,7 +150,7 @@ describe("native supervisor channel", () => {
 		channel.start();
 		channel.dispose();
 
-		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME, "intercom"]);
+		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME]);
 		assert.deepEqual(sent.map(({ message }) => message.details?.id), [matchingId]);
 		assert.deepEqual(sent[0]?.options, { triggerTurn: true });
 		assert.equal(channel.pending.has(matchingId), false, "disposed channel clears pending requests");
@@ -553,7 +553,7 @@ describe("native supervisor channel", () => {
 				registeredTools.set(tool.name, tool);
 			},
 		};
-		registerNativeSupervisorClient(pi as never, { includeIntercomFallback: false });
+		registerNativeSupervisorClient(pi as never);
 		const controller = new AbortController();
 		controller.abort();
 

package/dist/extensions/pi-subagents/test/unit/nested-events.test.ts

@@ -39,9 +39,23 @@ const savedEnv = {
 	[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV],
 };
 
-afterEach(() => {
+async function removeDirWithRetry(dir: string): Promise<void> {
+	let lastError: unknown;
+	for (let attempt = 0; attempt < 5; attempt++) {
+		try {
+			fs.rmSync(dir, { recursive: true, force: true });
+			return;
+		} catch (error) {
+			lastError = error;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+	}
+	throw lastError;
+}
+
+afterEach(async () => {
 	for (const route of routes.splice(0)) {
-		fs.rmSync(path.dirname(route.eventSink), { recursive: true, force: true });
+		await removeDirWithRetry(path.dirname(route.eventSink));
 	}
 	for (const [key, value] of Object.entries(savedEnv)) {
 		if (value === undefined) delete process.env[key];
@@ -97,6 +111,15 @@ describe("nested route index", () => {
 		const tokens = new Set([first.capabilityToken, second.capabilityToken]);
 		assert.ok(tokens.has(indexed.capabilityToken), "indexed route must be one of the two created routes");
 	});
+
+	it("recovers a route from its index when the route file is missing", () => {
+		const route = trackRoute("late-route-root");
+		const routeFile = path.join(path.dirname(route.eventSink), "route.json");
+		fs.rmSync(routeFile);
+
+		assert.equal(buildNestedRouteIndex().get("late-route-root")?.capabilityToken, route.capabilityToken);
+		assert.equal(JSON.parse(fs.readFileSync(routeFile, "utf-8")).capabilityToken, route.capabilityToken);
+	});
 });
 
 describe("nested event route validation", () => {

package/dist/extensions/pi-subagents/test/unit/node-executable.test.ts

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { resolveNodeExecutable } from "../../src/shared/node-executable.ts";
+
+describe("Node executable resolution", () => {
+	it("uses an executable Node path", () => {
+		assert.equal(resolveNodeExecutable(process.execPath), process.execPath);
+	});
+
+	it("falls back to PATH node for a standalone Pi executable", () => {
+		assert.equal(resolveNodeExecutable(path.join(os.tmpdir(), process.platform === "win32" ? "pi.exe" : "pi")), process.platform === "win32" ? "node.exe" : "node");
+	});
+
+	it("falls back to PATH node for a stale Node path", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-node-executable-"));
+		try {
+			const staleNode = path.join(root, process.platform === "win32" ? "node.exe" : "node");
+			assert.equal(resolveNodeExecutable(staleNode), process.platform === "win32" ? "node.exe" : "node");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/notify.test.ts

@@ -134,6 +134,14 @@ describe("registerSubagentNotify", () => {
 		});
 	});
 
+	it("does not attach async status snapshots to subagent-notify details", async () => {
+		const { notifier, sent } = createPi("session-a");
+		assert.equal(await notifier.deliver(completionResult({ id: "direct-no-snapshot" })), true);
+		const message = sent[0]?.message as { customType?: string; details?: Record<string, unknown> } | undefined;
+		assert.equal(message?.customType, "subagent-notify");
+		assert.equal(message?.details?.asyncSnapshot, undefined);
+	});
+
 	it("acknowledges direct delivery only after sendMessage accepts it", async () => {
 		const { notifier, sent } = createPi("session-a");
 		assert.equal(await notifier.deliver(completionResult({ id: "direct-accepted" })), true);