@selesai/code 0.13.16 → 0.13.19

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

@@ -13,7 +13,7 @@ import {
 	resolveModelCandidate,
 	resolveSubagentModelOverride,
 } from "../../src/runs/shared/model-fallback.ts";
-import { clearExclusions, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
+import { clearExclusions, findModelExclusion, getExcludedCount, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
 import { resolveModelScopesForAgent } from "../../src/runs/shared/model-scope.ts";
 
 beforeEach(() => clearExclusions());
@@ -30,10 +30,15 @@ describe("model fallback helpers", () => {
 	});
 
 	it("fails verification when the child reports an unregistered different model", () => {
-		assert.match(
-			formatSubagentModelVerificationError("openai/gpt-5-mini:high", "unknown-provider/wrong-model", availableModels) ?? "",
-			/model_verification_failed/,
-		);
+		const error = formatSubagentModelVerificationError("openai/gpt-5-mini:high", "unknown-provider/wrong-model", availableModels) ?? "";
+		assert.match(error, /model_verification_failed: native Pi child/);
+		assert.match(error, /Expected 'openai\/gpt-5-mini:high' but observed 'unknown-provider\/wrong-model'/);
+		assert.match(error, /independently verified/);
+		assert.match(error, /modelResponseAliases in ~\/\.selesai\/agent\/extensions\/subagent\/config\.json/);
+		assert.match(error, /docs\/configuration\.md#modelresponsealiases/);
+		assert.match(error, /resolved provider\/model ID without its thinking suffix/);
+		assert.match(error, /outgoing request unchanged/);
+		assert.match(error, /Configuration changes affect new independent native runs; resumed native runs retain their launch-time declaration\. External CLI adapters do not use this setting\./);
 	});
 
 	it("accepts child-reported bare model ids for the expected registry entry", () => {
@@ -86,6 +91,27 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("accepts exact response aliases only for the resolved candidate route", () => {
+		const route = "litellm/claude-haiku-4-5";
+		const responseId = "anthropic.claude-haiku-4-5-20251001-v1:0";
+		const registry = [{ provider: "litellm", id: "claude-haiku-4-5", fullId: route }];
+		const aliases = { [route]: [responseId] };
+		const candidate = resolveModelCandidate("claude-haiku-4-5:high", registry)!;
+		assert.equal(candidate, `${route}:high`);
+		assert.equal(formatSubagentModelVerificationError(candidate, responseId, registry, aliases), undefined);
+		for (const expected of ["other-provider/claude-haiku-4-5", "litellm/other-route", "claude-haiku-4-5"]) {
+			assert.match(formatSubagentModelVerificationError(expected, responseId, registry, aliases) ?? "", /model_verification_failed/);
+		}
+		for (const observed of [`wrong-provider/${responseId}`, "anthropic.claude-haiku-4-5-20251002-v1:0", "claude-sonnet-4", responseId.toUpperCase(), `${responseId}:high`]) {
+			assert.match(formatSubagentModelVerificationError(candidate, observed, registry, aliases) ?? "", /model_verification_failed/);
+		}
+		for (const map of [undefined, {}, { [route]: [] }]) {
+			assert.match(formatSubagentModelVerificationError(candidate, responseId, registry, map) ?? "", /model_verification_failed/);
+		}
+		assert.equal(formatSubagentModelVerificationError(candidate, "response:high", registry, { [route]: ["response:high"] }), undefined);
+		assert.match(formatSubagentModelVerificationError(candidate, "response", registry, { [route]: ["response:high"] }) ?? "", /model_verification_failed/);
+	});
+
 	it("resolves unique owner/name ids when the owner is not a registered provider", () => {
 		const registry = [
 			...availableModels,
@@ -184,6 +210,60 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("does not cache context overflow even when upstream makes it retryable", () => {
+		const error = "upstream: maximum context length exceeded";
+		assert.equal(isRetryableModelFailure(error), true);
+		assert.equal(isContextOverflow(error), true);
+		recordRetryableModelFailure("openai/gpt-5-mini", error);
+		assert.equal(getExcludedCount(), 0);
+	});
+
+	it("does not cache the reported Databricks tool-message request error (issue #1955)", () => {
+		const model = "databricks/databricks-kimi-k3";
+		const error = 'Databricks error: {"error_code":"BAD_REQUEST","message":"{\\"error\\":\\"Upstream error: INVALID_ARGUMENT: Kimi K3 tool messages need a resolvable tool name: carry `tool`/`name`, or match a preceding assistant tool_call by order.\\"}"}';
+		assert.equal(isRetryableModelFailure(error), true);
+		const messages = [{ role: "assistant", errorMessage: error }];
+		assert.equal(isRetryableModelFailureAttempt({ error, messages, toolCount: 0 }), true);
+		assert.equal(isRetryableModelFailureAttempt({ error, messages, toolCount: 1 }), false);
+		recordRetryableModelFailure(model, error);
+		assert.equal(findModelExclusion(model), undefined);
+		assert.equal(getExcludedCount(), 0);
+		assert.deepEqual(buildModelCandidates(model, undefined, undefined), [model]);
+	});
+
+	it("does not cache request-shape errors despite retryable upstream prose", () => {
+		for (const error of [
+			"Bad Request: upstream rejected the request",
+			"BAD_REQUEST: upstream rejected the request",
+			"INVALID_ARGUMENT: upstream rejected the request",
+			"invalid_request_error: upstream rejected the request",
+		]) {
+			assert.equal(isRetryableModelFailure(error), true, error);
+			recordRetryableModelFailure("openai/gpt-5-mini", error);
+			assert.equal(getExcludedCount(), 0, error);
+		}
+	});
+
+	it("still caches rate limits that mention numeric request quotas", () => {
+		const error = "rate limit exceeded: 400 requests per minute";
+		recordRetryableModelFailure("openai/gpt-5-mini", error);
+		assert.equal(findModelExclusion("openai/gpt-5-mini")?.reason, error);
+		assert.equal(getExcludedCount(), 1);
+	});
+
+	it("still caches raw request limits and per-minute input-token rate quotas", () => {
+		for (const error of [
+			"REQUEST_LIMIT_EXCEEDED",
+			'{"error_code":"REQUEST_LIMIT_EXCEEDED","message":"REQUEST_LIMIT_EXCEEDED: Exceeded workspace input tokens per minute rate limit for <model>."}',
+		]) {
+			clearExclusions();
+			assert.equal(isContextOverflow(error), false);
+			recordRetryableModelFailure("openai/gpt-5-mini", error);
+			assert.equal(findModelExclusion("openai/gpt-5-mini")?.reason, error);
+			assert.equal(getExcludedCount(), 1);
+		}
+	});
+
 	it("applies the current provider preference to fallback candidates too", () => {
 		const ambiguous = [
 			...availableModels,
@@ -250,6 +330,19 @@ describe("model fallback helpers", () => {
 		assert.equal(warnings.some((warning) => warning.includes("Skipping primary model 'does-not-exist'")), false);
 	});
 
+	it("fails closed when fallback-only configuration resolves no candidates", () => {
+		const originalWarn = console.warn;
+		console.warn = () => {};
+		try {
+			assert.throws(
+				() => buildModelCandidates(undefined, ["does-not-exist"], availableModels),
+				/Unknown subagent model 'does-not-exist'/,
+			);
+		} finally {
+			console.warn = originalWarn;
+		}
+	});
+
 	it("keeps an explicit unknown primary strict even when fallbacks exist", () => {
 		assert.throws(
 			() => buildModelCandidates("does-not-exist", ["anthropic/claude-sonnet-4"], availableModels, undefined, { origin: "explicit" }),
@@ -264,6 +357,40 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("ignores stale model-not-found exclusions when the model is back in the registry", () => {
+		recordModelFailure({
+			modelId: "gpt-5-mini",
+			provider: "openai",
+			reason: 'Model "openai/gpt-5-mini" not found. Use --list-models to see available models.',
+		});
+		assert.deepEqual(buildModelCandidates("openai/gpt-5-mini", undefined, availableModels), ["openai/gpt-5-mini"]);
+	});
+
+	it("keeps provider-wide exclusions when ignoring a stale model-not-found entry", () => {
+		recordModelFailure({ provider: "openai", reason: "quota exceeded" });
+		recordModelFailure({
+			modelId: "gpt-5-mini",
+			provider: "openai",
+			reason: 'Model "openai/gpt-5-mini" not found. Use --list-models to see available models.',
+		});
+		assert.throws(
+			() => buildModelCandidates("openai/gpt-5-mini", undefined, availableModels),
+			/No usable subagent models remain after registry, scope, and cached-exclusion filtering/,
+		);
+	});
+
+	it("keeps explicit stale model-not-found exclusions strict", () => {
+		recordModelFailure({
+			modelId: "gpt-5-mini",
+			provider: "openai",
+			reason: 'Model "openai/gpt-5-mini" not found. Use --list-models to see available models.',
+		});
+		assert.throws(
+			() => buildModelCandidates("openai/gpt-5-mini", ["anthropic/claude-sonnet-4"], availableModels, undefined, { origin: "explicit" }),
+			/Requested subagent model 'openai\/gpt-5-mini' is excluded and cannot be replaced by a fallback/,
+		);
+	});
+
 	it("keeps an explicit cached-excluded primary strict even when fallbacks exist", () => {
 		recordModelFailure({ modelId: "gpt-5-mini", provider: "openai", reason: "sk-secret-token-xyz" });
 		assert.throws(
@@ -290,11 +417,67 @@ describe("model fallback helpers", () => {
 			(error: unknown) => {
 				const message = String(error);
 				return /No usable subagent models remain after registry, scope, and cached-exclusion filtering/.test(message)
+					&& /excluded: openai\/gpt-5-mini — model: gpt-5-mini; provider: openai; reason: \[redacted\]; expires: \d{4}-\d{2}-\d{2}T/.test(message)
+					&& /excluded: .*anthropic\/claude-sonnet-4/.test(message)
 					&& !message.includes("sk-secret-token-xyz");
 			},
 		);
 	});
 
+	it("keeps cached-exclusion diagnostics when an unrelated fallback is unavailable", () => {
+		recordModelFailure({ modelId: "gpt-5-mini", provider: "openai", reason: "sk-secret-token-xyz" });
+		const originalWarn = console.warn;
+		console.warn = () => {};
+		try {
+			assert.throws(
+				() => buildModelCandidates("openai/gpt-5-mini", ["does-not-exist"], availableModels),
+				/No usable subagent models remain after registry, scope, and cached-exclusion filtering/,
+			);
+		} finally {
+			console.warn = originalWarn;
+		}
+	});
+
+	it("bounds and sanitizes excluded-candidate evidence", () => {
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message: unknown) => warnings.push(String(message));
+		const candidates = Array.from({ length: 21 }, (_, index) => ({
+			provider: index === 0 ? "sk-provider-secret" : "diagnostic-provider",
+			id: index === 0 ? "sk-model-secret" : `diagnostic-model-${index}`,
+			fullId: index === 0 ? "sk-provider-secret/sk-model-secret" : `diagnostic-provider/diagnostic-model-${index}`,
+		}));
+		for (const [index, candidate] of candidates.entries()) {
+			recordModelFailure({
+				modelId: candidate.id,
+				provider: candidate.provider,
+				reason: index === 0 ? "Bearer sk-secret-token-xyz\n" + "long-reason-".repeat(100) : `failure-${index}`,
+			});
+		}
+
+		try {
+			assert.throws(
+				() => buildModelCandidates(candidates[0]!.fullId, candidates.slice(1).map((candidate) => candidate.fullId), candidates),
+				(error: unknown) => {
+					const message = String(error);
+					assert.match(message, /excluded: \[redacted\]\/\[redacted\] — model: \[redacted\]; provider: \[redacted\]/);
+					assert.match(message, /reason: \[redacted\] long-reason-/);
+					assert.doesNotMatch(message, /sk-provider-secret|sk-model-secret|sk-secret-token-xyz/);
+					assert.doesNotMatch(message, /[\r\n]/);
+					assert.match(message, /diagnostic-model-19/);
+					assert.doesNotMatch(message, /diagnostic-model-20/);
+					assert.match(message, /\.\.\. and 1 more/);
+					assert.equal((message.match(/reason: /g) ?? []).length, 20);
+					return true;
+				},
+			);
+		} finally {
+			console.warn = originalWarn;
+		}
+		assert.equal(warnings.length, 21);
+		assert.doesNotMatch(warnings.join("\n"), /sk-provider-secret|sk-model-secret|sk-secret-token-xyz/);
+	});
+
 	it("trusts an inherited parent model outside the registry", () => {
 		assert.deepEqual(
 			buildModelCandidates("gateway/parent-model", undefined, availableModels, undefined, { primaryModelFromParent: true }),
@@ -328,6 +511,13 @@ describe("model fallback helpers", () => {
 		assert.equal(isRetryableModelFailure(undefined), false);
 	});
 
+	it("recognizes only the exact raw request-limit code without broadening limit families", () => {
+		assert.equal(isRetryableModelFailure("REQUEST_LIMIT_EXCEEDED"), true);
+		for (const error of ["TOKEN_LIMIT_EXCEEDED", "INPUT_LIMIT_EXCEEDED", "OUTPUT_LIMIT_EXCEEDED", "RESOURCE_EXHAUSTED", "NOT_REQUEST_LIMIT_EXCEEDED", "REQUEST_LIMIT_EXCEEDED_OTHER", "400"]) {
+			assert.equal(isRetryableModelFailure(error), false, error);
+		}
+	});
+
 	it("does not treat network-flavored tool failures as retryable model failures", () => {
 		assert.equal(isRetryableModelFailure("bash failed (exit 1): requests.exceptions.ConnectionError: Connection error."), false);
 		assert.equal(isRetryableModelFailure("bash failed (exit 1): urllib.error.URLError: request timed out"), false);
@@ -900,4 +1090,4 @@ describe("isContextOverflow", () => {
 		assert.equal(isContextOverflow(undefined), false);
 		assert.equal(isContextOverflow(""), false);
 	});
-});
+});

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

@@ -11,30 +11,16 @@ import {
 	registerNativeSupervisorClient,
 	resolveSupervisorChannelDir,
 } from "../../src/intercom/native-supervisor-channel.ts";
-import {
-	SUBAGENT_CHILD_AGENT_ENV,
-	SUBAGENT_CHILD_INDEX_ENV,
-	SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV,
-	SUBAGENT_ORCHESTRATOR_TARGET_ENV,
-	SUBAGENT_RUN_ID_ENV,
-	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
-} from "../../src/runs/shared/pi-args.ts";
+import { SUPERVISOR_REPLY_ENTRY_TYPE, SUPERVISOR_REQUEST_MESSAGE_TYPE } from "../../src/intercom/supervisor-ui.ts";
 import { INTERCOM_DETACH_REQUEST_EVENT, type SubagentState } from "../../src/shared/types.ts";
 
 const createdChannels: string[] = [];
-const savedEnv = {
-	[SUBAGENT_CHILD_AGENT_ENV]: process.env[SUBAGENT_CHILD_AGENT_ENV],
-	[SUBAGENT_CHILD_INDEX_ENV]: process.env[SUBAGENT_CHILD_INDEX_ENV],
-	[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV]: process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV],
-	[SUBAGENT_ORCHESTRATOR_TARGET_ENV]: process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV],
-	[SUBAGENT_RUN_ID_ENV]: process.env[SUBAGENT_RUN_ID_ENV],
-	[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV]: process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV],
-};
 
 function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 	return {
 		baseCwd: process.cwd(),
 		currentSessionId: sessionId,
+		supervisorOwnerSessionId: (ctx as SubagentState["lastUiContext"])?.sessionManager.getSessionId() ?? null,
 		asyncJobs: new Map(),
 		foregroundControls: new Map(),
 		lastForegroundControlId: null,
@@ -48,7 +34,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 {
+function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string; reason?: "need_decision" | "interview_request" | "progress_update"; childTarget?: string; interview?: unknown; createdAt?: number; expiresAt?: number }): string {
 	const agent = input.agent ?? "worker";
 	const index = input.index ?? 0;
 	const channelDir = resolveSupervisorChannelDir(input.runId, agent, index);
@@ -60,14 +46,16 @@ function writeRequest(input: { sessionId: string; runId: string; agent?: string;
 		id: requestId,
 		createdAt: input.createdAt ?? Date.now(),
 		...(input.expiresAt !== undefined ? { expiresAt: input.expiresAt } : {}),
-		reason: "need_decision",
+		reason: input.reason ?? "need_decision",
 		message: input.message ?? "Need a decision",
-		expectsReply: true,
+		expectsReply: input.reason !== "progress_update",
 		orchestratorSessionId: input.sessionId,
 		orchestratorTarget: "shared-name",
 		runId: input.runId,
 		agent,
 		childIndex: index,
+		...(input.childTarget ? { childTarget: input.childTarget } : {}),
+		...(input.interview !== undefined ? { interview: input.interview } : {}),
 	}, null, "\t"));
 	return requestId;
 }
@@ -102,15 +90,7 @@ async function waitForCondition(condition: () => boolean, description: string):
 	}
 }
 
-function restoreEnv(): void {
-	for (const [key, value] of Object.entries(savedEnv)) {
-		if (value === undefined) delete process.env[key];
-		else process.env[key] = value;
-	}
-}
-
 afterEach(() => {
-	restoreEnv();
 	delete process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
 	for (const channel of createdChannels.splice(0)) fs.rmSync(channel, { recursive: true, force: true });
 });
@@ -125,7 +105,7 @@ describe("native supervisor channel", () => {
 			message: { content?: string; details?: { id?: string } };
 			options?: { triggerTurn?: boolean };
 		}> = [];
-		const registeredTools: string[] = [];
+		const registeredTools: Array<{ name: string; parameters: { properties: { action: unknown } } }> = [];
 		const ctx = {
 			cwd: process.cwd(),
 			hasUI: false,
@@ -137,7 +117,7 @@ describe("native supervisor channel", () => {
 		};
 		const pi = {
 			getAllTools: () => [],
-			registerTool: (tool: { name: string }) => { registeredTools.push(tool.name); },
+			registerTool: (tool: typeof registeredTools[number]) => { registeredTools.push(tool); },
 			sendMessage: (
 				message: { content?: string; details?: { id?: string } },
 				options?: { triggerTurn?: boolean },
@@ -150,7 +130,8 @@ describe("native supervisor channel", () => {
 		channel.start();
 		channel.dispose();
 
-		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME]);
+		assert.deepEqual(registeredTools.map((tool) => tool.name), [NATIVE_SUPERVISOR_TOOL_NAME]);
+		assert.deepEqual(registeredTools[0]?.parameters.properties.action, { type: "string", enum: ["list", "pending", "status", "reply"] });
 		assert.deepEqual(sent.map(({ message }) => message.details?.id), [matchingId]);
 		assert.deepEqual(sent[0]?.options, { triggerTurn: true });
 		assert.equal(channel.pending.has(matchingId), false, "disposed channel clears pending requests");
@@ -671,6 +652,130 @@ describe("native supervisor channel", () => {
 		}
 	});
 
+	it("includes supervisor request metadata and journals a successful reply", async () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({
+			sessionId: currentSessionId,
+			runId,
+			agent: "worker",
+			index: 2,
+			message: "Should this change be applied?",
+			reason: "interview_request",
+			childTarget: "child-worker",
+			interview: { approved: "boolean", rationale: "string" },
+		});
+		const sent: Array<{ customType?: string; content?: string; details?: Record<string, unknown> }> = [];
+		const entries: Array<{ customType: string; data?: Record<string, unknown> }> = [];
+		const journalState = { replyExistsAtAppend: false, requestExistsAtAppend: true };
+		const registeredTools = new Map<string, { execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }>();
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
+			registerTool: (tool: { name: string; execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }) => {
+				registeredTools.set(tool.name, tool);
+			},
+			sendMessage: (message: { customType?: string; content?: string; details?: Record<string, unknown> }) => { sent.push(message); },
+			appendEntry: (customType: string, data?: Record<string, unknown>) => {
+				journalState.replyExistsAtAppend = fs.existsSync(replyFile(runId, requestId, "worker", 2));
+				journalState.requestExistsAtAppend = fs.existsSync(requestFile(runId, requestId, "worker", 2));
+				entries.push({ customType, data });
+			},
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		try {
+			channel.start();
+			assert.equal(sent.length, 1);
+			assert.equal(sent[0]?.customType, SUPERVISOR_REQUEST_MESSAGE_TYPE);
+			assert.match(sent[0]?.content ?? "", /Subagent requests a structured supervisor interview\./);
+			assert.match(sent[0]?.content ?? "", /Should this change be applied\?/);
+			assert.ok(sent[0]?.content?.includes(`Reply with: subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`));
+			assert.ok(sent[0]?.content?.includes(`Live guidance: subagent({ action: "steer", id: "${runId}", index: 2, message: "..." }) (Reply to the pending request first.)`));
+			assert.doesNotMatch(sent[0]?.content ?? "", /Child intercom target:|child-worker/);
+			assert.deepEqual(sent[0]?.details, {
+				id: requestId,
+				requestId,
+				reason: "interview_request",
+				expectsReply: true,
+				runId,
+				agent: "worker",
+				childIndex: 2,
+				childTarget: "child-worker",
+				interview: { approved: "boolean", rationale: "string" },
+				requestBody: "Should this change be applied?",
+				replyHint: `subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`,
+			});
+
+			await registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("reply", {
+				action: "reply",
+				replyTo: requestId,
+				message: "Approved with rationale",
+			});
+
+			assert.equal(entries.length, 1);
+			assert.equal(entries[0]?.customType, SUPERVISOR_REPLY_ENTRY_TYPE);
+			assert.deepEqual(journalState, { replyExistsAtAppend: true, requestExistsAtAppend: false });
+			assert.deepEqual({ ...entries[0]?.data, createdAt: undefined }, {
+				requestId,
+				reason: "interview_request",
+				runId,
+				agent: "worker",
+				childIndex: 2,
+				childTarget: "child-worker",
+				message: "Approved with rationale",
+				createdAt: undefined,
+			});
+			assert.equal(typeof entries[0]?.data?.createdAt, "number");
+			const reply = JSON.parse(fs.readFileSync(replyFile(runId, requestId, "worker", 2), "utf-8")) as { message?: string };
+			assert.equal(reply.message, "Approved with rationale");
+			assert.equal(fs.existsSync(requestFile(runId, requestId, "worker", 2)), false);
+		} finally {
+			channel.dispose();
+		}
+	});
+
+	it("keeps message-less interview metadata visible to the parent model", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId, reason: "interview_request", message: "", interview: { approved: "boolean" } });
+		const sent: Array<{ content?: string; details?: Record<string, unknown> }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { content?: string; details?: Record<string, unknown> }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		channel.start();
+		channel.dispose();
+
+		assert.equal(sent.length, 1);
+		assert.match(sent[0]?.content ?? "", /Structured response requested/);
+		assert.match(sent[0]?.content ?? "", /"approved": "boolean"/);
+		assert.match(sent[0]?.content ?? "", new RegExp(`replyTo: "${requestId}"`));
+		assert.equal(sent[0]?.details?.requestBody, "");
+	});
+
 	it("suppresses resolved, expired, and inactive requests before displaying them", () => {
 		const currentSessionId = `session-${randomUUID()}`;
 		const resolvedRunId = `run-${randomUUID()}`;
@@ -765,16 +870,47 @@ describe("native supervisor channel", () => {
 		}
 	});
 
+	it("stores only the child-authored supervisor message in the request body", async () => {
+		const runId = `run-${randomUUID()}`;
+		const channelDir = resolveSupervisorChannelDir(runId, "worker", 3);
+		createdChannels.push(channelDir);
+		const registeredTools = new Map<string, { execute: (_id: string, params: { reason: string; message?: string }) => Promise<unknown> | unknown }>();
+		const pi = {
+			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
+			registerTool: (tool: { name: string; execute: (_id: string, params: { reason: string; message?: string }) => Promise<unknown> | unknown }) => {
+				registeredTools.set(tool.name, tool);
+			},
+		};
+		registerNativeSupervisorClient(pi as never, {
+			channelDir,
+			runId,
+			agent: "worker",
+			childIndex: 3,
+			orchestratorTarget: "shared-name",
+			orchestratorSessionId: "session-parent",
+		});
+
+		await assert.rejects(
+			() => registeredTools.get("contact_supervisor")!.execute("blank-progress", { reason: "progress_update" }),
+			/message is required for supervisor decisions and progress updates/,
+		);
+		await registeredTools.get("contact_supervisor")!.execute("contact", {
+			reason: "progress_update",
+			message: "  Finished the first review pass.  ",
+		});
+
+		const [file] = fs.readdirSync(path.join(channelDir, "requests"));
+		const request = JSON.parse(fs.readFileSync(path.join(channelDir, "requests", file!), "utf-8")) as { message?: string; runId?: string; agent?: string; childIndex?: number };
+		assert.equal(request.message, "Finished the first review pass.");
+		assert.equal(request.runId, runId);
+		assert.equal(request.agent, "worker");
+		assert.equal(request.childIndex, 3);
+	});
+
 	it("removes the request file when a child supervisor ask is cancelled", async () => {
 		const runId = `run-${randomUUID()}`;
 		const channelDir = resolveSupervisorChannelDir(runId, "worker", 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_INDEX_ENV] = "0";
 		const registeredTools = new Map<string, { execute: (_id: string, params: { reason: string; message?: string }, signal?: AbortSignal) => Promise<unknown> | unknown }>();
 		const pi = {
 			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
@@ -782,7 +918,14 @@ describe("native supervisor channel", () => {
 				registeredTools.set(tool.name, tool);
 			},
 		};
-		registerNativeSupervisorClient(pi as never);
+		registerNativeSupervisorClient(pi as never, {
+			channelDir,
+			runId,
+			agent: "worker",
+			childIndex: 0,
+			orchestratorTarget: "shared-name",
+			orchestratorSessionId: "session-parent",
+		});
 		const controller = new AbortController();
 		controller.abort();
 
@@ -793,4 +936,4 @@ describe("native supervisor channel", () => {
 
 		assert.deepEqual(fs.readdirSync(path.join(channelDir, "requests")), []);
 	});
-});
+});