@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/integration/async-job-tracker.test.ts

@@ -4,12 +4,13 @@ import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { registerExternalJobProvider } from "../../src/api/external-job-provider.ts";
 import { getArtifactsDir } from "../../src/shared/artifacts.ts";
-import { SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_CONTROL_EVENT, type ControlEvent } from "../../src/shared/types.ts";
+import { SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, type ControlEvent } from "../../src/shared/types.ts";
 import { ACTIVE_RUN_INDEX_DIR, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { EXTERNAL_JOB_BRIDGE_REQUEST_DIR } from "../../src/runs/shared/external-job-bridge.ts";
 import { createNativeSupervisorChannel, ensureSupervisorChannelDir, resolveSupervisorChannelDir } from "../../src/intercom/native-supervisor-channel.ts";
 import { SubagentFleetComponent } from "../../src/tui/fleet.ts";
-import { createNestedRoute } from "../../src/runs/shared/nested-events.ts";
+import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import { resolveSubagentRunId } from "../../src/runs/background/run-id-resolver.ts";
 import { createTempDir, removeTempDir, tryImport } from "../support/helpers.ts";
 
 interface AsyncJobTrackerModule {
@@ -170,6 +171,25 @@ function createNativeSupervisorHarness(sessionId: string) {
 	return { channel, tools, sent };
 }
 
+/** Starts a run whose events.jsonl holds one native supervisor attention record. Requires mock timers. */
+function startSupervisorAttentionRun(asyncRoot: string, runId: string, timers: { tick(ms: number): void }) {
+	const runDir = path.join(asyncRoot, runId);
+	writeRunningAsyncStatus(runDir, runId, "session-grace");
+	fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
+		type: "subagent.control",
+		channels: ["event", "intercom"],
+		event: supervisorControlEvent(runId, "call-grace"),
+		intercom: { to: "main", message: "SUBAGENT NEEDS ATTENTION: worker" },
+	})}\n`, "utf-8");
+	let answered = false;
+	const recorder = createEventRecorder();
+	const tracker = createTracker(recorder.pi, createState() as never, asyncRoot, { supervisorRequestState: () => answered ? "resolved" : "pending" });
+	tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker", sessionId: "session-grace" });
+	timers.tick(25); // the tracker's event-refresh debounce
+	assert.deepEqual(recorder.events.map((entry) => [entry.channel, (entry.data as { noticeDeferred?: boolean }).noticeDeferred]), [[SUBAGENT_CONTROL_EVENT, true]], "status consumers see the request immediately, marked deferred");
+	return { tracker, answer: () => { answered = true; }, events: recorder.events };
+}
+
 function pidGone(): never {
 	const error = new Error("missing") as NodeJS.ErrnoException;
 	error.code = "ESRCH";
@@ -197,6 +217,7 @@ function createUiContext() {
 			theme: {
 				fg: (_theme: string, text: string) => text,
 				bold: (text: string) => text,
+				getThinkingBorderColor: (_level: string) => (text: string) => text,
 			},
 			setWidget: (_key: string, value: unknown) => {
 				widgets.push(value);
@@ -291,6 +312,33 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("preserves a workflow job's established session root when attaching its start event", () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-workflow-session-root-");
+		const sessionRoot = createTempDir("pi-explicit-workflow-sessions-");
+		try {
+			const state = createState();
+			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot);
+			const runId = "workflow-established-session-root";
+			const asyncDir = path.join(asyncRoot, runId);
+			state.asyncJobs.set(runId, {
+				asyncId: runId,
+				asyncDir,
+				sessionRoot,
+				status: "running",
+				mode: "workflow",
+				startedAt: 100,
+				updatedAt: 100,
+			});
+
+			tracker.handleStarted({ id: runId, asyncDir, agent: "workflow", mode: "workflow" });
+
+			assert.equal(state.asyncJobs.get(runId)?.sessionRoot, sessionRoot);
+		} finally {
+			removeTempDir(asyncRoot);
+			removeTempDir(sessionRoot);
+		}
+	});
+
 	it("ignores unregistered session roots from async start events", () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-forged-session-root-");
 		try {
@@ -348,6 +396,28 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("retains nested lookup authority after async coordinator widget cleanup without crossing sessions", async () => {
+		const asyncRoot = createTempDir("pi-async-retained-lookup-");
+		const route = createNestedRoute("async-coordinator");
+		try {
+			const state = createState();
+			state.currentSessionId = "owner";
+			writeNestedEvent(route, { type: "subagent.nested.completed", ts: 100, parentRunId: route.rootRunId,
+				child: { id: "async-descendant", parentRunId: route.rootRunId, depth: 1, path: [{ runId: route.rootRunId }], state: "complete", agent: "worker" },
+			});
+			const tracker = createTracker(createEventRecorder().selesai, state, asyncRoot, { completionRetentionMs: 5 });
+			tracker.handleStarted({ id: route.rootRunId, asyncDir: path.join(asyncRoot, route.rootRunId), agent: "worker", sessionId: "owner", nestedRoute: route });
+			tracker.handleComplete({ id: route.rootRunId, success: true, sessionId: "owner" });
+			await waitForCondition(() => !state.asyncJobs.has(route.rootRunId), "coordinator cleanup", 1000);
+			assert.equal(resolveSubagentRunId("async-descendant", { state })?.kind, "nested");
+			state.currentSessionId = "foreign";
+			assert.equal(resolveSubagentRunId("async-descendant", { state }), undefined);
+		} finally {
+			removeTempDir(asyncRoot);
+			fs.rmSync(path.dirname(route.eventSink), { recursive: true, force: true });
+		}
+	});
+
 	it("keeps the async widget cleared when it is disabled", () => {
 		const asyncRoot = createTempDir("pi-async-job-widget-disabled-");
 		try {
@@ -1252,35 +1322,40 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
-	it("schedules cleanup when polling observes a completed status without a completion event", async () => {
+	it("schedules cleanup when polling observes terminal statuses without completion events", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {
-			const runDir = path.join(asyncRoot, "run-2");
-			fs.mkdirSync(runDir, { recursive: true });
-			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
-				runId: "run-2",
-				mode: "single",
-				state: "complete",
-				startedAt: Date.now() - 1000,
-				lastUpdate: Date.now(),
-				steps: [{ agent: "worker", status: "complete" }],
-			}), "utf-8");
-
 			const state = createState();
 			const ui = createUiContext();
-			const recorder = createEventRecorder();
-			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-2", asyncDir: runDir, agent: "worker" });
+			for (const terminalState of ["complete", "partial", "rejected"] as const) {
+				const runId = `run-${terminalState}`;
+				const runDir = path.join(asyncRoot, runId);
+				fs.mkdirSync(runDir, { recursive: true });
+				fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+					runId,
+					mode: "single",
+					state: terminalState,
+					startedAt: Date.now() - 1000,
+					lastUpdate: Date.now(),
+					steps: [{ agent: "worker", status: terminalState }],
+				}), "utf-8");
+				tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker" });
+			}
 
 			await new Promise((resolve) => setTimeout(resolve, 80));
 
 			assert.equal(state.asyncJobs.size, 0);
 			assert.ok(ui.renderRequests > 0, "expected polling cleanup to request a rerender");
 			assert.equal(ui.widgets.at(-1), undefined);
+			assert.equal(state.fleetJobs.get("run-complete")?.status, "complete");
+			assert.equal(state.fleetJobs.get("run-partial")?.status, "partial");
+			assert.equal(state.fleetJobs.get("run-rejected")?.status, "rejected");
+			tracker.resetJobs();
 		} finally {
 			removeTempDir(asyncRoot);
 		}
@@ -1662,6 +1737,47 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("sends no parent notice for a supervisor request answered within the grace period", (t) => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-grace-answered-");
+		t.mock.timers.enable({ apis: ["setTimeout", "setInterval"] });
+		try {
+			const run = startSupervisorAttentionRun(asyncRoot, "run-grace-answered", t.mock.timers);
+			run.answer();
+			t.mock.timers.tick(60_000);
+			assert.equal(run.events.length, 1);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("escalates a supervisor request still unanswered after the grace period once", (t) => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-grace-pending-");
+		t.mock.timers.enable({ apis: ["setTimeout", "setInterval"] });
+		try {
+			const run = startSupervisorAttentionRun(asyncRoot, "run-grace-pending", t.mock.timers);
+			t.mock.timers.tick(59_000);
+			assert.equal(run.events.length, 1);
+			t.mock.timers.tick(1_000);
+			t.mock.timers.tick(120_000);
+			assert.deepEqual(run.events.slice(1).map((entry) => [entry.channel, (entry.data as { noticeDeferred?: boolean }).noticeDeferred]), [[SUBAGENT_CONTROL_EVENT, undefined], [SUBAGENT_CONTROL_INTERCOM_EVENT, undefined]]);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("drops a pending supervisor notice when the run finishes during the grace period", (t) => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-grace-finished-");
+		t.mock.timers.enable({ apis: ["setTimeout", "setInterval"] });
+		try {
+			const run = startSupervisorAttentionRun(asyncRoot, "run-grace-finished", t.mock.timers);
+			run.tracker.handleComplete({ id: "run-grace-finished", success: true });
+			t.mock.timers.tick(60_000);
+			assert.equal(run.events.filter((entry) => entry.channel === SUBAGENT_CONTROL_EVENT || entry.channel === SUBAGENT_CONTROL_INTERCOM_EVENT).length, 1);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("delivers an external intercom ask with the native lifecycle lookup enabled", async () => {
 		const asyncRoot = createTempDir("pi-async-job-supervisor-replay-external-");
 		const sessionId = `session-${Date.now()}`;
@@ -2155,7 +2271,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
-	it("bridges async child status events from events.jsonl to the parent event bus", async () => {
+	it("bridges async child started events from events.jsonl to the parent event bus", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {
 			const runDir = path.join(asyncRoot, "run-child-status");
@@ -2173,9 +2289,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				version: 1,
 				runId: "run-child-status",
 				childId: "slow",
-				status: "stopped",
+				status: "started",
 				ts: 123,
-				reason: "user",
 				stepIndex: 0,
 				agent: "worker",
 				workflowKey: "slow",
@@ -2199,9 +2314,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				version: 1,
 				runId: "run-child-status",
 				childId: "slow",
-				status: "stopped",
+				status: "started",
 				ts: 123,
-				reason: "user",
 				source: "async",
 				asyncDir: runDir,
 				stepIndex: 0,
@@ -2212,4 +2326,53 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			removeTempDir(asyncRoot);
 		}
 	});
+
+	it("continues replay after a child-status subscriber throws", async (t) => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-");
+		try {
+			const runDir = path.join(asyncRoot, "run-throwing-child-status");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-throwing-child-status",
+				mode: "workflow",
+				state: "running",
+				startedAt: Date.now() - 1000,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running", workflowKey: "child" }],
+			}), "utf-8");
+			const childEvent = (status: "started" | "stopped", ts: number) => JSON.stringify({
+				type: "subagent.child-status",
+				version: 1,
+				runId: "run-throwing-child-status",
+				childId: "child",
+				status,
+				ts,
+				workflowKey: "child",
+			});
+			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${childEvent("started", 123)}\n${childEvent("stopped", 124)}\n`, "utf-8");
+
+			let emitAttempts = 0;
+			const delivered: unknown[] = [];
+			const pi = { events: { emit(channel: string, data: unknown) {
+				if (channel !== SUBAGENT_CHILD_STATUS_EVENT) return;
+				emitAttempts += 1;
+				if (emitAttempts === 1) throw new Error("simulated replay subscriber failure");
+				delivered.push(data);
+			} } };
+			const diagnostics: unknown[][] = [];
+			const originalError = console.error;
+			console.error = (...args: unknown[]) => { diagnostics.push(args); };
+			t.after(() => { console.error = originalError; });
+			const tracker = createTracker(pi, createState() as never, asyncRoot, { pollIntervalMs: 10 });
+			tracker.handleStarted({ id: "run-throwing-child-status", asyncDir: runDir, agent: "workflow" });
+
+			await waitForCondition(() => delivered.length === 1, "later child status event");
+			await new Promise((resolve) => setTimeout(resolve, 30));
+			assert.equal(emitAttempts, 2);
+			assert.equal((delivered[0] as { status?: string }).status, "stopped");
+			assert.ok(diagnostics.some(([message]) => message === "Failed to emit async child status event:"));
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/integration/async-status.test.ts

@@ -330,7 +330,7 @@ describe("async status helpers", () => {
 		}
 	});
 
-	it("preserves agent contract projections on step summaries", () => {
+	it("reads legacy mutation-effect fields as inert persisted JSON", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-contract-"));
 		try {
 			createAsyncDir(root, "run-contract", {
@@ -357,6 +357,7 @@ describe("async status helpers", () => {
 			assert.equal(step?.acceptance?.status, "rejected");
 			assert.equal(step?.review?.status, "not-requested");
 			assert.equal(step?.effects?.fileMutation?.status, "missing");
+			assert.equal(step?.execution?.success, true);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -1297,4 +1298,4 @@ describe("async status helpers", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/claude-code-dispatch.test.ts

@@ -0,0 +1,127 @@
+/**
+ * End-to-end dispatch tests for the Claude Code model and thinking override.
+ *
+ * These launch the real background runner against a fake `claude` that records
+ * its argv, so they prove the tokens travel from a launch request to the CLI.
+ * On Windows the fake is an npm-style `.cmd` shim, as an npm install would create.
+ */
+
+import { afterEach, describe, it } from "node:test";
+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 { makeAgent } from "../support/helpers.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
+import {
+	available, executeAsyncChain, executeAsyncSingle, installAsyncExecutionHooks, isAsyncAvailable, tempDir, waitForAsyncResultFile,
+} from "../support/async-execution-fixture.ts";
+import { clearExternalCliPreflightCacheForTests } from "../../src/runs/shared/external-cli-preflight.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+
+const CLAUDE_HELP =
+	"Claude Code - starts an interactive session --print --input-format text --output-format stream-json --verbose --permission-mode plan acceptEdits --tools --strict-mcp-config --mcp-config --setting-sources --no-session-persistence --disable-slash-commands --no-chrome";
+
+const dirs: string[] = [];
+afterEach(() => {
+	clearExternalCliPreflightCacheForTests();
+	for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+/** A fake CLI that records every invocation and answers the adapter's preflight. */
+function fakeClaude(): { command: string; calls: () => string[][] } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-cc-dispatch-"));
+	dirs.push(dir);
+	const evidence = path.join(dir, "argv.jsonl");
+	const command = writeNodeCommand(dir, "claude", `
+const fs = require("node:fs");
+const args = process.argv.slice(2);
+fs.appendFileSync(${JSON.stringify(evidence)}, JSON.stringify(args) + "\\n");
+if (args.length === 1 && args[0] === "--version") { process.stdout.write("2.1.150 (Claude Code)\\n"); process.exit(0); }
+if (args.length === 1 && args[0] === "--help") { process.stdout.write(${JSON.stringify(CLAUDE_HELP)} + "\\n"); process.exit(0); }
+process.stdin.resume();
+process.stdin.on("end", () => {
+	process.stdout.write(JSON.stringify({ type: "result", subtype: "success", is_error: false, result: "ok" }) + "\\n");
+});
+`);
+	return {
+		command,
+		calls: () => fs.existsSync(evidence)
+			? fs.readFileSync(evidence, "utf-8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line) as string[])
+			: [],
+	};
+}
+
+function claudeCodeRunner(command: string): NonNullable<AgentConfig["runner"]> {
+	return { type: "external-cli", adapter: "claude-code", command, promptDelivery: "stdin" };
+}
+
+const artifactConfig = { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 };
+const asyncOnly = { skip: !isAsyncAvailable() ? "jiti not available" : undefined };
+
+describe("Claude Code override launch", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	it("carries a model suffix into --model and --effort through a real launch", asyncOnly, async () => {
+		const claude = fakeClaude();
+		const id = `cc-dispatch-suffix-${Date.now().toString(36)}`;
+		const launched = executeAsyncSingle(id, {
+			agent: "claude-code",
+			task: "Review the handoff",
+			modelOverride: "claude-opus-5.5:high",
+			agentConfig: makeAgent("claude-code", { runner: claudeCodeRunner(claude.command) } as never),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig,
+			shareEnabled: false,
+		});
+		assert.equal(launched.isError, undefined, launched.content[0]?.text ?? "launch failed");
+		await waitForAsyncResultFile(id, 15_000);
+
+		const calls = claude.calls();
+		const launch = calls.filter((args) => args[0] === "-p");
+		assert.equal(launch.length, 1);
+		assert.deepEqual(launch[0]?.slice(-4), ["--model", "claude-opus-5.5", "--effort", "high"]);
+		// The preflight probes stay single-argument: no launch token leaks into them.
+		assert.deepEqual(calls.filter((args) => args[0] === "--version" || args[0] === "--help"), [["--version"], ["--help"]]);
+	});
+
+	it("gives each chain step and each parallel item its own flags", asyncOnly, async () => {
+		const claude = fakeClaude();
+		const id = `cc-dispatch-chain-${Date.now().toString(36)}`;
+		const launched = executeAsyncChain(id, {
+			chain: [
+				{ agent: "claude-code", task: "First", model: "sonnet:low" },
+				{ parallel: [{ agent: "claude-code", task: "Second", model: "haiku:xhigh" }] },
+			],
+			agents: [makeAgent("claude-code", { runner: claudeCodeRunner(claude.command) } as never)],
+			resultMode: "chain",
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig,
+			shareEnabled: false,
+			acceptance: false,
+		});
+		assert.equal(launched.isError, undefined, launched.content[0]?.text ?? "launch failed");
+		await waitForAsyncResultFile(id, 20_000);
+
+		const launch = claude.calls().filter((args) => args[0] === "-p");
+		assert.equal(launch.length, 2);
+		assert.deepEqual(launch[0]?.slice(-4), ["--model", "sonnet", "--effort", "low"]);
+		assert.deepEqual(launch[1]?.slice(-4), ["--model", "haiku", "--effort", "xhigh"]);
+	});
+
+	it("rejects an effort above maxThinking before the CLI runs", asyncOnly, () => {
+		const claude = fakeClaude();
+		const launched = executeAsyncSingle(`cc-dispatch-ceiling-${Date.now().toString(36)}`, {
+			agent: "claude-code",
+			task: "Review the handoff",
+			modelOverride: "sonnet:max",
+			agentConfig: makeAgent("claude-code", { maxThinking: "low", runner: claudeCodeRunner(claude.command) } as never),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig,
+			shareEnabled: false,
+		});
+		assert.equal(launched.isError, true);
+		assert.match(launched.content[0]?.text ?? "", /Thinking level 'max' exceeds configured maximum 'low'/);
+		assert.deepEqual(claude.calls(), []);
+	});
+});

package/dist/extensions/pi-subagents/test/integration/deadline-checkpoint.test.ts

@@ -0,0 +1,126 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { events, makeAgent, makeMinimalCtx } from "../support/helpers.ts";
+import type { AsyncStatusPayload } from "../support/async-execution-fixture.ts";
+import {
+	installAsyncExecutionHooks, available, isAsyncAvailable, createSubagentExecutor,
+	ASYNC_DIR, tempDir, mockPi, makeAsyncExecutor, readAsyncPayload,
+	waitForAsyncState, waitForAsyncResultFile,
+} from "../support/async-execution-fixture.ts";
+
+type CheckpointStatus = AsyncStatusPayload & {
+	steering?: { recent: Array<{ id: string; source?: string; targets: Array<{ state: string }> }> };
+};
+
+function checkpoint(status: AsyncStatusPayload) {
+	return (status as CheckpointStatus).steering?.recent.find((request) => request.source === "deadline-checkpoint");
+}
+
+function journal(id: string): Array<{ type: string; requestId?: string; source?: string }> {
+	return fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+}
+
+describe("async single-agent deadline checkpoint lifecycle", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	for (const outcome of ["handoff", "timeout"] as const) {
+		it(`propagates ${outcome === "handoff" ? "call override" : "config default"} through the executor and runner: ${outcome}`, {
+			skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined,
+			timeout: 30_000,
+		}, async () => {
+			const release = path.join(tempDir, "checkpoint-release");
+			mockPi.onCall({
+				...(outcome === "handoff"
+					? { queuedInputReleasePath: release }
+					: { steps: [{ waitForPath: release, jsonl: [events.assistantMessage("current work complete")] }] }),
+				queuedMessageOutput: "Checkpoint handoff: changed files, tests, remaining work, commit state.",
+			});
+			// The overridden default would disarm the checkpoint entirely if call precedence broke.
+			const executor = makeAsyncExecutor([makeAgent("worker")], {
+				checkpointBeforeDeadlineMs: outcome === "handoff" ? 20_000 : 5_000,
+			});
+			const result = await executor.execute(`checkpoint-${outcome}`, {
+				agent: "worker", task: "Explore the repository", async: true, clarify: false,
+				timeoutMs: 10_000,
+				...(outcome === "handoff" ? { checkpointBeforeDeadlineMs: 5_000 } : {}),
+			}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			const id = result.details?.asyncId;
+			assert.ok(id, "expected an async launch");
+			const queued = await waitForAsyncState(id, (status) => checkpoint(status)?.targets[0]?.state === "queued");
+			assert.equal(queued.state, "running");
+			const request = checkpoint(queued)!;
+			const steers = fs.readFileSync(path.join(mockPi.dir, "steers.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.equal(steers.length, 1);
+			assert.equal(steers[0].mode, "steer");
+			assert.match(steers[0].text, /Deadline checkpoint from the runner/);
+			assert.match(steers[0].text, /Finish the current tool call only/);
+			assert.match(steers[0].text, /changed files, build\/test state, remaining work, and commit\/PR state/);
+			// Consume only after the runner has acknowledged the queued request. No
+			// assistant or terminal event precedes this synchronized boundary.
+			if (outcome === "handoff") fs.writeFileSync(release, "continue");
+			await waitForAsyncResultFile(id, 15_000);
+			const payload = await readAsyncPayload(id);
+			const terminal = await waitForAsyncState(id, (status) => status.state !== "running");
+			if (outcome === "handoff") {
+				assert.equal(payload.success, true, payload.error);
+				assert.match(payload.results[0]?.output ?? "", /^Checkpoint handoff:/);
+				assert.notEqual(payload.timedOut, true);
+				assert.equal(checkpoint(terminal)?.targets[0]?.state, "delivered");
+			} else {
+				assert.equal(payload.success, false);
+				assert.equal(payload.timedOut, true);
+				assert.equal(payload.results[0]?.timedOut, true);
+				assert.equal(checkpoint(terminal)?.targets[0]?.state, "failed");
+			}
+			const receipts = journal(id).filter((event) => event.requestId === request.id);
+			assert.equal(receipts.filter((event) => event.type === "subagent.steer.requested").length, 1);
+			assert.equal(receipts.filter((event) => event.type === "subagent.steer.queued").length, 1);
+			assert.equal(receipts.filter((event) => event.type === `subagent.steer.${outcome === "handoff" ? "delivered" : "failed"}`).length, 1);
+			assert.equal(receipts.filter((event) => event.type === `subagent.steer.${outcome === "handoff" ? "failed" : "delivered"}`).length, 0);
+		});
+	}
+
+	it("cleans up after early completion without issuing a late checkpoint or timeout", {
+		skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined,
+		timeout: 25_000,
+	}, async () => {
+		mockPi.onCall({ output: "finished early" });
+		const executor = makeAsyncExecutor([makeAgent("worker")]);
+		const result = await executor.execute("checkpoint-early", {
+			agent: "worker", task: "Explore the repository", async: true, clarify: false,
+			timeoutMs: 15_000, checkpointBeforeDeadlineMs: 3_000,
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		const id = result.details?.asyncId;
+		assert.ok(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.output, "finished early");
+		const terminal = await waitForAsyncState(id, (status) => status.state === "complete");
+		assert.ok(terminal.deadlineAt);
+		assert.ok(Date.now() < terminal.deadlineAt - 3_000, "child must finish before checkpoint is due");
+		await new Promise((resolve) => setTimeout(resolve, Math.max(0, terminal.deadlineAt! - Date.now()) + 300));
+		// Process-terminal bookkeeping may arrive later; no checkpoint steering may occur.
+		assert.deepEqual(journal(id).filter((event) => event.type.startsWith("subagent.steer.")), [], "no checkpoint steering after early completion");
+		assert.notEqual((await readAsyncPayload(id)).timedOut, true);
+		assert.ok(terminal.pid);
+		assert.throws(() => process.kill(terminal.pid!, 0), { code: "ESRCH" }, "runner exits rather than waiting for timers");
+	});
+
+	it("does not schedule a checkpoint less than one second after launch", {
+		skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined,
+		timeout: 25_000,
+	}, async () => {
+		mockPi.onCall({ steps: [{ waitForPath: path.join(tempDir, "never-released") }] });
+		const executor = makeAsyncExecutor([makeAgent("worker")]);
+		const result = await executor.execute("checkpoint-short-lead", {
+			agent: "worker", task: "Wait", async: true, clarify: false,
+			timeoutMs: 800, checkpointBeforeDeadlineMs: 100,
+		}, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+		const id = result.details?.asyncId;
+		assert.ok(id);
+		await waitForAsyncResultFile(id);
+		assert.deepEqual(journal(id).filter((event) => event.source === "deadline-checkpoint"), []);
+	});
+});

package/dist/extensions/pi-subagents/test/integration/doctor-executor.test.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
+import { acquireActiveAsyncCapacity } from "../../src/runs/background/active-async-capacity.ts";
 import { createEventBus, createTempDir, makeMinimalCtx, removeTempDir, tryImport } from "../support/helpers.ts";
 
 const originalHome = process.env.HOME;
@@ -92,6 +93,33 @@ describe("doctor action executor routing", { skip: !createSubagentExecutor ? "ex
 		assert.match(text, /- supervisor channel: available \(native:pi-subagents-supervisor-channel\)/);
 	});
 
+	it("counts async capacity in the pool launch admission uses", async () => {
+		const sessionFile = path.join(tempDir, "sessions", "resumed.jsonl");
+		const capacity = acquireActiveAsyncCapacity({ sessionId: sessionFile, limit: 3, runId: "doctor-held-run", kind: "runner", asyncDir: path.join(tempDir, "doctor-held-run") });
+		try {
+			const executor = createSubagentExecutor({
+				pi: { events: createEventBus(), getSessionName: () => undefined },
+				state: makeState(tempDir),
+				config: { maxActiveAsyncRunsPerSession: 3 },
+				asyncByDefault: false,
+				tempArtifactsDir: tempDir,
+				getSubagentSessionRoot: () => tempDir,
+				expandTilde: (value: string) => value,
+				discoverAgents: () => ({ agents: [] }),
+			});
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionFile = () => sessionFile;
+			ctx.sessionManager.getSessionId = () => "short-session-id";
+
+			const result = await executor.execute("doctor-id", { action: "doctor" }, new AbortController().signal, undefined, ctx);
+
+			assert.match(result.content[0]?.text ?? "", /Active async capacity\n- usage: 1\/3 used/);
+			assert.deepEqual(result.details.activeAsyncCapacity, { used: 1, limit: 3 });
+		} finally {
+			capacity?.rollback();
+		}
+	});
+
 	it("reports session manager failures without failing the doctor action", async () => {
 		const executor = createSubagentExecutor({
 			pi: { events: createEventBus(), getSessionName: () => undefined },
@@ -125,4 +153,4 @@ describe("doctor action executor routing", { skip: !createSubagentExecutor ? "ex
 		assert.match(text, /- session manager: failed — Error: session unavailable/);
 		assert.match(text, /- current session file: not available/);
 	});
-});
+});