@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/slash-bridge.test.ts

@@ -52,15 +52,15 @@ describe("slash subagent bridge requester context", () => {
     await done;
   });
 
-  it("accepts direct execution inputs before executor dispatch", async () => {
+  it("passes structured single-child execution to the direct path", async () => {
     const events = eventBus();
-    let executeCalls = 0;
+    let executedParams: any;
     registerSlashSubagentBridge({
       events,
       getContext: () => ({ cwd: "/repo" }) as any,
-      execute: async () => {
-        executeCalls++;
-        return { content: [{ type: "text", text: "unexpected" }], details: { mode: "single", results: [] } } as any;
+      execute: async (_id, params) => {
+        executedParams = params;
+        return { content: [{ type: "text", text: "ok" }], details: { mode: "workflow", results: [] } } as any;
       },
     });
 
@@ -68,7 +68,11 @@ describe("slash subagent bridge requester context", () => {
       events.on(RESPONSE, (data: any) => {
         try {
           assert.equal(data.isError, false);
-          assert.equal(executeCalls, 1);
+          assert.equal(executedParams.agent, "worker");
+          assert.equal(executedParams.task, "work");
+          assert.equal(executedParams.async, false);
+          assert.equal(executedParams.output, true);
+          assert.equal(executedParams.workflowScript, undefined);
           resolve();
         } catch (error) {
           reject(error);
@@ -76,11 +80,11 @@ describe("slash subagent bridge requester context", () => {
       });
     });
 
-    events.emit(REQUEST, { requestId: "legacy-single", params: { agent: "worker", task: "work" } });
+    events.emit(REQUEST, { requestId: "structured-single", params: { agent: "worker", task: "work", async: false } });
     await done;
   });
 
-  it("accepts chain and parallel inputs before executor dispatch", async () => {
+  it("rejects removed chain and parallel inputs before executor dispatch", async () => {
     const events = eventBus();
     let executeCalls = 0;
     registerSlashSubagentBridge({
@@ -95,8 +99,9 @@ describe("slash subagent bridge requester context", () => {
     const done = new Promise<void>((resolve, reject) => {
       events.on(RESPONSE, (data: any) => {
         try {
-          assert.equal(data.isError, false);
-          assert.equal(executeCalls, 1);
+          assert.equal(data.isError, true);
+          assert.match(data.errorText, /removed.*workflowScript/i);
+          assert.equal(executeCalls, 0);
           resolve();
         } catch (error) {
           reject(error);

package/dist/extensions/pi-subagents/test/unit/stale-run-reconciler.test.ts

@@ -37,13 +37,14 @@ describe("async stale-run reconciliation", () => {
 			writeStatus(asyncDir, {
 				runId: "run-dead",
 				sessionId: "session-current",
+				completionOwnerId: "owner-current",
 				mode: "single",
 				state: "running",
 				pid: 12345,
 				startedAt: 1000,
 				lastUpdate: 1000,
 				currentStep: 0,
-				steps: [{ agent: "scout", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "scout", status: "running", startedAt: 1000, contextOverflow: true }],
 			});
 
 			const result = reconcileAsyncRun(asyncDir, {
@@ -58,13 +59,16 @@ describe("async stale-run reconciliation", () => {
 			const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
 			assert.equal(status.state, "failed");
 			assert.equal(status.sessionId, "session-current");
+			assert.equal(status.completionOwnerId, "owner-current");
 			assert.equal(status.steps[0].status, "failed");
 			assert.match(status.steps[0].error, /process 12345 exited or disappeared/);
 			const resultJson = JSON.parse(fs.readFileSync(path.join(resultsDir, "run-dead.json"), "utf-8"));
 			assert.equal(resultJson.success, false);
 			assert.equal(resultJson.sessionId, "session-current");
+			assert.equal(resultJson.completionOwnerId, "owner-current");
 			assert.equal(resultJson.state, "failed");
 			assert.equal(resultJson.exitCode, 1);
+			assert.equal(resultJson.results[0].contextOverflow, true);
 			assert.match(resultJson.summary, /process 12345 exited or disappeared/);
 			assert.match(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8"), /subagent\.run\.repaired_stale/);
 		} finally {
@@ -199,7 +203,7 @@ describe("async stale-run reconciliation", () => {
 				state: "failed",
 				results: [
 					{ agent: "scout", success: true, sessionFile: scoutSession, model: "fast", attemptedModels: ["planned-scout", "fast"] },
-					{ agent: "worker", success: false, error: "boom", sessionFile: workerSession, model: "careful", attemptedModels: ["planned-worker", "careful"] },
+					{ agent: "worker", success: false, error: "boom", sessionFile: workerSession, model: "careful", attemptedModels: ["planned-worker", "careful"], contextOverflow: true },
 				],
 			}, null, 2), "utf-8");
 
@@ -221,6 +225,7 @@ describe("async stale-run reconciliation", () => {
 			assert.equal(result.status?.steps?.[1]?.error, "boom");
 			assert.equal(result.status?.steps?.[1]?.model, "careful");
 			assert.deepEqual(result.status?.steps?.[1]?.attemptedModels, ["planned-worker", "careful"]);
+			assert.equal(result.status?.steps?.[1]?.contextOverflow, true);
 			assert.equal(result.status?.steps?.[1]?.sessionFile, workerSession);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
@@ -290,8 +295,7 @@ describe("async stale-run reconciliation", () => {
 				startedAt: 1000,
 				lastUpdate: 1000,
 				currentStep: 0,
-				checkpoint: { name: "review", status: "rejected", stepIndex: 0 },
-				steps: [{ agent: "checkpoint:review", status: "rejected", startedAt: 1000, error: "Checkpoint 'review' rejected." }],
+				steps: [{ agent: "worker", status: "rejected", startedAt: 1000, error: "Run rejected." }],
 			});
 			const publicResultPath = path.join(resultsDir, "run-rejected.json");
 			fs.mkdirSync(publicResultPath, { recursive: true });
@@ -301,8 +305,8 @@ describe("async stale-run reconciliation", () => {
 				sessionId: "session-current",
 				success: false,
 				state: "rejected",
-				summary: "Checkpoint 'review' rejected.",
-				results: [{ agent: "checkpoint:review", success: false, error: "Checkpoint 'review' rejected." }],
+				summary: "Run rejected.",
+				results: [{ agent: "worker", success: false, error: "Run rejected." }],
 			});
 
 			const result = reconcileAsyncRun(asyncDir, {
@@ -314,7 +318,7 @@ describe("async stale-run reconciliation", () => {
 			assert.equal(result.repaired, false);
 			assert.equal(result.status?.state, "rejected");
 			assert.equal(result.status?.steps?.[0]?.status, "rejected");
-			assert.match(fs.readFileSync(result.resultPath!, "utf-8"), /review/);
+			assert.match(fs.readFileSync(result.resultPath!, "utf-8"), /Run rejected/);
 		} finally {
 			console.error = originalError;
 			fs.rmSync(root, { recursive: true, force: true });

package/dist/extensions/pi-subagents/test/unit/steering-action.test.ts

@@ -139,6 +139,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.match(result.content[0]!.text, /Steering delivered/);
+			assert.match(result.content[0]!.text, /Message: "correct course"/);
 		} finally {
 			removeAsyncDir(asyncDir);
 		}
@@ -330,6 +331,7 @@ describe("acknowledged steering action", () => {
 			const result = await action;
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details.steering?.state, "recovered");
+			assert.match(result.content[0]!.text, /Message: "correct course"/);
 			assert.equal(result.details.steering?.replacementRunId, "replacement");
 			assert.ok(result.details.steering?.targets[0]?.lateDeliveredAt);
 			const limits = receivedLimits as { timeoutMs: number; absoluteDeadlineAt: number; turnBudget: unknown; toolBudget: unknown };

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

@@ -3,11 +3,19 @@ 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 { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, terminalSteeringNoticeState, updateSteeringTarget } from "../../src/runs/background/steering.ts";
+import { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, steeringMessagePreview, terminalSteeringNoticeState, updateSteeringTarget } from "../../src/runs/background/steering.ts";
 import { applySteeringRecoveryAgentConfig } from "../../src/runs/background/async-resume.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
 
 describe("steering lifecycle ledger", () => {
+	it("redacts and bounds steering message previews", () => {
+		const secret = "ghp_1234567890abcdef";
+		const preview = steeringMessagePreview(`Use ${secret}\n${"x".repeat(200)}`);
+		assert.ok(preview.length <= 160);
+		assert.match(preview, /\[redacted\]/);
+		assert.doesNotMatch(preview, new RegExp(secret));
+	});
+
 	it("retains 20 recent requests while aggregate totals remain monotonic", () => {
 		const status = createSteeringStatus();
 		for (let index = 0; index < 21; index++) {
@@ -165,6 +173,37 @@ describe("steering lifecycle ledger", () => {
 		}
 	});
 
+	it("intersects persisted thinking ceilings with the current agent ceiling", () => {
+		const current = {
+			name: "worker",
+			description: "current",
+			thinking: "high",
+			maxThinking: "low",
+			systemPrompt: "current prompt",
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			source: "project",
+			filePath: "/current/agent.md",
+		} as AgentConfig;
+		const recovered = applySteeringRecoveryAgentConfig(current, {
+			version: 1,
+			sourceRunId: "source",
+			agent: "worker",
+			cwd: "/original",
+			thinking: "xhigh",
+			thinkingCeiling: "xhigh",
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			outputMode: "inline",
+			maxSubagentDepth: 2,
+			share: false,
+		});
+		assert.equal(recovered.thinking, "xhigh");
+		assert.equal(recovered.maxThinking, "low");
+	});
+
 	it("rejects recovery when any configured hard budget is exhausted", () => {
 		assert.throws(() => remainingSteeringRecoveryLimits({ absoluteDeadlineAt: 5 }, {}, 5), /deadline budget/);
 		assert.throws(() => remainingSteeringRecoveryLimits({ initialTurnBudget: { maxTurns: 2, graceTurns: 1 } }, { turnCount: 3 }), /turn budget/);

package/dist/extensions/pi-subagents/test/unit/subagent-action-recovery.test.ts

@@ -54,6 +54,14 @@ describe("subagent action recovery", () => {
 		assert.match(message, /Valid: .*status/);
 	});
 
+	it("does not list removed legacy controls", () => {
+		const message = unknownSubagentActionMessage("not-a-real-action");
+
+		assert.doesNotMatch(message, /append-step/);
+		assert.doesNotMatch(message, /approve-checkpoint/);
+		assert.doesNotMatch(message, /reject-checkpoint/);
+	});
+
 	it("does not suggest a destructive near-miss", () => {
 		const message = unknownSubagentActionMessage("del");
 
@@ -70,10 +78,10 @@ describe("subagent action recovery", () => {
 	});
 
 	it("routes invalid schedule actions through common recovery", async () => {
-		const result = await createExecutor().execute("invalid-removed-action", { action: "removed.lsit" }, new AbortController().signal, undefined, ctx());
+		const result = await createExecutor().execute("invalid-schedule-action", { action: "schedule.lsit" }, new AbortController().signal, undefined, ctx());
 		assert.equal(result.isError, true);
 		assert.equal(result.content[0]?.type, "text");
-		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("removed.lsit"));
+		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("schedule.lsit"));
 	});
 
 	it("lists and suggests mission decision resolution", () => {

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

@@ -100,6 +100,30 @@ describe("subagent control attention state", () => {
 		}), "time_threshold");
 	});
 
+	it("scales the default idle threshold for higher thinking levels", () => {
+		const defaults = resolveControlConfig();
+
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "low", now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "minimal", now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "high", now: 60_001 }), undefined);
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "high", now: 300_001 }), "needs_attention");
+	});
+
+	it("keeps explicit idle threshold overrides higher priority than thinking scale", () => {
+		const explicit = resolveControlConfig(undefined, { needsAttentionAfterMs: 90_000 });
+
+		assert.equal(explicit.needsAttentionAfterMsIsExplicit, true);
+		assert.equal(deriveActivityState({ config: explicit, startedAt: 0, thinking: "high", now: 90_001 }), "needs_attention");
+	});
+
+	it("treats recovered resolved configs without explicitness metadata as fixed thresholds", () => {
+		const recovered = { ...resolveControlConfig(undefined, { needsAttentionAfterMs: 90_000 }) };
+		delete recovered.needsAttentionAfterMsIsExplicit;
+
+		assert.equal(deriveActivityState({ config: recovered, startedAt: 0, thinking: "high", now: 90_001 }), "needs_attention");
+	});
+
 	it("marks non-exempt open tools for attention at the active threshold", () => {
 		const defaults = resolveControlConfig();
 
@@ -198,6 +222,17 @@ describe("subagent control attention state", () => {
 
 		assert.match(message, /worker has had tool 'bash' open for 240s/);
 		assert.match(message, /Facts: tool bash 240s \| path scripts\/run-tests\.sh/);
+		assert.match(message, /message: "Check tool bash at path scripts\/run-tests\.sh\. Report the smallest next step or ask for a decision\."/);
+	});
+
+	it("uses bounded task context in nudges and de-duplicates distinct contexts", () => {
+		const first = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "reviewer", label: `release gate ${"x".repeat(200)}` });
+		const second = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "reviewer", label: "security gate" });
+		const firstMessage = formatControlNoticeMessage(first);
+		const nudge = firstMessage.match(/message: ("(?:[^"\\]|\\.)*")/)?.[1];
+		assert.ok(nudge);
+		assert.ok((JSON.parse(nudge) as string).length <= 160);
+		assert.notEqual(controlNotificationKey(first), controlNotificationKey(second));
 	});
 
 	it("formats supervisor-request notices with pending-channel guidance", () => {
@@ -235,8 +270,8 @@ describe("subagent control attention state", () => {
 		assert.match(message, /Subagent active but long-running: worker/);
 		assert.match(message, /Inspect status/);
 		assert.match(message, /steer for a top-level live async child, routed resume for a live nested child/);
-		assert.match(message, /Top-level live async nudge: subagent\(\{ action: "steer", id: "78f659a3", message: "What are you blocked on\?/);
-		assert.match(message, /Routed live nested nudge: subagent\(\{ action: "resume", id: "78f659a3", message: "What are you blocked on\?/);
+		assert.match(message, /Top-level live async nudge: subagent\(\{ action: "steer", id: "78f659a3", message: "Check tool edit at path src\/runs\/background\/async-status\.ts/);
+		assert.match(message, /Routed live nested nudge: subagent\(\{ action: "resume", id: "78f659a3", message: "Check tool edit at path src\/runs\/background\/async-status\.ts/);
 		assert.match(message, /15 turns/);
 		assert.match(message, /160000 tokens/);
 		assert.match(message, /path src\/runs\/background\/async-status\.ts/);
@@ -277,7 +312,7 @@ describe("subagent control attention state", () => {
 		const event = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "worker", index: 0 });
 		const seen = new Set<string>();
 
-		assert.equal(controlNotificationKey(event, "subagent-worker-run-1-1"), "subagent-worker-run-1-1:needs_attention:idle");
+		assert.match(controlNotificationKey(event, "subagent-worker-run-1-1"), /^subagent-worker-run-1-1:needs_attention:idle:[a-f0-9]{8}$/);
 		assert.equal(claimControlNotification(resolveControlConfig(), event, seen, "subagent-worker-run-1-1"), true);
 		assert.equal(claimControlNotification(resolveControlConfig(), event, seen, "subagent-worker-run-1-1"), false);
 

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

@@ -164,6 +164,40 @@ describe("subagent prompt runtime", () => {
 		assert.equal(await askHandlers[0]!({ toolName: "write", input: { path: "out.txt" } }, { signal: undefined }), undefined);
 		assert.deepEqual(requests, [{ toolName: "write", args: { path: "out.txt" } }]);
 	});
+
+	it("fails closed when an ask permission decision stalls", async () => {
+		try {
+			process.env[PERMISSION_POLICY_ENV] = JSON.stringify({ write: "ask" });
+			process.env[CHILD_WATCHDOG_CONFIG_ENV] = JSON.stringify({
+				enabled: true,
+				watchdogTailTimeoutMs: 1_000,
+				agentEndTimeoutMs: 5,
+				maxWarnings: null,
+				lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
+				autoFollowBlockers: false,
+				autoFollowMaxAttempts: null,
+				stalemateRepeats: 2,
+			});
+			const handlers: Array<(event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown> = [];
+			registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown) { if (event === "tool_call") handlers.push(handler); } } as never, async () => new Promise(() => undefined));
+
+			const result = await Promise.race([
+				handlers[0]!({ toolName: "write", input: { path: "out.txt" } }, { signal: undefined }),
+				new Promise((resolve) => setTimeout(() => resolve("hung"), 100)),
+			]);
+
+			assert.notEqual(result, "hung");
+			assert.deepEqual(result, {
+				block: true,
+				reason: "Blocked by pi-subagents permission rule: Watchdog permission arbiter failed closed: Watchdog permission decision timed out after 5ms.",
+			});
+		} finally {
+			if (envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY === undefined) delete process.env[PERMISSION_POLICY_ENV];
+			else process.env[PERMISSION_POLICY_ENV] = envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY;
+			if (envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG === undefined) delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
+			else process.env[CHILD_WATCHDOG_CONFIG_ENV] = envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG;
+		}
+	});
 	it("collects runtime extension acknowledgements until terminal serialization", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-runtime-ack-"));
 		try {
@@ -244,6 +278,7 @@ describe("subagent prompt runtime", () => {
 				},
 				sendUserMessage() {},
 			} as { on(event: string, handler: (payload?: unknown) => unknown): void; sendUserMessage(): void }, {
+				platform: "linux",
 				nativeRealpath(target) {
 					assert.equal(target, inbox);
 					return nativeInbox;
@@ -270,6 +305,41 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
+	it("uses polling without native steering watchers on Darwin", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-darwin-runtime-"));
+		try {
+			const inbox = path.join(dir, "steer");
+			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			const intervalDelays: number[] = [];
+			let watchCalls = 0;
+
+			registerSteeringInbox({
+				on(event: string, handler: (payload?: unknown) => unknown) {
+					handlers.set(event, handler);
+				},
+				sendUserMessage() {},
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; sendUserMessage(): void }, {
+				platform: "darwin",
+				watch: (() => { watchCalls += 1; throw new Error("Darwin must not use fs.watch."); }) 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(watchCalls, 0);
+			assert.deepEqual(intervalDelays, [250]);
+			handlers.get("session_shutdown")?.({});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	it("delivers steering inbox requests as mid-run user messages", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-runtime-"));
 		try {
@@ -593,11 +663,10 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
-	it("does not register child watchdog lifecycle handlers when env is set", () => {
+	it("registers child watchdog lifecycle handlers only when enabled by env", () => {
 		delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
-		// Clear the ack capture and steer env vars explicitly: when this test suite itself
-		// runs inside a pi-subagents child, the runner sets them and extra agent_end
-		// handlers register (steering inbox is gated on SUBAGENT_STEER_INBOX_ENV).
+		// Clear the ack capture env explicitly: when this test suite itself runs inside a
+		// pi-subagents child, the runner sets it and an extra agent_end handler registers.
 		delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
 		delete process.env[SUBAGENT_STEER_INBOX_ENV];
 		delete process.env[SUBAGENT_STEER_CAPABILITY_ENV];
@@ -634,9 +703,9 @@ describe("subagent prompt runtime", () => {
 			sendMessage() {},
 		} as { on(event: string, handler: unknown): void; getThinkingLevel(): string; sendMessage(): void });
 
-		assert.equal(handlersWith.get("agent_end")?.length ?? 0, 1, "child watchdog lifecycle handlers are not registered");
-		assert.equal(handlersWith.get("before_agent_start")?.length ?? 0, handlersWithout.get("before_agent_start")?.length ?? 0);
-		assert.equal(handlersWith.get("turn_end")?.length ?? 0, handlersWithout.get("turn_end")?.length ?? 0);
+		assert.ok((handlersWith.get("before_agent_start")?.length ?? 0) >= 2);
+		assert.ok((handlersWith.get("turn_end")?.length ?? 0) >= 1);
+		assert.ok((handlersWith.get("agent_end")?.length ?? 0) >= 2, "watchdog and auto-drain both observe agent_end");
 	});
 
 	it("registered structured_output tool accepts valid schema output and writes the capture file", async () => {
@@ -949,12 +1018,41 @@ describe("subagent prompt runtime", () => {
 
 			handlers.get("session_start")?.({});
 			assert.deepEqual(registered, ["subagent_wait", "contact_supervisor"]);
-			handlers.get("agent_start")?.({});
+			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: read, grep, find, ls, bash, edit, write, intercom/);
 			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
 				agent: "scout",
 				required: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
 				available: ["subagent_wait", "contact_supervisor"],
-				missing: ["intercom"],
+				missing: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
+			});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("records missing core write tools from the actual child registry", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-core-tool-diagnostic-"));
+		try {
+			const diagnosticPath = path.join(dir, "tools.json");
+			const handlers = new Map<string, (payload?: unknown) => unknown>();
+			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "grep", "find", "ls", "bash", "edit", "write"]);
+			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
+			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
+
+			registerSubagentPromptRuntime({
+				on(event: string, handler: (payload?: unknown) => unknown) {
+					handlers.set(event, handler);
+				},
+				getAllTools: () => ["read", "grep", "find", "ls", "contact_supervisor"].map((name) => ({ name })),
+				registerTool() {},
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
+
+			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: bash, edit, write/);
+			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
+				agent: "worker",
+				required: ["read", "grep", "find", "ls", "bash", "edit", "write"],
+				available: ["read", "grep", "find", "ls", "contact_supervisor"],
+				missing: ["bash", "edit", "write"],
 			});
 		} finally {
 			fs.rmSync(dir, { recursive: true, force: true });
@@ -1033,7 +1131,7 @@ describe("subagent prompt runtime", () => {
 			assert.equal(fs.existsSync(diagnosticPath), false);
 			assert.doesNotMatch(promptRewrite?.systemPrompt ?? "", /requested unavailable child tools/);
 
-			handlers.get("agent_start")?.({});
+			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: fixture_search/);
 			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
 				agent: "extension-worker",
 				required: ["read", "fixture_search"],
@@ -1067,7 +1165,7 @@ describe("subagent prompt runtime", () => {
 				registerTool() {},
 			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
 
-			assert.doesNotThrow(() => handlers.get("agent_start")?.({}));
+			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: fixture_search/);
 			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
 				agent: "worker",
 				required: ["read", "fixture_search"],
@@ -1097,7 +1195,7 @@ describe("subagent prompt runtime", () => {
 				registerTool() {},
 			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
 
-			handlers.get("agent_start")?.({});
+			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: rust_symbols_workspace_symbols, fixture_search/);
 			const diagnostic = readChildToolDiagnostic(diagnosticPath);
 			assert.deepEqual(diagnostic, {
 				agent: "worker",