@selesai/code 0.13.40 → 0.14.3

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

@@ -3,6 +3,10 @@ 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 type { AssistantMessage, Message, Model, ToolResultMessage } from "@earendil-works/pi-ai";
+import { convertResponsesMessages } from "@earendil-works/pi-ai/api/openai-responses-shared";
+import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
+import { createEventBus } from "../support/helpers.ts";
 import { RUNTIME_EXTENSION_ACK_EVENT } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
 import { clearStructuredOutputCaptures } from "../../src/runs/shared/structured-output.ts";
 import { getAgentDir } from "../../src/shared/utils.ts";
@@ -10,6 +14,11 @@ import { formatChildToolDiagnostic, type ChildToolDiagnostic } from "../../src/r
 import type { ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
 import type { ChildWatchdogConfig } from "../../src/watchdog/child-status.ts";
 import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../src/watchdog/types.ts";
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { createNestedRoute, nestedResultsPath } from "../../src/runs/shared/nested-events.ts";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { INTERCOM_SESSION_IDENTITY_EVENT, SUBAGENT_ASYNC_COMPLETE_EVENT, TEMP_ROOT_DIR, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type SubagentState } from "../../src/shared/types.ts";
 import registerSubagentPromptRuntime, {
 	CHILD_FANOUT_BOUNDARY_INSTRUCTIONS,
 	CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS,
@@ -26,6 +35,149 @@ function childConfig(overrides: Partial<ChildRuntimeConfig> = {}): ChildRuntimeC
 	return { fanoutChild: false, depth: 1, waitTool: { enabled: true }, fast: false, ...overrides };
 }
 
+it("does not skip drain for in-process child sessions when hasUI is true", async () => {
+	const handlers = new Map<string, Function[]>();
+	const listeners = new Map<string, Array<() => void>>();
+	const held: boolean[] = [];
+	const sessionId = "reviewer-ui-session.jsonl";
+	const runtimeState = {
+		foregroundRuns: new Map([["fg", {
+			runId: "fg", mode: "single", cwd: "/tmp", sessionId, updatedAt: 1,
+			children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
+		}]]),
+	} as SubagentState;
+	const ctx = { hasUI: true, sessionManager: { getSessionFile: () => sessionId } };
+	const emit = async (name: string, event: unknown) => { for (const fn of handlers.get(name) ?? []) await fn(event, ctx); };
+	registerSubagentPromptRuntime({
+		on: (name: string, fn: Function) => handlers.set(name, [...(handlers.get(name) ?? []), fn]),
+		registerTool: () => {},
+		events: { on: (channel: string, handler: () => void) => { listeners.set(channel, [...(listeners.get(channel) ?? []), handler]); return () => {}; } },
+	} as never, childConfig({ runtimeState, holdFinalDrain: (value) => { held.push(value); } }));
+	await emit("session_start", {});
+	let settled = false;
+	const ended = emit("agent_end", { messages: [] }).then(() => { settled = true; });
+	await new Promise((resolve) => setTimeout(resolve, 30));
+	assert.equal(settled, false);
+	assert.deepEqual(held, [true]);
+	runtimeState.foregroundRuns.get("fg")!.children[0]!.status = "completed";
+	for (const handler of listeners.get(SUBAGENT_FOREGROUND_COMPLETE_EVENT) ?? []) handler();
+	await ended;
+	assert.equal(settled, true);
+	assert.deepEqual(held, [true, false]);
+});
+
+it("reads a late-installed owner barrier for each final drain and balances the hold", async () => {
+	const handlers = new Map<string, Function[]>();
+	const listeners = new Map<string, Array<() => void>>();
+	const held: boolean[] = [];
+	const sessionId = "fanout-owner-session.jsonl";
+	const runtimeState = {
+		foregroundRuns: new Map([["fg", {
+			runId: "fg", mode: "single", cwd: "/tmp", sessionId, updatedAt: 1,
+			children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
+		}]]),
+	} as SubagentState;
+	const config = childConfig({ runtimeState, holdFinalDrain: (value) => { held.push(value); } });
+	const ctx = { hasUI: true, sessionManager: { getSessionFile: () => sessionId } };
+	const emit = async (name: string) => { for (const fn of handlers.get(name) ?? []) await fn({}, ctx); };
+	registerSubagentPromptRuntime({
+		on: (name: string, fn: Function) => handlers.set(name, [...(handlers.get(name) ?? []), fn]),
+		registerTool: () => {},
+		events: { on: (channel: string, handler: () => void) => { listeners.set(channel, [...(listeners.get(channel) ?? []), handler]); return () => {}; } },
+	} as never, config);
+	await emit("session_start");
+	let pending = true;
+	config.hasPendingSupervisorRequest = () => pending;
+	await emit("agent_end");
+	assert.deepEqual(held, [true, false]);
+	assert.equal(runtimeState.foregroundRuns.get("fg")!.children[0]!.status, "detached");
+
+	pending = false;
+	let settled = false;
+	const ended = emit("agent_end").then(() => { settled = true; });
+	await new Promise((resolve) => setTimeout(resolve, 30));
+	assert.equal(settled, false);
+	runtimeState.foregroundRuns.get("fg")!.children[0]!.status = "completed";
+	for (const handler of listeners.get(SUBAGENT_FOREGROUND_COMPLETE_EVENT) ?? []) handler();
+	await ended;
+	assert.deepEqual(held, [true, false, true, false]);
+});
+
+it("does not grant nested wait access for an invalid inherited route", async (t) => {
+	const route = createNestedRoute(randomUUID());
+	const runId = randomUUID();
+	const root = path.join(TEMP_ROOT_DIR, "nested-subagent-runs", route.rootRunId);
+	const dir = path.join(root, runId);
+	t.after(() => { for (const entry of [root, path.dirname(route.eventSink)]) fs.rmSync(entry, { recursive: true, force: true }); });
+	t.mock.method(console, "error", () => {});
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify({ runId, sessionId: "owner", mode: "single", state: "running", pid: process.pid, startedAt: Date.now(), steps: [] }));
+	updateActiveRunIndex(dir, "running");
+	const tools = new Map<string, { execute: Function }>();
+	// SAFETY: this fixture supplies the registration API and session identity used by the empty wait path.
+	registerSubagentPromptRuntime({
+		on: () => {}, registerTool: (tool: { name: string; execute: Function }) => tools.set(tool.name, tool),
+	} as never, childConfig({ runtimeState: { currentSessionId: "owner" } as SubagentState, nestedRoute: { ...route, capabilityToken: "invalid" } }));
+	const result = await tools.get("bg_wait")!.execute("wait", { id: runId, timeoutMs: 1 });
+	assert.match(result.content[0].text, /No active run matched/);
+});
+
+it("registered child bg_wait discovers nested personas and agent_end drains the same scope", async () => {
+	const route = createNestedRoute(randomUUID());
+	const runId = randomUUID();
+	const asyncRoot = path.join(TEMP_ROOT_DIR, "nested-subagent-runs", route.rootRunId);
+	const asyncDir = path.join(asyncRoot, runId);
+	const resultPath = nestedResultsPath(route.rootRunId, runId);
+	const sessionId = "nested-reviewer-session.jsonl";
+	const handlers = new Map<string, Function[]>();
+	const events = createEventBus();
+	const tools = new Map<string, { execute: Function }>();
+	const held: boolean[] = [];
+	const ctx = { hasUI: false, sessionManager: { getSessionFile: () => sessionId } };
+	const emit = async (event: string) => { for (const fn of handlers.get(event) ?? []) await fn({}, ctx); };
+	const writeStatus = (state: "running" | "complete") => {
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+			runId, sessionId, mode: "single", state, pid: process.pid,
+			startedAt: Date.now(), lastUpdate: Date.now(), steps: [{ agent: "persona", status: state }],
+		}));
+		updateActiveRunIndex(asyncDir, state);
+	};
+	try {
+		// SAFETY: this fixture supplies the registration/event APIs exercised by the wait and drain hooks.
+		registerSubagentPromptRuntime({
+			on: (event: string, fn: Function) => handlers.set(event, [...(handlers.get(event) ?? []), fn]),
+			registerTool: (tool: { name: string; execute: Function }) => tools.set(tool.name, tool),
+			events,
+		} as never, childConfig({ fanoutChild: true, nestedRoute: route, holdFinalDrain: (value) => { held.push(value); } }));
+		await emit("session_start");
+		writeStatus("running");
+		const wait = tools.get("bg_wait")!;
+		const timed = await wait.execute("wait", { id: runId, timeoutMs: 1 }, undefined, undefined, ctx);
+		assert.deepEqual(timed.details.wait?.activeRunIds, [runId], "registered wait must discover its nested persona");
+
+		let settled = false;
+		const draining = emit("agent_end").then(() => { settled = true; });
+		await new Promise((resolve) => setTimeout(resolve, 20));
+		assert.equal(settled, false, "agent_end cannot skip the nested namespace");
+		assert.deepEqual(held, [true]);
+		fs.mkdirSync(path.dirname(resultPath), { recursive: true });
+		fs.writeFileSync(resultPath, JSON.stringify({ runId, sessionId, success: true, results: [{ agent: "persona", output: "PERSONA_EVIDENCE" }] }));
+		writeStatus("complete");
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, undefined);
+		await draining;
+		assert.deepEqual(held, [true, false]);
+		const terminal = await wait.execute("collect", { id: runId }, undefined, undefined, ctx);
+		assert.equal(terminal.details.completions?.[0]?.runId, runId);
+		assert.ok(terminal.content.some((part: { text?: string }) => part.text?.includes(resultPath)), "model receives a readable result reference, not details alone");
+		assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf8")).results[0].output, "PERSONA_EVIDENCE");
+	} finally {
+		fs.rmSync(asyncRoot, { recursive: true, force: true });
+		fs.rmSync(path.dirname(resultPath), { recursive: true, force: true });
+		fs.rmSync(path.dirname(route.eventSink), { recursive: true, force: true });
+	}
+});
+
 function supervisorConfig(overrides: Partial<ChildRuntimeConfig> = {}): ChildRuntimeConfig {
 	return childConfig({
 		orchestratorTarget: "subagent-chat-parent",
@@ -75,6 +227,66 @@ describe("subagent prompt runtime", () => {
 		assert.doesNotThrow(() => registerSubagentPromptRuntime({} as never));
 	});
 
+	it("registers a requested watchdog_diff at launch HEAD and reports unavailable baseline outside Git", async (t) => {
+		const repo = fs.mkdtempSync(path.join(os.tmpdir(), "reviewer-runtime-diff-"));
+		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "reviewer-runtime-no-git-"));
+		t.after(() => {
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(outside, { recursive: true, force: true });
+		});
+		execFileSync("git", ["init", "-q"], { cwd: repo });
+		execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: repo });
+		execFileSync("git", ["config", "user.name", "Test User"], { cwd: repo });
+		fs.writeFileSync(path.join(repo, "tracked.txt"), "base\n");
+		execFileSync("git", ["add", "."], { cwd: repo });
+		execFileSync("git", ["commit", "-q", "-m", "base"], { cwd: repo });
+
+		const registered = new Map<string, unknown>();
+		const handlers = new Map<string, Function>();
+		const diagnostics: Array<ChildToolDiagnostic | undefined> = [];
+		registerSubagentPromptRuntime({
+			on: (event: string, handler: Function) => handlers.set(event, handler),
+			registerTool: (tool: { name: string }) => registered.set(tool.name, tool),
+			getAllTools: () => [...registered.keys()].map((name) => ({ name })),
+		} as never, childConfig({ cwd: repo, requiredTools: ["watchdog_diff"], toolDiagnostic: (value) => diagnostics.push(value) }));
+		assert.ok(registered.has("watchdog_diff"), "the required child runtime registers the bounded diff tool");
+		handlers.get("agent_start")?.({});
+		assert.equal(diagnostics.at(-1), undefined);
+		fs.writeFileSync(path.join(repo, "tracked.txt"), "changed\n");
+		const diffTool = registered.get("watchdog_diff") as { execute(id: string, params: object): Promise<{ content: Array<{ text: string }> }> };
+		const result = await diffTool.execute("review", {});
+		assert.match(result.content[0]?.text ?? "", /\+changed/);
+		assert.equal(registered.has("contact_supervisor"), false, "reviewing the fixture needs no supervisor contact");
+
+		const outsideTools = new Map<string, unknown>();
+		const outsideHandlers = new Map<string, Function>();
+		const outsideDiagnostics: Array<ChildToolDiagnostic | undefined> = [];
+		registerSubagentPromptRuntime({
+			on: (event: string, handler: Function) => outsideHandlers.set(event, handler),
+			registerTool: (tool: { name: string }) => outsideTools.set(tool.name, tool),
+			getAllTools: () => [...outsideTools.keys()].map((name) => ({ name })),
+		} as never, childConfig({ cwd: outside, requiredTools: ["watchdog_diff"], toolDiagnostic: (value) => outsideDiagnostics.push(value) }));
+		assert.equal(outsideTools.has("watchdog_diff"), true);
+		assert.doesNotThrow(() => outsideHandlers.get("agent_start")?.({}));
+		assert.deepEqual(outsideDiagnostics, [undefined]);
+		const unavailable = outsideTools.get("watchdog_diff") as { execute(id: string, params: object): Promise<{ content: Array<{ type: string; text: string }>; details: { chars: number } }> };
+		const unavailableResult = await unavailable.execute("review", {});
+		assert.equal(unavailableResult.content[0]?.type, "text");
+		assert.match(unavailableResult.content[0]?.text ?? "", /no valid Git HEAD baseline/);
+		assert.match(unavailableResult.content[0]?.text ?? "", /No diff can be shown/);
+		assert.equal(unavailableResult.details.chars, unavailableResult.content[0]?.text.length);
+		assert.deepEqual(await unavailable.execute("review", { path: "tracked.txt", stat: true }), unavailableResult);
+		assert.equal(outsideTools.has("contact_supervisor"), false);
+
+		const missingHandlers = new Map<string, Function>();
+		registerSubagentPromptRuntime({
+			on: (event: string, handler: Function) => missingHandlers.set(event, handler),
+			registerTool: (tool: { name: string }) => outsideTools.set(tool.name, tool),
+			getAllTools: () => [...outsideTools.keys()].map((name) => ({ name })),
+		} as never, childConfig({ cwd: outside, requiredTools: ["watchdog_diff", "fixture_search"] }));
+		assert.throws(() => missingHandlers.get("agent_start")?.({}), /requested unavailable child tools: fixture_search/);
+	});
+
 	it("registers no permission hook by default and routes ask only to the watchdog arbiter", async () => {
 		const handlers: Array<(event: { toolName?: string; input?: unknown }, ctx?: unknown) => unknown> = [];
 		const pi = { on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx?: unknown) => unknown) { if (event === "tool_call") handlers.push(handler); } };
@@ -199,31 +411,38 @@ describe("subagent prompt runtime", () => {
 	it("registered structured_output tool accepts valid schema output and captures it", async () => {
 		{
 			const captured: unknown[] = [];
+			const terminalState = { captured: false };
 			let execute: ((_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }>) | undefined;
 			let parameters: unknown;
+			let exposure: unknown;
 
 			registerSubagentPromptRuntime({
-				registerTool(tool: { name: string; parameters: unknown; execute: (_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }> }) {
+				registerTool(tool: { name: string; parameters: unknown; exposure?: string; execute: (_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }> }) {
 					if (tool.name === "structured_output") {
 						execute = tool.execute;
 						parameters = tool.parameters;
+						exposure = tool.exposure;
 					}
 				},
 				on() {},
 			} as { registerTool(tool: { name: string; parameters: unknown; execute: (_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }> }): void; on(): void }, childConfig({
-				structuredOutput: { schema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } }, capture: (value) => captured.push(value) },
+				structuredOutput: { schema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } }, terminalState, capture: (value) => captured.push(value) },
 			}));
 
 			assert.ok(execute, "structured_output tool should be registered");
+			assert.equal(exposure, "model-only", "a nested structured_output call cannot terminate the step");
 			assert.deepEqual(parameters, {
 				type: "object",
 				properties: { value: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } } },
 				required: ["value"],
 				additionalProperties: false,
 			});
+			await assert.rejects(execute("invalid", { value: { ok: "not-boolean" } }), /validation failed/);
+			assert.equal(terminalState.captured, false, "schema rejection is not a terminal capture");
 			const result = await execute("tool-1", { value: { ok: true } });
 			assert.equal(result.terminate, true);
 			assert.deepEqual(captured, [{ ok: true }]);
+			assert.equal(terminalState.captured, true);
 		}
 	});
 
@@ -469,13 +688,23 @@ describe("subagent prompt runtime", () => {
 			inheritSkills: true,
 		});
 
-		assert.ok(rewritten.startsWith(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS));
+		assert.ok(rewritten.endsWith(`\n\n${CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS}`));
 		assert.ok(rewritten.includes("Do not propose or run subagents."));
 		assert.ok(rewritten.includes("If you need to edit files, use the available editing tools."));
 		assert.ok(!rewritten.includes("call the actual edit/write tools"));
 		assert.ok(rewritten.includes("Do not print tool-call syntax, patches, or pseudo-tool calls as text."));
-		assert.equal(rewriteSubagentPrompt(rewritten, { inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true }).indexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS), 0);
-		assert.equal(rewriteSubagentPrompt(rewritten, { inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true }).lastIndexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS), 0);
+		assert.equal(rewriteSubagentPrompt(rewritten, { inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true }), rewritten);
+	});
+
+	it("keeps Pi's base prompt first and appends the boundary and structured-output instructions once", () => {
+		const piPrompt = "You are an expert coding assistant operating inside pi, a coding agent harness.\n\nAvailable tools:\n- read\n\nCurrent working directory: /repo";
+		const options = { inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true, structuredOutput: true };
+		const rewritten = rewriteSubagentPrompt(piPrompt, options);
+
+		assert.ok(rewritten.startsWith("You are an expert coding assistant operating inside pi"));
+		assert.ok(rewritten.indexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS) > rewritten.indexOf("Current working directory: /repo"));
+		assert.ok(rewritten.endsWith("if you do not call `structured_output`, the parent will fail this step."));
+		assert.equal(rewriteSubagentPrompt(rewritten, options), rewritten);
 	});
 
 	it("replaces inherited child boundaries with the fanout boundary when authorized", () => {
@@ -487,12 +716,13 @@ describe("subagent prompt runtime", () => {
 			fanoutChild: true,
 		});
 
-		assert.ok(rewritten.startsWith(CHILD_FANOUT_BOUNDARY_INSTRUCTIONS));
+		assert.ok(rewritten.startsWith("You are a subagent."));
+		assert.ok(rewritten.endsWith(`\n\n${CHILD_FANOUT_BOUNDARY_INSTRUCTIONS}`));
 		assert.ok(rewritten.includes("You may use the `subagent` tool only for the fanout work explicitly requested in this task."));
 		assert.ok(rewritten.includes("If you need to edit files, use the available editing tools."));
 		assert.ok(!rewritten.includes("call the actual edit/write tools"));
 		assert.ok(!rewritten.includes("Do not propose or run subagents."));
-		assert.equal(rewritten.lastIndexOf(CHILD_FANOUT_BOUNDARY_INSTRUCTIONS), 0);
+		assert.equal(rewritten.indexOf(CHILD_FANOUT_BOUNDARY_INSTRUCTIONS), rewritten.lastIndexOf(CHILD_FANOUT_BOUNDARY_INSTRUCTIONS));
 	});
 
 	it("replaces inherited fanout boundaries with the strict boundary when fanout is not authorized", () => {
@@ -503,9 +733,10 @@ describe("subagent prompt runtime", () => {
 			inheritSkills: true,
 		});
 
-		assert.ok(rewritten.startsWith(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS));
+		assert.ok(rewritten.startsWith("You are a subagent."));
+		assert.ok(rewritten.endsWith(`\n\n${CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS}`));
 		assert.ok(!rewritten.includes("explicit fanout responsibility"));
-		assert.equal(rewritten.lastIndexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS), 0);
+		assert.equal(rewritten.indexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS), rewritten.lastIndexOf(CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS));
 	});
 
 	it("keeps explicitly injected skill content when inherited skills are stripped", () => {
@@ -823,29 +1054,36 @@ describe("subagent prompt runtime", () => {
 				missing: ["rust_symbols_workspace_symbols", "fixture_search"],
 				missingMcpDirectTools: ["rust_symbols_workspace_symbols"],
 			});
-			assert.match(formatChildToolDiagnostic(diagnostic!), /host\/pi-mcp-adapter registration problem/);
+			assert.match(formatChildToolDiagnostic(diagnostic!), /must match what the host or pi-mcp-adapter registers/);
 			assert.match(formatChildToolDiagnostic(diagnostic!), /fixture_search/);
 		}
 	});
 
-	it("sets the child intercom session name from the config during agent startup", async () => {
-		let sessionName: string | undefined;
-		let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
+	for (const intercomAsks of [true, false]) {
+		it(`names an intercom child ${intercomAsks ? "readably when pi-intercom takes its route as the intercom ID" : "by its route when pi-intercom does not ask for an ID"}`, async () => {
+			const events = createEventBus();
+			let sessionName: string | undefined;
+			let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
 
-		registerSubagentPromptRuntime({
-			on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) {
-				if (event === "before_agent_start") beforeAgentStart = handler;
-			},
-			getAllTools: () => [{ name: "intercom" }, { name: "contact_supervisor" }],
-			setSessionName(name: string) {
-				sessionName = name;
-			},
-		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }>; setSessionName(name: string): void }, childConfig({ intercomSessionName: "subagent-worker-78f659a3", sessionName: "worker: display name" }));
+			registerSubagentPromptRuntime({
+				events,
+				on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) {
+					if (event === "before_agent_start") beforeAgentStart = handler;
+				},
+				getAllTools: () => [{ name: "intercom" }, { name: "contact_supervisor" }],
+				setSessionName(name: string) {
+					sessionName = name;
+				},
+			} as never, childConfig({ intercomSessionName: "subagent-worker-78f659a3", sessionName: "worker: display name" }));
 
-		await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
+			const claimed: string[] = [];
+			if (intercomAsks) events.emit(INTERCOM_SESSION_IDENTITY_EVENT, { version: 1, claim: (id: string) => claimed.push(id) });
+			await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 
-		assert.equal(sessionName, "subagent-worker-78f659a3");
-	});
+			assert.deepEqual(claimed, intercomAsks ? ["subagent-worker-78f659a3"] : []);
+			assert.equal(sessionName, intercomAsks ? "worker: display name" : "subagent-worker-78f659a3");
+		});
+	}
 
 	it("rewrites the final child-visible prompt through before_agent_start", async () => {
 		let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
@@ -876,7 +1114,8 @@ describe("subagent prompt runtime", () => {
 
 		const rewritten = await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 		assert.ok(rewritten);
-		assert.ok(rewritten.systemPrompt.startsWith(CHILD_FANOUT_BOUNDARY_INSTRUCTIONS));
+		assert.ok(rewritten.systemPrompt.startsWith("You are a subagent."));
+		assert.ok(rewritten.systemPrompt.endsWith(`\n\n${CHILD_FANOUT_BOUNDARY_INSTRUCTIONS}`));
 	});
 
 	it("filters parent-only artifacts from polluted fork context while preserving ordinary history", () => {
@@ -902,29 +1141,89 @@ 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;
+	describe("Codex child context tool ids on the Responses wire", () => {
+		const model: Model<"openai-codex-responses"> = {
+			id: "codex-test", name: "Codex test", api: "openai-codex-responses", provider: "openai-codex",
+			baseUrl: "https://example.invalid", reasoning: true, input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 128000, maxTokens: 4096,
+		};
+		let contextHandler: ((event: { messages: unknown[] }, ctx: { model: typeof model }) => { messages: unknown[] } | undefined) | undefined;
 		registerSubagentPromptRuntime({
-			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
+			on(event: string, handler: typeof contextHandler) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void }, childConfig());
+		} as never, childConfig());
 
-		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" },
-		];
+		function history(toolCallId: string): Message[] {
+			return [
+				{ role: "user", content: "Task", timestamp: 1 },
+				{
+					role: "assistant", api: model.api, provider: model.provider, model: model.id,
+					content: [{ type: "toolCall", id: toolCallId, name: "read", arguments: { path: "README.md" } }],
+					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+					stopReason: "toolUse", timestamp: 2,
+				},
+				{ role: "toolResult", toolName: "read", toolCallId, content: [{ type: "text", text: "file" }], isError: false, timestamp: 3 },
+			];
+		}
 
-		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);
+		function assertWire(messages: Message[], callId: string, itemId: string | undefined): void {
+			const wire = convertResponsesMessages(model, normalizeContext({ messages }), new Set(["openai", "openai-codex", "opencode"]));
+			assert.deepEqual(wire.filter((item) => item.type === "function_call" || item.type === "function_call_output"), [
+				{ type: "function_call", id: itemId, call_id: callId, name: "read", arguments: '{"path":"README.md"}' },
+				{ type: "function_call_output", call_id: callId, output: "file" },
+			]);
+		}
+
+		for (const [label, toolCallId] of [
+			["original #903 fixture", "call_N7iYNRPXLl9czpXh3bDyMpIL|fc_0e76718634eca88f016a76fdc89aec81919763fa7858f67a0d"],
+			["exactly 64 characters per half", `${"a".repeat(64)}|fc_${"b".repeat(61)}`],
+			["portable mixed charset", "call_AZaz09_-|fc_AZaz09_-"],
+			["non-fc_ item (serializer omits item id)", "call_read|ctc_item"],
+			["ordinary portable single id", "call_read-OK_09"],
+		] as const) {
+			it(`preserves ${label}`, () => {
+				const messages = history(toolCallId);
+				assert.ok(contextHandler);
+				assert.equal(contextHandler({ messages }, { model }), undefined, "preservation must not rewrite context");
+				const [callId, itemId] = toolCallId.split("|");
+				assertWire(messages, callId!, itemId?.startsWith("fc_") ? itemId : undefined);
+			});
+		}
+
+		for (const [label, toolCallId] of [
+			["65-character call half", `${"a".repeat(65)}|fc_item`],
+			["65-character item half", `call_read|fc_${"b".repeat(62)}`],
+			["both halves oversized", `${"a".repeat(65)}|fc_${"b".repeat(62)}`],
+			["empty call half", "|fc_item"],
+			["empty item half", "call_read|"],
+			["both halves empty", "|"],
+			["extra separator", "call_read|fc_item|extra"],
+			["invalid call charset", "call.read|fc_item"],
+			["invalid item charset", "call_read|fc_item/bad"],
+			["whitespace", "call_read|fc_item\n"],
+			["non-ASCII", "call_read|fc_é"],
+			["empty single id", ""],
+			["oversized single id", "a".repeat(65)],
+		] as const) {
+			it(`uses the deterministic bounded fallback for ${label}`, () => {
+				const messages = history(toolCallId);
+				assert.ok(contextHandler);
+				const context = contextHandler({ messages }, { model });
+				assert.ok(context);
+				assert.deepEqual(context.messages, stripParentOnlySubagentMessages(messages), "fallback must match the existing default sanitizer");
+				assert.deepEqual(contextHandler({ messages }, { model }), context, "mapping must be deterministic");
+				const assistant = context.messages[1] as AssistantMessage;
+				const call = assistant.content[0];
+				assert.equal(call?.type, "toolCall");
+				if (call?.type !== "toolCall") assert.fail("expected tool call");
+				assert.notEqual(call.id, toolCallId);
+				assert.match(call.id, /^[A-Za-z0-9_-]+$/);
+				assert.ok(call.id.length <= 64);
+				assert.equal((context.messages[2] as ToolResultMessage).toolCallId, call.id);
+				assertWire(context.messages as Message[], call.id, undefined);
+			});
+		}
 	});
 
 	it("preserves composite tool ids for non-Codex APIs that normalize them", () => {