@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/subagent-prompt-runtime.test.ts

@@ -61,7 +61,7 @@ const envSnapshot = {
 	SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG: process.env.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG,
 };
 
-const SKILLS_SECTION = "\n\nThe following skills provide specialized instructions for specific tasks.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>safe-bash</name>\n    <description>desc</description>\n    <location>/tmp/SKILL.md</location>\n  </skill>\n  <skill>\n    <name>pi-subagents</name>\n    <description>explorer to subagents</description>\n    <location>/tmp/pi-subagents/SKILL.md</location>\n  </skill>\n</available_skills>";
+const SKILLS_SECTION = "\n\nThe following skills provide specialized instructions for specific tasks.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>safe-bash</name>\n    <description>desc</description>\n    <location>/tmp/SKILL.md</location>\n  </skill>\n  <skill>\n    <name>pi-subagents</name>\n    <description>delegate to subagents</description>\n    <location>/tmp/pi-subagents/SKILL.md</location>\n  </skill>\n</available_skills>";
 
 const BASE_PROMPT = [
 	"You are a subagent.",
@@ -132,7 +132,7 @@ function setSupervisorEnv(): void {
 	process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = "session-parent";
 	process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = path.join(os.tmpdir(), "subagent-supervisor-runtime-test");
 	process.env[SUBAGENT_RUN_ID_ENV] = "run-123";
-	process.env[SUBAGENT_CHILD_AGENT_ENV] = "builder";
+	process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 	process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
 }
 
@@ -235,6 +235,7 @@ describe("subagent prompt runtime", () => {
 			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
 			const handlers = new Map<string, (payload?: unknown) => unknown>();
 			let watchedDir: fs.PathLike | undefined;
+			const intervalDelays: number[] = [];
 			const fakeWatcher = { on() { return fakeWatcher; }, close() {} } as fs.FSWatcher;
 
 			registerSteeringInbox({
@@ -251,10 +252,18 @@ describe("subagent prompt runtime", () => {
 					watchedDir = target;
 					return fakeWatcher;
 				}) as typeof fs.watch,
+				timers: {
+					setInterval: ((_handler: Parameters<typeof setInterval>[0], delay?: number) => {
+						intervalDelays.push(delay ?? 0);
+						return { unref() {} };
+					}) as typeof setInterval,
+					clearInterval: (() => {}) as typeof clearInterval,
+				},
 			});
 
 			handlers.get("session_start")?.({});
 			assert.equal(watchedDir, nativeInbox);
+			assert.deepEqual(intervalDelays, [5000]);
 			handlers.get("session_shutdown")?.({});
 		} finally {
 			fs.rmSync(dir, { recursive: true, force: true });
@@ -292,6 +301,162 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
+	it("queues follow-ups and acknowledges delivery at the next turn boundary", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-follow-up-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
+			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
+			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const sent: Array<{ content: string; deliverAs?: string }> = [];
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
+				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
+			} as never);
+			handlers.get("session_start")?.({});
+			handlers.get("agent_start")?.({});
+			handlers.get("turn_start")?.({});
+			writeSteerRequestToDir(inbox, { type: "steer", id: "follow", ts: 1, message: "Check docs.", mode: "follow_up" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[0]?.deliverAs, "followUp");
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+			handlers.get("turn_end")?.({});
+			handlers.get("turn_start")?.({});
+			const delivered = consumeSteerAcks(dir)[0];
+			assert.equal(delivered?.state, "delivered");
+			assert.equal(delivered?.deliveryStatus, "delivered");
+
+			writeSteerRequestToDir(inbox, { type: "steer", id: "auto-mid", ts: 2, message: "Mid-turn auto.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[1]?.deliverAs, "followUp");
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[1]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+			handlers.get("turn_end")?.({});
+			handlers.get("turn_start")?.({});
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "delivered");
+
+			handlers.get("turn_end")?.({});
+			writeSteerRequestToDir(inbox, { type: "steer", id: "auto-idle", ts: 3, message: "Between-turn auto.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[2]?.deliverAs, "steer");
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "steer", text: sent[2]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.deliveryStatus, "delivered");
+
+			writeSteerRequestToDir(inbox, { type: "steer", id: "undelivered", ts: 4, message: "Never reached.", mode: "follow_up" });
+			handlers.get("message_start")?.({});
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[3]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+			handlers.get("session_shutdown")?.({});
+			const failed = consumeSteerAcks(dir)[0];
+			assert.equal(failed?.state, "failed");
+			assert.match(failed?.message ?? "", /ended before queued follow-up/);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("queues auto steering after agent_end until agent_settled", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-settled-steering-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
+			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const sent: Array<{ content: string; deliverAs?: string }> = [];
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
+				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
+			} as never);
+			handlers.get("session_start")?.({});
+			handlers.get("agent_start")?.({});
+			handlers.get("turn_start")?.({});
+			handlers.get("turn_end")?.({});
+			handlers.get("agent_end")?.({ willRetry: false });
+
+			writeSteerRequestToDir(inbox, { type: "steer", id: "settling-auto", ts: 1, message: "Wait for settled.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[0]?.deliverAs, "followUp");
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+
+			handlers.get("agent_settled")?.({});
+			writeSteerRequestToDir(inbox, { type: "steer", id: "settled-auto", ts: 2, message: "Now idle.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[1]?.deliverAs, undefined);
+			handlers.get("input")?.({ source: "extension", text: sent[1]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.deliveryStatus, "delivered");
+			handlers.get("session_shutdown")?.({});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps auto steering queued while agent_end will retry", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-retry-steering-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
+			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const sent: Array<{ content: string; deliverAs?: string }> = [];
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
+				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
+			} as never);
+			handlers.get("session_start")?.({});
+			handlers.get("agent_start")?.({});
+			handlers.get("turn_start")?.({});
+			handlers.get("turn_end")?.({});
+			handlers.get("agent_end")?.({ willRetry: true });
+
+			writeSteerRequestToDir(inbox, { type: "steer", id: "retry-auto", ts: 1, message: "Keep this guidance.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[0]?.deliverAs, "followUp");
+			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+
+			handlers.get("turn_start")?.({});
+			const delivered = consumeSteerAcks(dir)[0];
+			assert.equal(delivered?.requestId, "retry-auto");
+			assert.equal(delivered?.deliveryStatus, "delivered");
+			handlers.get("session_shutdown")?.({});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("falls back to idle delivery for runtimes without agent_settled", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-legacy-steering-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const sent: Array<{ content: string; deliverAs?: string }> = [];
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
+				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
+			} as never, { legacySettleFallbackMs: 5 });
+			handlers.get("session_start")?.({});
+			handlers.get("agent_start")?.({});
+			handlers.get("turn_start")?.({});
+			handlers.get("turn_end")?.({});
+			handlers.get("agent_end")?.({ willRetry: false });
+			await new Promise((resolve) => setTimeout(resolve, 20));
+
+			writeSteerRequestToDir(inbox, { type: "steer", id: "legacy-auto", ts: 1, message: "Legacy idle.", mode: "auto" });
+			handlers.get("message_start")?.({});
+			assert.equal(sent[0]?.deliverAs, undefined);
+			handlers.get("session_shutdown")?.({});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	it("does not acknowledge sendUserMessage until the correlated Pi input event arrives", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-ack-runtime-"));
 		try {
@@ -325,6 +490,64 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
+	it("retries pending correlation once as a follow-up after compaction", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-compaction-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
+			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
+			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const sent: Array<{ content: string; deliverAs?: string }> = [];
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
+				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
+			} as never);
+			handlers.get("session_start")?.({});
+			writeSteerRequestToDir(inbox, { type: "steer", id: "compact", ts: 1, message: "Keep this guidance." });
+			handlers.get("message_start")?.({});
+			assert.equal(sent.length, 1);
+			assert.deepEqual(consumeSteerAcks(dir), []);
+
+			handlers.get("session_compact")?.({ reason: "manual" });
+			assert.equal(sent.length, 2);
+			assert.equal(sent[1]?.deliverAs, "followUp");
+			handlers.get("input")?.({ source: "extension", text: sent[1]?.content });
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
+			handlers.get("turn_start")?.({});
+			assert.equal(consumeSteerAcks(dir)[0]?.state, "delivered");
+			handlers.get("session_compact")?.({ reason: "manual" });
+			assert.equal(sent.length, 2);
+			handlers.get("session_shutdown")?.({});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("fails pending correlation when the session shuts down", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-pending-shutdown-runtime-"));
+		try {
+			const inbox = path.join(dir, "inbox");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
+			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
+			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			registerSteeringInbox({ on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); }, sendUserMessage() {} } as never);
+			handlers.get("session_start")?.({});
+			writeSteerRequestToDir(inbox, { type: "steer", id: "pending", ts: 1, message: "Unconfirmed guidance." });
+			handlers.get("message_start")?.({});
+			handlers.get("session_shutdown")?.({});
+			const ack = consumeSteerAcks(dir)[0];
+			assert.equal(ack?.requestId, "pending");
+			assert.equal(ack?.state, "failed");
+			assert.match(ack?.message ?? "", /before Pi confirmed steering input delivery/);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	it("correlates duplicate guidance FIFO without a visible marker", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-fifo-runtime-"));
 		try {
@@ -386,7 +609,7 @@ describe("subagent prompt runtime", () => {
 		process.env[CHILD_WATCHDOG_CONFIG_ENV] = JSON.stringify({
 			enabled: true,
 			runId: "run-1",
-			agent: "builder",
+			agent: "worker",
 			childIndex: 0,
 			watchdogTailTimeoutMs: 1000,
 			agentEndTimeoutMs: 500,
@@ -586,7 +809,7 @@ describe("subagent prompt runtime", () => {
 
 		assert.ok(rewritten.includes("<name>safe-bash</name>"));
 		assert.ok(!rewritten.includes("<name>pi-subagents</name>"));
-		assert.ok(!rewritten.includes("explorer to subagents"));
+		assert.ok(!rewritten.includes("delegate to subagents"));
 	});
 
 	it("strips explicit pi-subagents skill injection from child prompts", () => {
@@ -619,13 +842,13 @@ describe("subagent prompt runtime", () => {
 			role: "assistant",
 			content: [
 				{ type: "text", text: "I will inspect the repo." },
-				{ type: "toolCall", name: "subagent", input: { agent: "builder" } },
+				{ type: "toolCall", name: "subagent", input: { agent: "worker" } },
 				{ type: "toolCall", name: "read", input: { path: "README.md" } },
 			],
 		};
 		const pureSubagentCall = {
 			role: "assistant",
-			content: [{ type: "toolCall", name: "subagent", input: { agent: "commentator" } }],
+			content: [{ type: "toolCall", name: "subagent", input: { agent: "reviewer" } }],
 		};
 
 		assert.deepEqual(
@@ -644,10 +867,34 @@ describe("subagent prompt runtime", () => {
 		);
 	});
 
+	it("sanitizes non-portable tool ids in forked child context", () => {
+		const assistant = {
+			role: "assistant",
+			content: [
+				{ type: "toolCall", id: "call_read|fc_123", name: "read", input: { path: "README.md" } },
+				{ type: "toolCall", id: "call_bash-ok", name: "bash", input: { command: "pwd" } },
+			],
+		};
+		const readResult = { role: "toolResult", toolName: "read", toolCallId: "call_read|fc_123", content: "file contents" };
+		const bashResult = { role: "toolResult", toolName: "bash", toolCallId: "call_bash-ok", content: "cwd" };
+
+		assert.deepEqual(stripParentOnlySubagentMessages([assistant, readResult, bashResult]), [
+			{
+				role: "assistant",
+				content: [
+					{ type: "toolCall", id: "tool_Y2FsbF9yZWFkfGZjXzEyMw", name: "read", input: { path: "README.md" } },
+					{ type: "toolCall", id: "call_bash-ok", name: "bash", input: { command: "pwd" } },
+				],
+			},
+			{ role: "toolResult", toolName: "read", toolCallId: "tool_Y2FsbF9yZWFkfGZjXzEyMw", content: "file contents" },
+			bashResult,
+		]);
+	});
+
 	it("preserves live nested subagent calls and results in fanout child context", () => {
 		const user = { role: "user", content: "Task" };
 		const subagentResult = { role: "toolResult", toolName: "subagent", content: "OK" };
-		const subagentCall = { role: "assistant", content: [{ type: "toolCall", name: "subagent", input: { agent: "explorer" } }] };
+		const subagentCall = { role: "assistant", content: [{ type: "toolCall", name: "subagent", input: { agent: "delegate" } }] };
 		const instruction = { role: "custom", customType: "subagent-orchestration-instructions", content: "Subagent orchestration is enabled." };
 		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
 
@@ -684,7 +931,7 @@ describe("subagent prompt runtime", () => {
 			const registered: string[] = [];
 			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"]);
 			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "explorer";
+			process.env[SUBAGENT_CHILD_AGENT_ENV] = "scout";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -763,7 +1010,7 @@ describe("subagent prompt runtime", () => {
 			const available = ["read"];
 			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "fixture_search"]);
 			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "extension-builder";
+			process.env[SUBAGENT_CHILD_AGENT_ENV] = "extension-worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -779,7 +1026,7 @@ describe("subagent prompt runtime", () => {
 
 			handlers.get("agent_start")?.({});
 			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
-				agent: "extension-builder",
+				agent: "extension-worker",
 				required: ["read", "fixture_search"],
 				available: ["read"],
 				missing: ["fixture_search"],
@@ -801,7 +1048,7 @@ describe("subagent prompt runtime", () => {
 			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "fixture_search"]);
 			process.env[MCP_DIRECT_CHILD_TOOLS_ENV] = "not-json";
 			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "builder";
+			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -813,7 +1060,7 @@ describe("subagent prompt runtime", () => {
 
 			assert.doesNotThrow(() => handlers.get("agent_start")?.({}));
 			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
-				agent: "builder",
+				agent: "worker",
 				required: ["read", "fixture_search"],
 				available: ["read"],
 				missing: ["fixture_search"],
@@ -831,7 +1078,7 @@ describe("subagent prompt runtime", () => {
 			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "rust_symbols_workspace_symbols", "fixture_search"]);
 			process.env[MCP_DIRECT_CHILD_TOOLS_ENV] = JSON.stringify(["rust_symbols_workspace_symbols"]);
 			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "builder";
+			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -844,7 +1091,7 @@ describe("subagent prompt runtime", () => {
 			handlers.get("agent_start")?.({});
 			const diagnostic = readChildToolDiagnostic(diagnosticPath);
 			assert.deepEqual(diagnostic, {
-				agent: "builder",
+				agent: "worker",
 				required: ["read", "rust_symbols_workspace_symbols", "fixture_search"],
 				available: ["read"],
 				missing: ["rust_symbols_workspace_symbols", "fixture_search"],
@@ -861,7 +1108,7 @@ describe("subagent prompt runtime", () => {
 	it("sets the child intercom session name from env during agent startup", async () => {
 		let sessionName: string | undefined;
 		let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
-		process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV] = "subagent-builder-78f659a3";
+		process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV] = "subagent-worker-78f659a3";
 
 		registerSubagentPromptRuntime({
 			on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) {
@@ -875,7 +1122,7 @@ describe("subagent prompt runtime", () => {
 
 		await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 
-		assert.equal(sessionName, "subagent-builder-78f659a3");
+		assert.equal(sessionName, "subagent-worker-78f659a3");
 	});
 
 	it("rewrites the final child-visible prompt through before_agent_start", async () => {
@@ -924,12 +1171,12 @@ describe("subagent prompt runtime", () => {
 			},
 		} as { on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined): void });
 
-		const priorParentTurn = { role: "user", content: "Earlier we said architect → builder → reviewers → builder." };
+		const priorParentTurn = { role: "user", content: "Earlier we said planner → worker → reviewers → worker." };
 		const currentTask = { role: "user", content: "Now implement only the assigned fix." };
 		const instruction = { role: "custom", customType: "subagent-orchestration-instructions", content: "Subagent orchestration is enabled." };
 		const slashResult = { role: "custom", customType: "subagent-slash-result", content: "## Orchestration" };
 		const subagentResult = { role: "toolResult", toolName: "subagent", content: "subagent results" };
-		const subagentCall = { role: "assistant", content: [{ type: "toolCall", name: "subagent", input: { agent: "builder" } }] };
+		const subagentCall = { role: "assistant", content: [{ type: "toolCall", name: "subagent", input: { agent: "worker" } }] };
 		const watchdogWarning = { role: "custom", customType: SUBAGENT_WATCHDOG_WARNING_TYPE, content: "<subagent_watchdog>parent-only</subagent_watchdog>" };
 		const childWatchdogWarning = { role: "custom", customType: SUBAGENT_WATCHDOG_WARNING_TYPE, content: "<subagent_watchdog>child-visible</subagent_watchdog>", details: { source: "child" } };
 		const otherCustom = { role: "custom", customType: "other", content: "keep" };
@@ -939,13 +1186,56 @@ describe("subagent prompt runtime", () => {
 		});
 	});
 
+	it("bounds composite tool ids for Codex child context", () => {
+		let contextHandler: ((event: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) | undefined;
+		registerSubagentPromptRuntime({
+			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
+				if (event === "context") contextHandler = handler;
+			},
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+
+		const toolCallId = "call_N7iYNRPXLl9czpXh3bDyMpIL|fc_0e76718634eca88f016a76fdc89aec81919763fa7858f67a0d";
+		const messages = [
+			{ role: "user", content: "Task" },
+			{ role: "assistant", content: [{ type: "toolCall", id: toolCallId, name: "read", input: { path: "README.md" } }] },
+			{ role: "toolResult", toolName: "read", toolCallId, content: "file" },
+		];
+
+		const context = contextHandler?.({ messages }, { model: { api: "openai-codex-responses" } });
+		assert.ok(context);
+		const mappedCallId = (context.messages[1] as { content: Array<{ id?: unknown }> }).content[0]?.id;
+		const mappedResultId = (context.messages[2] as { toolCallId?: unknown }).toolCallId;
+		assert.equal(typeof mappedCallId, "string");
+		assert.match(mappedCallId, /^[a-zA-Z0-9_-]+$/);
+		assert.ok(mappedCallId.length <= 64);
+		assert.equal(mappedResultId, mappedCallId);
+	});
+
+	it("preserves composite tool ids for non-Codex APIs that normalize them", () => {
+		let contextHandler: ((event: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) | undefined;
+		registerSubagentPromptRuntime({
+			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
+				if (event === "context") contextHandler = handler;
+			},
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+
+		const toolCallId = "call_7XJjvAJfk07117JO8LgBCZjY|fc_0e92b09b28010bac016a756e9e79cc8197b01825a5dc3d9eaa";
+		const messages = [
+			{ role: "user", content: "Task" },
+			{ role: "assistant", content: [{ type: "toolCall", id: toolCallId, name: "read", input: { path: "README.md" } }] },
+			{ role: "toolResult", toolName: "read", toolCallId, content: "file" },
+		];
+
+		assert.equal(contextHandler?.({ messages }, { model: { api: "openai-responses" } }), undefined);
+	});
+
 	it("does not rewrite child context when no parent-only artifacts are present", () => {
-		let contextHandler: ((event: { messages: unknown[] }) => { messages: unknown[] } | undefined) | undefined;
+		let contextHandler: ((event: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) | undefined;
 		registerSubagentPromptRuntime({
-			on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined) {
+			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
 
 		const messages = [
 			{ role: "user", content: "Task" },
@@ -953,6 +1243,6 @@ describe("subagent prompt runtime", () => {
 			{ role: "assistant", content: [{ type: "toolCall", name: "read", input: { path: "README.md" } }] },
 		];
 
-		assert.equal(contextHandler?.({ messages }), undefined);
+		assert.equal(contextHandler?.({ messages }, {}), undefined);
 	});
 });