@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/pi-subagents/test/integration/single-execution.test.ts

@@ -38,6 +38,8 @@ import {
 } from "../../src/api/delegation.ts";
 import { CHAIN_RUNS_DIR, DIRS, INTERCOM_DETACH_REQUEST_EVENT, INTERCOM_DETACH_RESPONSE_EVENT, type AsyncStatus, type SubagentState } from "../../src/shared/types.ts";
 import { ACTIVE_RUN_INDEX_DIR } from "../../src/runs/background/active-run-index.ts";
+import { resolveMissionStoreLocation } from "../../src/missions/store.ts";
+import { missionStatePath } from "../../src/missions/workflow-state.ts";
 import { CHILD_WATCHDOG_STATUS_EVENT } from "../../src/watchdog/child-status.ts";
 import { WAIT_TOOL_ENABLED_ENV } from "../../src/runs/background/wait-config.ts";
 import { TOOL_BUDGET_ENV, TOOL_BUDGET_ZERO_AUTH_ENV } from "../../src/runs/shared/tool-budget.ts";
@@ -656,7 +658,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		const activityDeadline = Date.now() + 5_000;
 		while (Date.now() < activityDeadline && !fs.existsSync(resultPath)) {
 			const candidate = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatus;
-			if (candidate.activityState === "active_long_running" && candidate.steps?.[0]?.currentTool === "read") {
+			if (candidate.activityState === "needs_attention" && candidate.steps?.[0]?.currentTool === "read") {
 				liveStatus = candidate;
 				break;
 			}
@@ -664,7 +666,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		}
 
 		assert.ok(liveStatus, "expected workflow status to expose live child activity");
-		assert.equal(liveStatus.activityState, "active_long_running");
+		assert.equal(liveStatus.activityState, "needs_attention");
 		assert.equal(typeof liveStatus.lastActivityAt, "number");
 		assert.equal(liveStatus.currentTool, "read");
 		assert.match(liveStatus.currentPath ?? "", /src[/\\]example\.ts$/);
@@ -673,10 +675,10 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(liveStatus.steps?.[0]?.agent, "echo");
 		assert.match(liveStatus.steps?.[0]?.sessionFile ?? "", /session\.jsonl$/);
 		assert.equal(fs.existsSync(liveStatus.steps?.[0]?.sessionFile ?? ""), true);
-		assert.equal(liveStatus.steps?.[0]?.activityState, "active_long_running");
+		assert.equal(liveStatus.steps?.[0]?.activityState, "needs_attention");
 		assert.equal(typeof liveStatus.steps?.[0]?.lastActivityAt, "number");
 		assert.equal(liveStatus.steps?.[0]?.toolCount, 1);
-		assert.equal(asyncJobs.get(workflowRunId)?.activityState, "active_long_running");
+		assert.equal(asyncJobs.get(workflowRunId)?.activityState, "needs_attention");
 		assert.equal(asyncJobs.get(workflowRunId)?.steps?.[0]?.currentTool, "read");
 
 		const completionDeadline = Date.now() + 5_000;
@@ -913,39 +915,58 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		fs.rmSync(asyncDir, { recursive: true, force: true });
 	});
 
-	it("routes workflow children through one automatic mission", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+	it("keeps a git worktree clean while routing workflow children through one automatic mission", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		mockPi.onCall({ output: "scanned auth" });
 		mockPi.onCall({ output: "reviewed auth" });
-		const executor = makeExecutor([makeAgent("echo")], { missions: { globalIndex: false } });
-
-		const result = await executor.execute(
-			"scripted-workflow",
-			{
-				async: false,
-				workflowScript: `
-					const stateType = typeof state;
-					const scan = await runs.run("scan", { agent: "echo", task: "Scan auth" });
-					const review = await runs.run("review", { agent: "echo", task: "Review: " + scan.output });
-					return { output: review.output, stateType };
-				`,
-			},
-			new AbortController().signal,
-			undefined,
-			makeMinimalCtx(tempDir),
-		);
+		const projectDir = path.join(tempDir, "project");
+		const agentDir = path.join(tempDir, "agent");
+		fs.mkdirSync(projectDir);
+		execFileSync("git", ["init"], { cwd: projectDir, stdio: "ignore" });
+		execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: projectDir });
+		execFileSync("git", ["config", "user.name", "Test User"], { cwd: projectDir });
+		fs.writeFileSync(path.join(projectDir, "base.txt"), "base\n", "utf-8");
+		execFileSync("git", ["add", "base.txt"], { cwd: projectDir });
+		execFileSync("git", ["commit", "-m", "base"], { cwd: projectDir, stdio: "ignore" });
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		try {
+			const executor = makeExecutor([makeAgent("echo")], { missions: { globalIndex: false } });
+			const result = await executor.execute(
+				"scripted-workflow",
+				{
+					async: false,
+					workflowScript: `
+						const stateType = typeof state;
+						const scan = await runs.run("scan", { agent: "echo", task: "Scan auth" });
+						const review = await runs.run("review", { agent: "echo", task: "Review: " + scan.output });
+						return { output: review.output, stateType };
+					`,
+				},
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(projectDir),
+			);
 
-		assert.equal(result.isError, undefined);
-		assert.match(result.content[0]?.text ?? "", /reviewed auth/);
-		assert.equal(result.details.mode, "workflow");
-		assert.equal(result.details.results.length, 2);
-		assert.equal(result.details.workflow?.value && (result.details.workflow.value as { stateType?: unknown }).stateType, "object");
-		assert.ok(result.details.missionId);
-		const missionDir = path.join(tempDir, ".pi-subagents", "missions");
-		const missionFiles = fs.readdirSync(missionDir).filter((entry) => entry.endsWith(".json"));
-		assert.equal(missionFiles.length, 1);
-		const mission = JSON.parse(fs.readFileSync(path.join(missionDir, missionFiles[0]!), "utf-8")) as { objective?: string };
-		assert.equal(mission.objective, utils.PROMPT_REDACTED);
-		assert.deepEqual(result.details.workflow?.trace.filter((entry) => entry.state === "completed").map((entry) => entry.key), ["scan", "review"]);
+			assert.equal(result.isError, undefined);
+			assert.match(result.content[0]?.text ?? "", /reviewed auth/);
+			assert.equal(result.details.mode, "workflow");
+			assert.equal(result.details.results.length, 2);
+			assert.equal(result.details.workflow?.value && (result.details.workflow.value as { stateType?: unknown }).stateType, "object");
+			assert.ok(result.details.missionId);
+			const missionFiles = fs.readdirSync(path.join(agentDir, "missions", "projects"), { recursive: true })
+				.filter((entry) => typeof entry === "string" && entry.endsWith(".json"));
+			assert.equal(missionFiles.length, 1);
+			const mission = JSON.parse(fs.readFileSync(path.join(agentDir, "missions", "projects", missionFiles[0]!), "utf-8")) as { objective?: string };
+			assert.equal(mission.objective, utils.PROMPT_REDACTED);
+			assert.deepEqual(result.details.workflow?.trace.filter((entry) => entry.state === "completed").map((entry) => entry.key), ["scan", "review"]);
+			// Selesai fork: artifactDir defaults to "project" (.pi-subagents), so the
+			// tree keeps untracked runtime state; only that dir may appear.
+			const porcelain = execFileSync("git", ["status", "--porcelain"], { cwd: projectDir, encoding: "utf-8" });
+			assert.match(porcelain, /^\?\? \.pi-subagents\/\n$/);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		}
 	});
 
 	it("keeps workflow children mission-detached when automatic mission persistence fails", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
@@ -953,7 +974,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		mockPi.onCall({ output: "reviewed auth" });
 		const blockedIndex = path.join(tempDir, "blocked-mission-index");
 		fs.writeFileSync(blockedIndex, "not a directory", "utf-8");
-		const executor = makeExecutor([makeAgent("echo")], { missions: { globalIndexDir: blockedIndex } });
+		const executor = makeExecutor([makeAgent("echo")], { missions: { directory: ".pi/subagents/missions", globalIndexDir: blockedIndex } });
 
 		const result = await executor.execute(
 			"scripted-workflow-mission-warning",
@@ -974,50 +995,62 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(result.details.missionId, undefined);
 		assert.match(result.details.missionWarning ?? "", /Mission tracking unavailable/);
 		assert.equal(result.details.results.length, 2);
-		const missionDir = path.join(tempDir, ".pi-subagents", "missions");
+		const missionDir = path.join(tempDir, ".pi/subagents", "missions");
 		const missionFiles = fs.existsSync(missionDir) ? fs.readdirSync(missionDir).filter((entry) => entry.endsWith(".json")) : [];
 		assert.equal(missionFiles.length, 1);
 	});
 
 	it("shares durable workflow state across a mission and omits it for mission:false", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
-		const executor = makeExecutor([makeAgent("echo")], { missions: { globalIndex: false } });
-		const first = await executor.execute(
-			"mission-state-first",
-			{
-				async: false,
-				mission: { title: "Stateful workflow" },
-				workflowScript: `await state.set("review.stage", { count: 1 }); return await state.get("review.stage");`,
-			},
-			new AbortController().signal,
-			undefined,
-			makeMinimalCtx(tempDir),
-		);
-		assert.equal(first.isError, undefined, first.content[0]?.text ?? "first workflow failed");
-		assert.ok(first.details.missionId);
-		assert.deepEqual(first.details.workflow?.value, { count: 1 });
-		const statePath = path.join(tempDir, ".pi-subagents", "missions", first.details.missionId, "state.json");
-		assert.equal(fs.existsSync(statePath), true);
-
-		const second = await executor.execute(
-			"mission-state-second",
-			{ async: false, missionId: first.details.missionId, workflowScript: `return await state.get("review.stage");` },
-			new AbortController().signal,
-			undefined,
-			makeMinimalCtx(tempDir),
-		);
-		assert.equal(second.isError, undefined, second.content[0]?.text ?? "second workflow failed");
-		assert.deepEqual(second.details.workflow?.value, { count: 1 });
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const projectDir = path.join(tempDir, "project");
+		const agentDir = path.join(tempDir, "agent");
+		fs.mkdirSync(projectDir);
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		try {
+			const executor = makeExecutor([makeAgent("echo")], { missions: { globalIndex: false } });
+			const first = await executor.execute(
+				"mission-state-first",
+				{
+					async: false,
+					mission: { title: "Stateful workflow" },
+					workflowScript: `await state.set("review.stage", { count: 1 }); return await state.get("review.stage");`,
+				},
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(projectDir),
+			);
+			assert.equal(first.isError, undefined, first.content[0]?.text ?? "first workflow failed");
+			assert.ok(first.details.missionId);
+			assert.deepEqual(first.details.workflow?.value, { count: 1 });
+			const location = resolveMissionStoreLocation({ projectRoot: projectDir, agentDir });
+			const statePath = missionStatePath(location, first.details.missionId);
+			assert.equal(fs.existsSync(statePath), true);
+			assert.equal(path.relative(projectDir, statePath).startsWith(".."), true);
+
+			const second = await executor.execute(
+				"mission-state-second",
+				{ async: false, missionId: first.details.missionId, workflowScript: `return await state.get("review.stage");` },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(projectDir),
+			);
+			assert.equal(second.isError, undefined, second.content[0]?.text ?? "second workflow failed");
+			assert.deepEqual(second.details.workflow?.value, { count: 1 });
 
-		const ephemeral = await executor.execute(
-			"mission-state-off",
-			{ async: false, mission: false, workflowScript: `return typeof state;` },
-			new AbortController().signal,
-			undefined,
-			makeMinimalCtx(tempDir),
-		);
-		assert.equal(ephemeral.isError, undefined, ephemeral.content[0]?.text ?? "ephemeral workflow failed");
-		assert.equal(ephemeral.details.workflow?.value, "undefined");
-		assert.equal(ephemeral.details.missionId, undefined);
+			const ephemeral = await executor.execute(
+				"mission-state-off",
+				{ async: false, mission: false, workflowScript: `return typeof state;` },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(projectDir),
+			);
+			assert.equal(ephemeral.isError, undefined, ephemeral.content[0]?.text ?? "ephemeral workflow failed");
+			assert.equal(ephemeral.details.workflow?.value, "undefined");
+			assert.equal(ephemeral.details.missionId, undefined);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		}
 	});
 
 	it("runs a direct single child in a managed worktree", { skip: !createSubagentExecutor || process.platform === "win32" ? "executor unavailable or worktree paths differ on Windows" : undefined }, async () => {
@@ -1356,7 +1389,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 
 		assert.equal(detachAccepted, true);
 		assert.equal(result.isError, undefined, result.content[0]?.text ?? "workflow failed");
-		assert.match(result.content[0]?.text ?? "", /run detaches: failed/);
+		assert.match(result.content[0]?.text ?? "", /run detaches: detached/);
 		const workflowValue = result.details.workflow?.value as Array<{ ok: boolean; artifactPaths: string[] }>;
 		assert.equal(workflowValue[0]?.ok, false);
 		const handoffPath = workflowValue[0]?.artifactPaths.find((candidate) => candidate.endsWith(".json"));
@@ -2668,7 +2701,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 
 		const result = await runSync(tempDir, agents, "echo", "Investigate behavior", {
 			runId: "run-active",
-			controlConfig: { enabled: true, activeNoticeAfterTurns: 2, activeNoticeAfterMs: 999_999, activeNoticeAfterTokens: 999_999, notifyOn: ["active_long_running", "needs_attention"] },
+			controlConfig: { enabled: true, activeNoticeAfterTurns: 2, activeNoticeAfterMs: 999_999, activeNoticeAfterTokens: 999_999, notifyOn: ["active_long_running", "active_long_running"] },
 			onControlEvent: (event: NonNullable<RunSyncResult["controlEvents"]>[number]) => controlEvents.push(event),
 		});
 
@@ -2725,7 +2758,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 
 		const result = await runSync(tempDir, agents, "echo", "Investigate behavior", {
 			runId: "run-control-disabled",
-			controlConfig: { enabled: false, activeNoticeAfterTurns: 1, activeNoticeAfterMs: 1, activeNoticeAfterTokens: 1, notifyOn: ["active_long_running", "needs_attention"] },
+			controlConfig: { enabled: false, activeNoticeAfterTurns: 1, activeNoticeAfterMs: 1, activeNoticeAfterTokens: 1, notifyOn: ["active_long_running", "active_long_running"] },
 			onControlEvent: (event: NonNullable<RunSyncResult["controlEvents"]>[number]) => controlEvents.push(event),
 		});
 
@@ -3451,14 +3484,14 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 
 		const result = await runSync(tempDir, makeAgentConfigs(["echo"]), "echo", "Task", {
 			runId: "delayed-tool-attention",
-			controlConfig: { enabled: true, needsAttentionAfterMs: 200, activeNoticeAfterMs: 999_999, notifyOn: ["needs_attention"] },
+			controlConfig: { enabled: true, needsAttentionAfterMs: 200, activeNoticeAfterMs: 999_999, notifyOn: ["active_long_running"] },
 			onUpdate: (update: { details?: { progress?: ProgressSummary[] } }) => updates.push(update),
 			onControlEvent: (event: NonNullable<RunSyncResult["controlEvents"]>[number]) => controlEvents.push(event),
 		});
 
 		assert.equal(result.exitCode, 0);
 		assert.equal(result.progress.activityState, undefined);
-		assert.equal(controlEvents.some((event) => event.type === "needs_attention"), false);
+		assert.equal(controlEvents.some((event) => event.type === "active_long_running"), false);
 		assert.equal(updates.some((update) => update.details?.progress?.some((progress) => progress.currentTool === "bash")), true);
 	});
 

package/dist/extensions/pi-subagents/test/integration/slash-commands.test.ts

@@ -46,6 +46,7 @@ interface RegisterSlashCommandsModule {
 			watcherRestartTimer: ReturnType<typeof setTimeout> | null;
 			resultFileCoalescer: { schedule(file: string, delayMs?: number): boolean; clear(): void };
 		},
+		options?: { foregroundDetachShortcut?: string },
 	) => void;
 }
 
@@ -480,6 +481,52 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		clearSlashSnapshots?.();
 	});
 
+	it("registers a configured foreground detach shortcut", async () => {
+		const shortcuts = new Map<string, { handler(ctx: unknown): Promise<void> }>();
+		const sent: unknown[] = [];
+		const state = createState(process.cwd());
+		let detachCalls = 0;
+		state.foregroundControls.set("run-123", {
+			runId: "run-123",
+			mode: "single",
+			updatedAt: Date.now(),
+			detach: () => {
+				detachCalls += 1;
+				return true;
+			},
+		});
+		state.lastForegroundControlId = "run-123";
+
+		registerSlashCommands!({
+			events: createEventBus(),
+			on() {},
+			on() {},
+			registerCommand() {},
+			registerShortcut(key: string, spec: { handler(ctx: unknown): Promise<void> }) {
+				shortcuts.set(key, spec);
+			},
+			sendMessage(message: unknown) { sent.push(message); },
+		}, state, { foregroundDetachShortcut: "ctrl+b" });
+
+		assert.ok(shortcuts.has("ctrl+b"));
+		await shortcuts.get("ctrl+b")!.handler(createCommandContext());
+		assert.equal(detachCalls, 1);
+		assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Detached foreground run run-123/);
+	});
+
+	it("does not reserve a foreground detach shortcut by default", () => {
+		const shortcuts = new Map<string, unknown>();
+		registerSlashCommands!({
+			events: createEventBus(),
+			on() {},
+			on() {},
+			registerCommand() {},
+			registerShortcut(key: string, spec: unknown) { shortcuts.set(key, spec); },
+			sendMessage() {},
+		}, createState(process.cwd()));
+		assert.equal(shortcuts.has("ctrl+b"), false);
+	});
+
 	it("/subagents-stop keeps the selector within its allocated width", async () => {
 		await withTempProject("pi-stop-selector-width-", async (root) => {
 			const id = "scheduled-width-check";
@@ -589,7 +636,7 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		assert.equal(requestedCtx, ctx);
 		assert.equal(sent.length, 2);
 		assert.equal((sent[0] as { display?: boolean }).display, true);
-		assert.equal((sent[0] as { content?: string }).content, "Running subagent...");
+		assert.equal((sent[0] as { content?: string }).content, "Workflow running.");
 		assert.equal((sent[1] as { display?: boolean }).display, true);
 		assert.match((sent[1] as { content?: string }).content ?? "", /Commit finished/);
 		assert.equal(sessionManager.rewrites, 2);
@@ -636,6 +683,7 @@ Inspect
 		const pi = {
 			events,
 			on() {},
+			on() {},
 			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
 				commands.set(name, spec);
 			},

package/dist/extensions/pi-subagents/test/integration/slash-live-state.test.ts

@@ -63,6 +63,18 @@ describe("slash live state", { skip: !available ? "slash-live-state.ts not impor
 		assert.equal(snapshot.version > 0, true);
 	});
 
+	it("marks async initial slash snapshots as background", () => {
+		clearSlashSnapshots!();
+		const details = buildSlashInitialResult!("req-bg", {
+			workflowScript: "return runs.run(\"run\", { agent: \"scout\", task: \"inspect\" })",
+			async: true,
+		});
+
+		assert.equal(details.result.details.mode, "workflow");
+		assert.equal(details.result.details.background, true);
+		assert.equal(details.result.details.asyncId, undefined);
+	});
+
 	it("does not assign a parallel child update to another chain placeholder", () => {
 		clearSlashSnapshots!();
 		const details = buildSlashInitialResult!("req-parallel", {

package/dist/extensions/pi-subagents/test/support/node-command.ts

@@ -0,0 +1,15 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function writeNodeCommand(directory: string, name: string, source: string): string {
+	if (process.platform === "win32") {
+		const scriptPath = path.join(directory, `${name}.cjs`);
+		const commandPath = path.join(directory, `${name}.cmd`);
+		fs.writeFileSync(scriptPath, source, "utf-8");
+		fs.writeFileSync(commandPath, `@echo off\r\n"${process.execPath}" "${scriptPath}" %*\r\n`, "utf-8");
+		return commandPath;
+	}
+	const commandPath = path.join(directory, name);
+	fs.writeFileSync(commandPath, `#!/usr/bin/env node\n${source}\n`, { encoding: "utf-8", mode: 0o755 });
+	return commandPath;
+}

package/dist/extensions/pi-subagents/test/unit/active-async-capacity.test.ts

@@ -7,6 +7,7 @@ import {
 	acquireActiveAsyncCapacity,
 	ActiveAsyncCapacityError,
 	getActiveAsyncCapacitySnapshot,
+	inspectActiveAsyncCapacityOwner,
 	transferActiveAsyncCapacity,
 } from "../../src/runs/background/active-async-capacity.ts";
 
@@ -104,6 +105,32 @@ describe("active async capacity", () => {
 		}
 	});
 
+	it("explains runner release verdicts without mutating slots", () => {
+		const rootDir = tempRoot();
+		const asyncDir = path.join(rootDir, "runs", "run-a");
+		try {
+			const handle = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 2, runId: "run-a", kind: "runner", asyncDir }, { rootDir });
+			assert.ok(handle);
+			handle.markStarted("runner-a");
+			writeJson(path.join(asyncDir, "status.json"), { runId: "run-a", sessionId: "session-a", mode: "single", state: "complete", startedAt: 100, processTerminal: { version: 1, state: "unknown", runId: "run-a", runnerProcessInstanceId: "runner-a", reason: "process-tree-unverified" } });
+
+			const retained = inspectActiveAsyncCapacityOwner({ runId: "run-a", sessionId: "session-a", asyncDir }, { rootDir });
+
+			assert.equal(retained.relation, "current");
+			assert.equal(retained.release.state, "retained");
+			assert.match(retained.release.reason, /process-terminal proof is missing/);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 2, { rootDir }), { used: 1, limit: 2 });
+
+			writeJson(path.join(asyncDir, "process-terminal.json"), observedProof("run-a", "runner-a"));
+			const releasable = inspectActiveAsyncCapacityOwner({ runId: "run-a", sessionId: "session-a", asyncDir }, { rootDir });
+			assert.equal(releasable.release.state, "releasable");
+			assert.match(releasable.release.reason, /observed process-terminal proof/);
+			assert.equal(releasable.slotDir ? fs.existsSync(releasable.slotDir) : false, true);
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
 	it("retains active and unknown runner proof, then releases matching observed proof", () => {
 		const rootDir = tempRoot();
 		const asyncDir = path.join(rootDir, "runs", "run-a");
@@ -211,6 +238,29 @@ describe("active async capacity", () => {
 		}
 	});
 
+	it("reports transferred source runs as not owned", () => {
+		const rootDir = tempRoot();
+		const sourceDir = path.join(rootDir, "runs", "source");
+		const nextDir = path.join(rootDir, "runs", "next");
+		try {
+			const source = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "source", kind: "runner", asyncDir: sourceDir }, { rootDir });
+			assert.ok(source);
+			source.markStarted("runner-source");
+			writeJson(path.join(sourceDir, "status.json"), { runId: "source", sessionId: "session-a", mode: "single", state: "paused", startedAt: 100 });
+			const next = transferActiveAsyncCapacity({ sessionId: "session-a", limit: 1, sourceRunId: "source", runId: "next", asyncDir: nextDir }, { rootDir });
+			assert.ok(next);
+
+			const inspection = inspectActiveAsyncCapacityOwner({ runId: "source", sessionId: "session-a", asyncDir: sourceDir }, { rootDir });
+
+			assert.equal(inspection.relation, "source");
+			assert.equal(inspection.owner?.runId, "next");
+			assert.equal(inspection.release.state, "not-owned");
+			assert.match(inspection.release.reason, /transferred to next/);
+		} finally {
+			fs.rmSync(rootDir, { recursive: true, force: true });
+		}
+	});
+
 	it("transfers a paused reservation without changing usage", () => {
 		const rootDir = tempRoot();
 		const sourceDir = path.join(rootDir, "runs", "source");

package/dist/extensions/pi-subagents/test/unit/agent-frontmatter.test.ts

@@ -472,6 +472,13 @@ Do work
 		}
 		const oracle = agents.find((candidate) => candidate.name === "oracle");
 		assert.deepEqual(oracle?.aliases, ["advisor"]);
+		assert.doesNotMatch(oracle?.tools?.join(",") ?? "", /contact_supervisor/);
+		for (const name of ["scout", "researcher", "oracle", "reviewer"]) {
+			assert.equal(agents.find((candidate) => candidate.name === name)?.tools?.includes("intercom"), false, `${name} should not require generic intercom`);
+		}
+		assert.match(oracle?.systemPrompt ?? "", /asking or consulting the oracle/);
+		assert.match(oracle?.systemPrompt ?? "", /When runtime bridge instructions provide `contact_supervisor`/);
+		assert.match(oracle?.systemPrompt ?? "", /If no supervisor channel is available/);
 		assert.equal(agents.some((candidate) => candidate.name === "planner"), false);
 		assert.equal(agents.some((candidate) => candidate.name === "context-builder"), false);
 	});
@@ -493,6 +500,7 @@ describe("agent frontmatter launch defaults", () => {
 			filePath,
 			defaultAsync: false,
 			defaultTimeoutMs: 90_000,
+			defaultToolTimeoutMs: 600_000,
 			defaultTurnBudget: { maxTurns: 12, graceTurns: 2 },
 			defaultAcceptance: { level: "none", reason: "lightweight lookup" },
 		};
@@ -500,6 +508,7 @@ describe("agent frontmatter launch defaults", () => {
 		const serialized = serializeAgent(agent);
 		assert.match(serialized, /^async: false$/m);
 		assert.match(serialized, /^timeoutMs: 90000$/m);
+		assert.match(serialized, /^toolTimeoutMs: 600000$/m);
 		assert.match(serialized, /^turnBudget: \{"maxTurns":12,"graceTurns":2\}$/m);
 		assert.match(serialized, /^acceptance: \{"level":"none","reason":"lightweight lookup"\}$/m);
 		writeAgent(filePath, serialized);
@@ -507,6 +516,7 @@ describe("agent frontmatter launch defaults", () => {
 		const worker = discoverAgents(dir, "project").agents.find((candidate) => candidate.name === "worker");
 		assert.equal(worker?.defaultAsync, false);
 		assert.equal(worker?.defaultTimeoutMs, 90_000);
+		assert.equal(worker?.defaultToolTimeoutMs, 600_000);
 		assert.deepEqual(worker?.defaultTurnBudget, { maxTurns: 12, graceTurns: 2 });
 		assert.deepEqual(worker?.defaultAcceptance, { level: "none", reason: "lightweight lookup" });
 	});
@@ -601,6 +611,24 @@ Do work
 			/Agent 'worker' has invalid async frontmatter; expected true or false/,
 		);
 	});
+
+	it("rejects oversized toolTimeoutMs frontmatter at discovery", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-oversized-tool-timeout-"));
+		tempDirs.push(dir);
+		writeAgent(path.join(dir, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Worker
+toolTimeoutMs: 2147483648
+---
+
+Do work
+`);
+
+		assert.throws(
+			() => discoverAgents(dir, "project"),
+			/Agent 'worker' has invalid toolTimeoutMs frontmatter; expected a positive integer no larger than 2147483647/,
+		);
+	});
 });
 
 describe("chain discovery", () => {

package/dist/extensions/pi-subagents/test/unit/agent-overrides.test.ts

@@ -88,6 +88,67 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer?.modelSource, undefined);
 	});
 
+	it("lets a builtin agent inherit Pi's normal tools from an override", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					researcher: { tools: "inherit" },
+				},
+			},
+		});
+
+		const researcher = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "researcher");
+		assert.equal(researcher?.tools, undefined);
+		assert.equal(researcher?.mcpDirectTools, undefined);
+	});
+
+	it("keeps strict builtin tools unless a role opts into inheritance", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					researcher: { tools: "inherit" },
+				},
+			},
+		});
+
+		const builtins = discoverAgentsAll(tempProject).builtin;
+		assert.equal(builtins.find((agent) => agent.name === "researcher")?.tools, undefined);
+		assert.deepEqual(builtins.find((agent) => agent.name === "reviewer")?.tools, ["read", "grep", "find", "ls"]);
+	});
+
+	it("keeps explicit empty builtin tool allowlists distinct from inherited tools", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					researcher: { tools: [] },
+				},
+			},
+		});
+
+		const researcher = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "researcher");
+		assert.deepEqual(researcher?.tools, []);
+		assert.equal(researcher?.mcpDirectTools, undefined);
+	});
+
+	it("surfaces invalid string tool override settings", () => {
+		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
+		writeJson(settingsPath, {
+			subagents: {
+				agentOverrides: {
+					researcher: { tools: "read" },
+				},
+			},
+		});
+
+		assert.throws(
+			() => discoverAgents(tempProject, "both"),
+			(error: unknown) => error instanceof Error
+				&& error.message.includes(settingsPath)
+				&& error.message.includes("researcher")
+				&& error.message.includes("tools"),
+		);
+	});
+
 	it("clears subagents.defaultModel provenance for same-value agent model overrides", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {

package/dist/extensions/pi-subagents/test/unit/agent-stream-options.test.ts

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { agentStreamOptions } from "../../src/shared/agent-stream-options.ts";
+
+describe("agent stream options", () => {
+	it("supports the Pi 0.81 and 0.84 constructor option names", () => {
+		const streamFn: StreamFn = () => { throw new Error("not called"); };
+		const options = agentStreamOptions(streamFn);
+
+		assert.equal(options.streamFunction, streamFn);
+		assert.equal(options.streamFn, streamFn);
+	});
+});