@selesai/code 0.6.2 → 0.7.0

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

@@ -0,0 +1,217 @@
+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 {
+	attachMissionToLaunchResult,
+	prepareMissionLaunch,
+	readMissionBinding,
+	syncMissionFromAsyncCompletion,
+} from "../../src/missions/lifecycle.ts";
+import { readMission } from "../../src/missions/store.ts";
+
+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") } };
+}
+
+describe("mission launch lifecycle", () => {
+	it("creates missions by default for task launches and honors explicit opt-out", () => {
+		const test = projectFixture();
+		try {
+			const binding = prepareMissionLaunch({
+				params: { task: "Map the auth flow" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+				ownerSessionId: "session-1",
+			});
+			assert.ok(binding);
+			const mission = readMission(binding.location, binding.missionId);
+			assert.equal(mission.goal, "Map the auth flow");
+			assert.equal(mission.status, "active");
+			const result = attachMissionToLaunchResult({
+				binding,
+				result: {
+					content: [{ type: "text", text: JSON.stringify({ ok: true }) }],
+					details: {
+						mode: "single",
+						runId: "default-mission-run",
+						results: [{ index: 0, agent: "builder", task: "Map the auth flow", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
+					},
+				},
+			});
+			assert.equal(result.content[0]?.type === "text" ? result.content[0].text : "", JSON.stringify({ ok: true }));
+
+			const disabled = prepareMissionLaunch({
+				params: { task: "Tiny one-off" },
+				projectRoot: test.projectRoot,
+				config: { ...test.missionConfig, enabled: false },
+			});
+			assert.equal(disabled, undefined);
+
+			const perLaunchDisabled = prepareMissionLaunch({
+				params: { mission: false, task: "Ephemeral check" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.equal(perLaunchDisabled, undefined);
+
+			assert.throws(() => prepareMissionLaunch({
+				params: { missionId: binding.missionId, mission: false, task: "Contradictory mission request" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			}), /Use missionId or mission/);
+
+			const explicit = prepareMissionLaunch({
+				params: { mission: { title: "Explicit mission" }, task: "Tiny one-off" },
+				projectRoot: test.projectRoot,
+				config: { ...test.missionConfig, enabled: false },
+			});
+			assert.ok(explicit);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("creates a mission shortcut and records a completed foreground run", () => {
+		const test = projectFixture();
+		try {
+			const binding = prepareMissionLaunch({
+				params: { mission: { title: "Implement feature", goal: "Ship it", labels: ["phase-1"] }, task: "Do the work" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+				ownerSessionId: "session-1",
+			});
+			assert.ok(binding);
+			const result = attachMissionToLaunchResult({
+				binding,
+				result: {
+					content: [{ type: "text", text: "Implemented and tested." }],
+					details: {
+						mode: "single",
+						runId: "foreground-1",
+						results: [{ index: 0, agent: "builder", task: "Do the work", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 } }],
+					},
+				},
+			});
+			assert.equal(result.details?.missionId, binding.missionId);
+			assert.match(result.content[0]?.type === "text" ? result.content[0].text : "", new RegExp(`Implemented and tested\\.\\nMission: ${binding.missionId} \\(completed\\)$`));
+			const mission = readMission(binding.location, binding.missionId);
+			assert.equal(mission.status, "completed");
+			assert.equal(mission.runs[0]?.runId, "foreground-1");
+			assert.equal(mission.runs[0]?.status, "completed");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("marks a prepared mission failed when launch reservation returns an error before a run id exists", () => {
+		const test = projectFixture();
+		try {
+			const binding = prepareMissionLaunch({
+				params: { mission: { title: "Budget race" }, task: "Run after preflight" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.ok(binding);
+			const result = attachMissionToLaunchResult({
+				binding,
+				result: {
+					content: [{ type: "text", text: "Spawn budget exhausted after preflight." }],
+					isError: true,
+					details: { mode: "single", results: [] },
+				},
+			});
+			assert.equal(result.details?.missionId, binding.missionId);
+			assert.equal(readMission(binding.location, binding.missionId).status, "failed");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("records a bounded warning when an async mission record disappeared before completion", () => {
+		const test = projectFixture();
+		try {
+			const asyncDir = path.join(test.root, "async-run-missing-mission");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			const binding = prepareMissionLaunch({
+				params: { mission: { title: "Disposable mission record" }, task: "Run later" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.ok(binding);
+			attachMissionToLaunchResult({
+				binding,
+				result: {
+					content: [{ type: "text", text: "Async started" }],
+					details: { mode: "single", runId: "async-missing-mission", asyncId: "async-missing-mission", asyncDir, results: [] },
+				},
+			});
+			fs.rmSync(binding.location.missionDir, { recursive: true, force: true });
+
+			const completed = syncMissionFromAsyncCompletion({
+				runId: "async-missing-mission",
+				asyncDir,
+				mode: "single",
+				state: "complete",
+				success: true,
+			});
+
+			assert.equal(completed, undefined);
+			const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line) as Record<string, unknown>);
+			assert.deepEqual(events, [{
+				type: "subagent.mission.sync.skipped",
+				ts: events[0]?.ts,
+				runId: "async-missing-mission",
+				missionId: binding.missionId,
+				reason: "mission-record-missing",
+				missionPath: path.join(binding.location.missionDir, `${binding.missionId}.json`),
+			}]);
+			assert.equal(typeof events[0]?.ts, "number");
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("binds an async launch and reconciles terminal status and artifacts", () => {
+		const test = projectFixture();
+		try {
+			const asyncDir = path.join(test.root, "async-run");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			const binding = prepareMissionLaunch({
+				params: { mission: { title: "Background mission" }, task: "Run later" },
+				projectRoot: test.projectRoot,
+				config: test.missionConfig,
+			});
+			assert.ok(binding);
+			attachMissionToLaunchResult({
+				binding,
+				result: {
+					content: [{ type: "text", text: "Async started" }],
+					details: { mode: "chain", runId: "async-1", asyncId: "async-1", asyncDir, results: [] },
+				},
+			});
+			assert.equal(readMissionBinding(asyncDir)?.missionId, binding.missionId);
+			assert.equal(readMission(binding.location, binding.missionId).status, "active");
+
+			const completed = syncMissionFromAsyncCompletion({
+				id: "async-1",
+				runId: "async-1",
+				asyncDir,
+				mode: "chain",
+				state: "complete",
+				success: true,
+				summary: "Background work completed",
+				results: [{ artifactPath: path.join(asyncDir, "output-0.log") }],
+			});
+			assert.equal(completed?.status, "completed");
+			assert.equal(completed?.runs[0]?.status, "complete");
+			assert.ok(completed?.artifacts.some((artifact) => artifact.kind === "output"));
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,182 @@
+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 { handleMissionAction } from "../../src/missions/actions.ts";
+import {
+	createMission,
+	listGlobalMissions,
+	listMissions,
+	readMission,
+	resolveMissionStoreLocation,
+	updateMission,
+} from "../../src/missions/store.ts";
+
+function fixture() {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-missions-"));
+	const projectRoot = path.join(root, "project");
+	const agentDir = path.join(root, "agent");
+	fs.mkdirSync(projectRoot, { recursive: true });
+	const location = resolveMissionStoreLocation({ projectRoot, agentDir });
+	return { root, projectRoot, agentDir, location };
+}
+
+describe("mission store", () => {
+	it("creates, reads, updates, lists, and globally indexes project missions", () => {
+		const test = fixture();
+		try {
+			const created = createMission(test.location, {
+				title: "Ship durable missions",
+				goal: "Make delegated work resumable",
+				labels: ["phase-1"],
+			});
+			const updated = updateMission(test.location, created.id, {
+				status: "active",
+				summary: "Implementation started",
+				addRuns: [
+					{ runId: "run-1", mode: "single", status: "running" },
+					{ runId: "workflow-1", mode: "workflow", status: "completed" },
+				],
+				addArtifacts: [{ kind: "status", path: path.join(test.root, "status.json") }],
+				addReceipts: [{ kind: "pull_request", status: "ready", title: "PR 733", url: "https://github.com/example/repo/pull/733" }],
+				addDecisions: [{ title: "Choose release window", options: ["now", "later"] }],
+			});
+
+			assert.equal(readMission(test.location, created.id).status, "active");
+			assert.equal(updated.runs[0]?.runId, "run-1");
+			assert.equal(readMission(test.location, created.id).runs[1]?.mode, "workflow");
+			assert.equal(updated.decisions[0]?.status, "open");
+			assert.equal(updated.receipts[0]?.url, "https://github.com/example/repo/pull/733");
+			const receiptUpdated = updateMission(test.location, created.id, {
+				addReceipts: [{ kind: "pull_request", status: "succeeded", title: "PR 733", url: "https://github.com/example/repo/pull/733" }],
+			});
+			assert.equal(receiptUpdated.receipts[0]?.status, "succeeded");
+			assert.equal(receiptUpdated.receipts[0]?.createdAt, updated.receipts[0]?.createdAt);
+			assert.deepEqual(listMissions(test.location).records.map((record) => record.id), [created.id]);
+			const global = listGlobalMissions(test.location.globalIndexDir);
+			assert.equal(global.entries[0]?.missionId, created.id);
+			assert.equal(global.entries[0]?.stale, false);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("loads older records that do not have receipts", () => {
+		const test = fixture();
+		try {
+			const created = createMission(test.location, { title: "Older record", goal: "Stay readable" });
+			const recordPath = path.join(test.location.missionDir, `${created.id}.json`);
+			const raw = JSON.parse(fs.readFileSync(recordPath, "utf-8")) as Record<string, unknown>;
+			delete raw.receipts;
+			fs.writeFileSync(recordPath, JSON.stringify(raw), "utf-8");
+			assert.deepEqual(readMission(test.location, created.id).receipts, []);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("skips corrupt records, removes missing pointers, and preserves parse-error pointers", () => {
+		const test = fixture();
+		try {
+			const missing = createMission(test.location, { title: "Missing record", goal: "Heal its pointer" });
+			const corrupt = createMission(test.location, { title: "Corrupt record", goal: "Keep evidence" });
+			fs.writeFileSync(path.join(test.location.missionDir, "broken.json"), "{not json", "utf-8");
+			assert.equal(listMissions(test.location).warnings.length, 1);
+
+			fs.rmSync(path.join(test.location.missionDir, `${missing.id}.json`));
+			fs.writeFileSync(path.join(test.location.missionDir, `${corrupt.id}.json`), "{not json", "utf-8");
+			const global = listGlobalMissions(test.location.globalIndexDir);
+			assert.equal(global.entries.length, 1);
+			assert.equal(global.entries[0]?.missionId, corrupt.id);
+			assert.equal(global.entries[0]?.stale, true);
+			assert.match(global.warnings.join("\n"), /Removed stale global mission pointer/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("prunes only the oldest terminal missions at the configured bound", () => {
+		const test = fixture();
+		const location = { ...test.location, retainTerminal: 1 };
+		try {
+			const oldest = createMission(location, { title: "Old terminal", goal: "Prune me" }, new Date("2026-01-01T00:00:00Z"));
+			const newest = createMission(location, { title: "New terminal", goal: "Keep me" }, new Date("2026-01-02T00:00:00Z"));
+			const active = createMission(location, { title: "Active", goal: "Never prune", status: "active" }, new Date("2026-01-03T00:00:00Z"));
+			const planned = createMission(location, { title: "Planned", goal: "Never prune", status: "planned" }, new Date("2026-01-04T00:00:00Z"));
+			updateMission(location, oldest.id, { status: "completed" }, new Date("2026-01-05T00:00:00Z"));
+			updateMission(location, newest.id, { status: "failed" }, new Date("2026-01-06T00:00:00Z"));
+
+			assert.throws(() => readMission(location, oldest.id), /was not found/);
+			assert.equal(readMission(location, newest.id).status, "failed");
+			assert.equal(readMission(location, active.id).status, "active");
+			assert.equal(readMission(location, planned.id).status, "planned");
+			assert.equal(listGlobalMissions(location.globalIndexDir).entries.some((entry) => entry.missionId === oldest.id), false);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("shows missions with warnings when linked run status is unreadable", () => {
+		const test = fixture();
+		try {
+			const ctx = { cwd: test.projectRoot, agentDir: test.agentDir, currentSessionId: "session-1" };
+			const created = handleMissionAction("mission.create", { mission: { title: "Unreadable status", goal: "Keep mission readable" } }, ctx);
+			const missionId = created.details?.missionId;
+			assert.ok(missionId);
+			const asyncDir = path.join(test.root, "async-run");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			handleMissionAction("mission.attach-run", { missionId, runId: "run-3", runMode: "single", runStatus: "running", dir: asyncDir }, ctx);
+			fs.writeFileSync(path.join(asyncDir, "status.json"), "{not json", "utf-8");
+
+			const shown = handleMissionAction("mission.show", { missionId }, ctx);
+
+			assert.equal(shown.details?.mission?.runs[0]?.status, "running");
+			assert.match(shown.content[0]?.type === "text" ? shown.content[0].text : "", /Warning: Failed to read linked run status/);
+			assert.equal(shown.details?.missions?.warnings?.length, 1);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("supports the mission management actions with structured details", () => {
+		const test = fixture();
+		try {
+			const ctx = { cwd: test.projectRoot, agentDir: test.agentDir, currentSessionId: "session-1" };
+			const created = handleMissionAction("mission.create", { mission: { title: "Action mission", goal: "Exercise actions" } }, ctx);
+			const missionId = created.details?.missionId;
+			assert.ok(missionId);
+			const asyncDir = path.join(test.root, "async-run");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			const attached = handleMissionAction("mission.attach-run", { missionId, runId: "run-2", runMode: "parallel", runStatus: "running", dir: asyncDir }, ctx);
+			assert.equal(attached.details?.mission?.runs[0]?.runId, "run-2");
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ state: "complete" }), "utf-8");
+			const shown = handleMissionAction("mission.show", { missionId }, ctx);
+			assert.equal(shown.details?.mission?.status, "completed");
+			assert.equal(shown.details?.mission?.runs[0]?.status, "complete");
+			const receipt = handleMissionAction("mission.update", {
+				missionId,
+				missionUpdate: {
+					receipts: [{ kind: "ci", status: "succeeded", title: "Unit tests", url: "https://github.com/example/repo/actions/runs/1", description: "All checks passed" }],
+				},
+			}, ctx);
+			assert.equal(receipt.details?.mission?.receipts[0]?.status, "succeeded");
+			assert.match(receipt.content[0]?.type === "text" ? receipt.content[0].text : "", /Delivery receipts:\n  ci \(succeeded\): Unit tests/);
+			const updatedReceipt = handleMissionAction("mission.update", {
+				missionId,
+				missionUpdate: { receipts: [{ kind: "ci", status: "ready", title: "Unit tests", url: "https://github.com/example/repo/actions/runs/1" }] },
+			}, ctx);
+			assert.equal(updatedReceipt.details?.mission?.receipts.length, 1);
+			assert.equal(updatedReceipt.details?.mission?.receipts[0]?.status, "ready");
+			const closed = handleMissionAction("mission.close", { missionId, missionStatus: "completed", summary: "Done" }, ctx);
+			assert.equal(closed.details?.mission?.status, "completed");
+			const global = handleMissionAction("mission.list", { missionScope: "global" }, ctx);
+			assert.equal(global.details?.missions?.globalEntries?.length, 1);
+			assert.throws(() => handleMissionAction("mission.list", { missionScope: "everywhere" as "global" }, ctx), /missionScope/);
+			assert.throws(() => handleMissionAction("mission.update", { missionId, missionUpdate: { unsupported: true } as never }, ctx), /unknown/);
+			assert.throws(() => handleMissionAction("mission.update", { missionId, missionUpdate: { receipts: [{ kind: "ci", status: "ready", title: "Bad URL", url: "relative" }] } as never }, ctx), /absolute URL/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,22 @@
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import { after, describe, it } from "node:test";
+import { createMockPi } from "../support/mock-pi.ts";
+
+describe("mock Pi queue isolation", () => {
+	const mockPi = createMockPi();
+	after(() => mockPi.uninstall());
+
+	it("keeps the prior queue for children that inherited it before reset", () => {
+		mockPi.install();
+		mockPi.reset();
+		const priorQueue = mockPi.dir;
+		mockPi.onCall({ output: "prior response" });
+
+		mockPi.reset();
+
+		assert.notEqual(mockPi.dir, priorQueue);
+		assert.ok(fs.readdirSync(priorQueue).some((name) => name.startsWith("pending-")));
+		assert.equal(fs.readdirSync(mockPi.dir).length, 0);
+	});
+});

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

@@ -117,7 +117,7 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
-	it("inherits the parent session model when the agent config sets model: false (delegate)", () => {
+	it("inherits the parent session model when the agent config sets model: false (explorer)", () => {
 		assert.equal(
 			resolveSubagentModelOverride(false, parentModel, availableModels),
 			"deepseek/deepseek-v4-flash",

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

@@ -49,7 +49,7 @@ function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 }
 
 function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string; createdAt?: number; expiresAt?: number }): string {
-	const agent = input.agent ?? "worker";
+	const agent = input.agent ?? "builder";
 	const index = input.index ?? 0;
 	const channelDir = resolveSupervisorChannelDir(input.runId, agent, index);
 	createdChannels.push(channelDir);
@@ -72,16 +72,16 @@ function writeRequest(input: { sessionId: string; runId: string; agent?: string;
 	return requestId;
 }
 
-function requestFile(runId: string, requestId: string, agent = "worker", index = 0): string {
+function requestFile(runId: string, requestId: string, agent = "builder", index = 0): string {
 	return path.join(resolveSupervisorChannelDir(runId, agent, index), "requests", `${requestId}.json`);
 }
 
-function replyFile(runId: string, requestId: string, agent = "worker", index = 0): string {
+function replyFile(runId: string, requestId: string, agent = "builder", index = 0): string {
 	return path.join(resolveSupervisorChannelDir(runId, agent, index), "replies", `${requestId}.json`);
 }
 
 function makeEmptyChannel(runId: string): string {
-	const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
+	const channelDir = resolveSupervisorChannelDir(runId, "builder", 0);
 	createdChannels.push(channelDir);
 	ensureSupervisorChannelDir(channelDir);
 	return channelDir;
@@ -211,7 +211,7 @@ describe("native supervisor channel", () => {
 	it("emits foreground detach only after displaying a pending supervisor request", () => {
 		const currentSessionId = `session-${randomUUID()}`;
 		const runId = `run-${randomUUID()}`;
-		const requestId = writeRequest({ sessionId: currentSessionId, runId, agent: "worker", index: 2 });
+		const requestId = writeRequest({ sessionId: currentSessionId, runId, agent: "builder", index: 2 });
 		const log: string[] = [];
 		const emitted: Array<{ channel: string; payload: { requestId?: string; runId?: string; agent?: string; childIndex?: number } }> = [];
 		const ctx = {
@@ -242,7 +242,7 @@ describe("native supervisor channel", () => {
 			assert.deepEqual(log, ["send", "emit"]);
 			assert.deepEqual(emitted, [{
 				channel: INTERCOM_DETACH_REQUEST_EVENT,
-				payload: { requestId, runId, agent: "worker", childIndex: 2 },
+				payload: { requestId, runId, agent: "builder", childIndex: 2 },
 			}]);
 			assert.equal(channel.pending.has(requestId), true);
 		} finally {
@@ -271,7 +271,7 @@ describe("native supervisor channel", () => {
 			cwd: process.cwd(),
 			sessionId: currentSessionId,
 			updatedAt: 1,
-			children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
+			children: [{ agent: "builder", index: 0, status: "detached", updatedAt: 1 }],
 		}]]);
 		const pi = {
 			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
@@ -398,7 +398,7 @@ describe("native supervisor channel", () => {
 			mode: "single",
 			cwd: process.cwd(),
 			updatedAt: Date.now(),
-			children: [{ agent: "worker", index: 0, status: "completed", updatedAt: Date.now() }],
+			children: [{ agent: "builder", index: 0, status: "completed", updatedAt: Date.now() }],
 		}]]);
 		const pi = {
 			getAllTools: () => [],
@@ -464,13 +464,13 @@ describe("native supervisor channel", () => {
 
 	it("removes the request file when a child supervisor ask is cancelled", async () => {
 		const runId = `run-${randomUUID()}`;
-		const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
+		const channelDir = resolveSupervisorChannelDir(runId, "builder", 0);
 		createdChannels.push(channelDir);
 		process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = "shared-name";
 		process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = "session-parent";
 		process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = channelDir;
 		process.env[SUBAGENT_RUN_ID_ENV] = runId;
-		process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
+		process.env[SUBAGENT_CHILD_AGENT_ENV] = "builder";
 		process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
 		const registeredTools = new Map<string, { execute: (_id: string, params: { reason: string; message?: string }, signal?: AbortSignal) => Promise<unknown> | unknown }>();
 		const pi = {

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

@@ -88,7 +88,7 @@ function createNestedRun(id = "nested-live", state: "running" | "complete" | "fa
 		ts: 100,
 		parentRunId: "root-control",
 		parentStepIndex: 0,
-		child: { id, parentRunId: "root-control", parentStepIndex: 0, depth: 1, path: [{ runId: "root-control", stepIndex: 0 }], state, agent: "worker", ownerState: state === "running" ? "live" : "gone", ...extras },
+		child: { id, parentRunId: "root-control", parentStepIndex: 0, depth: 1, path: [{ runId: "root-control", stepIndex: 0 }], state, agent: "builder", ownerState: state === "running" ? "live" : "gone", ...extras },
 	});
 	return route;
 }
@@ -187,7 +187,7 @@ describe("nested control routing", () => {
 
 			assert.equal(result.isError, undefined);
 			assert.match(text(result), /Run: root-control/);
-			assert.match(text(result), /↳ worker \[nested-foreground\] running/);
+			assert.match(text(result), /↳ builder \[nested-foreground\] running/);
 			assert.match(text(result), /Status: subagent\(\{ action: "status", id: "nested-foreground" \}\)/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
@@ -264,11 +264,19 @@ describe("nested control routing", () => {
 		try {
 			const route = createNestedRun("nested-timeout");
 			const executor = createExecutor(stateWithNestedRoute(route));
-			setTimeout(() => {
-				const request = readNestedControlRequests(route)[0];
-				if (request) writeNestedControlResult(route, { ts: Date.now(), requestId: request.requestId, targetRunId: request.targetRunId, ok: true, message: "late success" });
-			}, 1_200);
+			const lateResponder = (async () => {
+				const deadline = Date.now() + 2_000;
+				let request = readNestedControlRequests(route)[0];
+				while (!request && Date.now() < deadline) {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					request = readNestedControlRequests(route)[0];
+				}
+				assert.ok(request, "expected a nested control request");
+				await new Promise((resolve) => setTimeout(resolve, 1_200));
+				writeNestedControlResult(route, { ts: Date.now(), requestId: request.requestId, targetRunId: request.targetRunId, ok: true, message: "late success" });
+			})();
 			const result = await executor.execute("interrupt", { action: "interrupt", id: "nested-timeout" }, new AbortController().signal, undefined, ctx(root));
+			await lateResponder;
 			assert.equal(result.isError, true);
 			assert.match(text(result), /owner is not reachable/);
 			assert.doesNotMatch(text(result), /late success/);
@@ -310,7 +318,7 @@ describe("nested control routing", () => {
 		try {
 			const route = createNestedRun("nested-terminal-resume", "complete", { sessionFile: path.join(root, "missing-session.jsonl") });
 
-			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "builder", description: "Worker", prompt: "Do work" }])
 				.execute("resume", { action: "resume", id: "nested-terminal-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root));
 
 			assert.equal(result.isError, true);
@@ -325,7 +333,7 @@ describe("nested control routing", () => {
 		try {
 			const route = createNestedRun("nested-stopped-resume", "stopped", { sessionFile: path.join(root, "missing-session.jsonl") });
 
-			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "builder", description: "Worker", prompt: "Do work" }])
 				.execute("resume", { action: "resume", id: "nested-stopped-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root));
 
 			assert.equal(result.isError, true);
@@ -346,7 +354,7 @@ describe("nested control routing", () => {
 			fs.writeFileSync(attackerSessionFile, "");
 			const route = createNestedRun("nested-untrusted-resume", "complete", { sessionFile: attackerSessionFile });
 
-			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "builder", description: "Worker", prompt: "Do work" }])
 				.execute("resume", { action: "resume", id: "nested-untrusted-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root, parentSessionFile));
 
 			assert.equal(result.isError, true);
@@ -366,7 +374,7 @@ describe("nested control routing", () => {
 			fs.writeFileSync(siblingSessionFile, "");
 			const route = createNestedRun("nested-sibling-resume", "complete", { sessionFile: siblingSessionFile });
 
-			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "builder", description: "Worker", prompt: "Do work" }])
 				.execute("resume", { action: "resume", id: "nested-sibling-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root, parentSessionFile));
 
 			assert.equal(result.isError, true);
@@ -387,8 +395,8 @@ describe("nested control routing", () => {
 				modelRegistry: { getAvailable() { throw new Error("model registry exploded"); } },
 			};
 
-			const result = await createExecutor(createState(), [{ name: "worker", description: "Worker", prompt: "Do work" }])
-				.execute("run", { agent: "worker", task: "go" }, new AbortController().signal, undefined, throwingCtx);
+			const result = await createExecutor(createState(), [{ name: "builder", description: "Worker", prompt: "Do work" }])
+				.execute("run", { agent: "builder", task: "go" }, new AbortController().signal, undefined, throwingCtx);
 
 			assert.equal(result.isError, true);
 			assert.match(text(result), /model registry exploded/);