@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/src/runs/shared/structured-output.ts

@@ -1,11 +1,14 @@
 import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
-import { Compile } from "typebox/compile";
+import { pathToFileURL } from "node:url";
+import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
 export const STRUCTURED_OUTPUT_SCHEMA_ENV = "SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
 export const STRUCTURED_OUTPUT_CAPTURE_ENV = "SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
+export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
 
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;
@@ -13,11 +16,108 @@ export interface StructuredOutputRuntime {
 	outputPath: string;
 }
 
+const SCHEMA_MAP_KEYWORDS = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"] as const;
+const SCHEMA_SINGLE_KEYWORDS = ["additionalItems", "additionalProperties", "contains", "not", "propertyNames", "if", "then", "else", "unevaluatedItems", "unevaluatedProperties", "contentSchema"] as const;
+const SCHEMA_ARRAY_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"] as const;
+
+function rewriteLocalJsonPointerRefs(schema: unknown, pointerPrefix: string, inheritsWrapperResource = true): unknown {
+	if (typeof schema === "boolean" || !schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	const source = schema as Record<string, unknown>;
+	const rewritten: Record<string, unknown> = { ...source };
+	const sharesWrapperResource = inheritsWrapperResource && typeof source.$id !== "string";
+	if (sharesWrapperResource) {
+		for (const keyword of ["$ref", "$dynamicRef", "$recursiveRef"] as const) {
+			const ref = source[keyword];
+			if (ref === "#") rewritten[keyword] = pointerPrefix;
+			else if (typeof ref === "string" && ref.startsWith("#/")) rewritten[keyword] = `${pointerPrefix}${ref.slice(1)}`;
+		}
+	}
+	for (const keyword of SCHEMA_MAP_KEYWORDS) {
+		const entries = source[keyword];
+		if (!entries || typeof entries !== "object" || Array.isArray(entries)) continue;
+		rewritten[keyword] = Object.fromEntries(Object.entries(entries).map(([name, nested]) => [
+			name,
+			rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource),
+		]));
+	}
+	const items = source.items;
+	if (Array.isArray(items)) rewritten.items = items.map((nested) => rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource));
+	else if (items !== undefined) rewritten.items = rewriteLocalJsonPointerRefs(items, pointerPrefix, sharesWrapperResource);
+	for (const keyword of SCHEMA_SINGLE_KEYWORDS) {
+		if (source[keyword] !== undefined) rewritten[keyword] = rewriteLocalJsonPointerRefs(source[keyword], pointerPrefix, sharesWrapperResource);
+	}
+	for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+		if (Array.isArray(source[keyword])) rewritten[keyword] = source[keyword].map((nested) => rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource));
+	}
+	const dependencies = source.dependencies;
+	if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
+		rewritten.dependencies = Object.fromEntries(Object.entries(dependencies).map(([name, nested]) => [
+			name,
+			Array.isArray(nested) ? nested : rewriteLocalJsonPointerRefs(nested, pointerPrefix, sharesWrapperResource),
+		]));
+	}
+	return rewritten;
+}
+
+export function createStructuredOutputToolParameters(schema: JsonSchemaObject): JsonSchemaObject {
+	return {
+		type: "object",
+		properties: { value: rewriteLocalJsonPointerRefs(schema, "#/properties/value") },
+		required: ["value"],
+		additionalProperties: false,
+	};
+}
+
 interface CompiledJsonSchema {
 	Check(value: unknown): boolean;
 	Errors(value: unknown): Iterable<{ instancePath?: string; message?: string }>;
 }
 
+type CompileJsonSchema = (schema: unknown) => CompiledJsonSchema;
+
+let cachedCompile: Promise<CompileJsonSchema> | undefined;
+
+export async function resolveCompileFromPackageRoot(packageRoot: string): Promise<CompileJsonSchema | undefined> {
+	const requireFromRoot = createRequire(path.join(packageRoot, "package.json"));
+	const resolved = requireFromRoot.resolve("typebox/compile");
+	const mod = (await import(pathToFileURL(resolved).href)) as { Compile?: unknown };
+	return typeof mod.Compile === "function" ? (mod.Compile as CompileJsonSchema) : undefined;
+}
+
+async function importCompile(): Promise<CompileJsonSchema> {
+	const failures: string[] = [];
+	try {
+		const mod = (await import("typebox/compile")) as { Compile?: unknown };
+		if (typeof mod.Compile === "function") return mod.Compile as CompileJsonSchema;
+		failures.push("typebox/compile did not export a Compile function");
+	} catch (error) {
+		failures.push(`direct import failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const packageRoot = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	if (packageRoot) {
+		try {
+			const compile = await resolveCompileFromPackageRoot(packageRoot);
+			if (compile) return compile;
+			failures.push("Pi package root typebox/compile did not export a Compile function");
+		} catch (error) {
+			failures.push(`Pi package root import failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	} else {
+		failures.push(`${SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV} is not set`);
+	}
+	throw new Error(`Cannot load typebox/compile for structured output validation (${failures.join("; ")})`);
+}
+
+function loadCompile(): Promise<CompileJsonSchema> {
+	if (!cachedCompile) {
+		cachedCompile = importCompile().catch((error) => {
+			cachedCompile = undefined;
+			throw error;
+		});
+	}
+	return cachedCompile;
+}
+
 export function assertJsonSchemaObject(schema: unknown, label = "outputSchema"): asserts schema is JsonSchemaObject {
 	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
 		throw new Error(`${label} must be a JSON Schema object.`);
@@ -35,10 +135,11 @@ export function createStructuredOutputRuntime(schema: JsonSchemaObject, baseDir?
 	return { schema, schemaPath, outputPath };
 }
 
-export function validateStructuredOutputValue(schema: JsonSchemaObject, value: unknown): { status: "valid" } | { status: "invalid"; message: string } {
+export async function validateStructuredOutputValue(schema: JsonSchemaObject, value: unknown): Promise<{ status: "valid" } | { status: "invalid"; message: string }> {
+	const compile = await loadCompile();
 	let validator: CompiledJsonSchema;
 	try {
-		validator = (Compile as (schema: unknown) => CompiledJsonSchema)(schema);
+		validator = compile(schema);
 	} catch (error) {
 		return { status: "invalid", message: `invalid outputSchema: ${error instanceof Error ? error.message : String(error)}` };
 	}
@@ -52,9 +153,9 @@ export function validateStructuredOutputValue(schema: JsonSchemaObject, value: u
 	return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
 }
 
-export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?: unknown; error?: string } {
+export async function readStructuredOutput(runtime: StructuredOutputRuntime): Promise<{ value?: unknown; error?: string }> {
 	if (!fs.existsSync(runtime.outputPath)) {
-		return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
+		return { error: MISSING_STRUCTURED_OUTPUT_CALL_ERROR };
 	}
 	let value: unknown;
 	try {
@@ -62,8 +163,12 @@ export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?
 	} catch (error) {
 		return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
 	}
-	const validation = validateStructuredOutputValue(runtime.schema, value);
-	if (validation.status === "invalid") return { error: `Structured output validation failed: ${validation.message}` };
+	try {
+		const validation = await validateStructuredOutputValue(runtime.schema, value);
+		if (validation.status === "invalid") return { error: `Structured output validation failed: ${validation.message}` };
+	} catch (error) {
+		return { error: `Failed to validate structured output: ${error instanceof Error ? error.message : String(error)}` };
+	}
 	return { value };
 }
 

package/dist/extensions/pi-subagents/src/runs/shared/subagent-control.ts

@@ -74,9 +74,10 @@ export function deriveActivityState(input: {
 	config: ResolvedControlConfig;
 	startedAt: number;
 	lastActivityAt?: number;
+	currentTool?: string;
 	now?: number;
 }): ActivityState | undefined {
-	if (!input.config.enabled) return undefined;
+	if (!input.config.enabled || input.currentTool) return undefined;
 	const now = input.now ?? Date.now();
 	const lastActivity = input.lastActivityAt ?? input.startedAt;
 	const ageMs = Math.max(0, now - lastActivity);
@@ -174,7 +175,8 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 	}
 
 	const nudgeMessage = "What are you blocked on? Reply with the smallest next step or ask for a decision.";
-	const nudgeCommand = `subagent({ action: "resume", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: "${nudgeMessage}" })`;
+	const steerCommand = `subagent({ action: "steer", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: "${nudgeMessage}" })`;
+	const nestedResumeCommand = `subagent({ action: "resume", id: "${runTarget}", message: "${nudgeMessage}" })`;
 	if (event.type === "active_long_running") {
 		const facts = formatLongRunningFacts(event);
 		return [
@@ -182,21 +184,27 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 			`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
 			`Signal: ${event.message}`,
 			facts ? `Facts: ${facts}` : undefined,
-			"Hint: Inspect status, then nudge if the work seems stuck. Live async nudges interrupt the child before sending the follow-up.",
-			`Nudge: ${nudgeCommand}`,
+			"Hint: Inspect status first. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
+			`Top-level live async nudge: ${steerCommand}`,
+			`Routed live nested nudge: ${nestedResumeCommand}`,
 			childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
 			`Status: subagent({ action: "status", id: "${runTarget}" })`,
 			`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
 		].filter((line): line is string => Boolean(line)).join("\n");
 	}
 
+	const supervisorHint = event.reason === "supervisor_request"
+		? "Supervisor request: reply to the pending request. If subagent_supervisor pending is empty, check intercom pending because an external intercom tool may own the request."
+		: undefined;
 	return [
 		`Subagent needs attention: ${event.agent}`,
 		`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
 		`Signal: ${event.message}`,
 		event.recentFailureSummary ? `Recent failures: ${event.recentFailureSummary}` : undefined,
-		"Hint: Inspect status first unless the run is clearly blocked. Live async nudges interrupt the child before sending the follow-up.",
-		`Nudge: ${nudgeCommand}`,
+		supervisorHint,
+		"Hint: Inspect status first unless the run is clearly blocked. Use steer for a top-level live async child, routed resume for a live nested child, or resume to revive a paused/completed/failed child.",
+		`Top-level live async nudge: ${steerCommand}`,
+		`Routed live nested nudge: ${nestedResumeCommand}`,
 		childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
 		`Status: subagent({ action: "status", id: "${runTarget}" })`,
 		`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,

package/dist/extensions/pi-subagents/src/runs/shared/subagent-prompt-runtime.ts

@@ -2,11 +2,25 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@selesai/code";
 import { registerNativeSupervisorClient } from "../../intercom/native-supervisor-channel.ts";
-import { consumeSteerRequestsFromDir, writeSteerRequestToDir, type SteerRequest } from "../background/control-channel.ts";
-import { SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_STEER_INBOX_ENV } from "./pi-args.ts";
-import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
-import { TOOL_BUDGET_ENV, decodeToolBudgetEnv, shouldBlockToolForBudget, toolBudgetBlockedMessage, toolBudgetSoftNudge } from "./tool-budget.ts";
-import type { JsonSchemaObject, ResolvedToolBudget } from "../../shared/types.ts";
+import { consumeSteerRequestsFromDir, steerAckPathFromDir, writeSteerAckAt, writeSteerCapabilityAt, writeSteerRequestToDir, type SteerRequest } from "../background/control-channel.ts";
+import { SUBAGENT_CHILD_AGENT_ENV, SUBAGENT_CHILD_INDEX_ENV, SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_STEER_ACK_DIR_ENV, SUBAGENT_STEER_CAPABILITY_ENV, SUBAGENT_STEER_INBOX_ENV } from "./pi-args.ts";
+import { createStructuredOutputToolParameters, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
+import {
+	CHILD_TOOL_DIAGNOSTIC_PATH_ENV,
+	MCP_DIRECT_CHILD_TOOLS_ENV,
+	REQUIRED_CHILD_TOOLS_ENV,
+	writeChildToolDiagnostic,
+	type ChildToolDiagnostic,
+} from "./tool-availability.ts";
+import { TOOL_BUDGET_ENV, TOOL_BUDGET_ZERO_AUTH_ENV, decodeToolBudgetEnv, shouldBlockToolForBudget, toolBudgetBlockedMessage, toolBudgetSoftNudge } from "./tool-budget.ts";
+import type { JsonSchemaObject, ResolvedToolBudget, SubagentState } from "../../shared/types.ts";
+import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
+import { resolveWatchPath } from "../../shared/utils.ts";
+import { registerChildWatchdog } from "../../watchdog/register-child.ts";
+import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../watchdog/types.ts";
+import { resolveWaitToolConfig } from "../background/wait-config.ts";
+import { registerWaitTool } from "../background/wait-tool.ts";
+import { drainOutstandingWork } from "../background/auto-drain.ts";
 
 const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT";
 const SUBAGENT_INHERIT_SKILLS_ENV = "SELESAI_SUBAGENT_INHERIT_SKILLS";
@@ -55,6 +69,36 @@ function readBooleanEnv(name: string): boolean | undefined {
 	return value !== "0";
 }
 
+function readRequiredChildTools(): string[] | undefined {
+	const encoded = process.env[REQUIRED_CHILD_TOOLS_ENV]?.trim();
+	if (!encoded) return undefined;
+	const required = JSON.parse(encoded) as unknown;
+	if (!Array.isArray(required) || required.some((name) => typeof name !== "string" || !name)) {
+		throw new Error(`Invalid ${REQUIRED_CHILD_TOOLS_ENV} payload.`);
+	}
+	return required;
+}
+
+function readMcpDirectChildTools(): string[] | undefined {
+	const encoded = process.env[MCP_DIRECT_CHILD_TOOLS_ENV]?.trim();
+	if (!encoded) return undefined;
+	try {
+		const tools = JSON.parse(encoded) as unknown;
+		if (!Array.isArray(tools) || tools.some((name) => typeof name !== "string" || !name)) return undefined;
+		return tools;
+	} catch {
+		return undefined;
+	}
+}
+
+function refreshChildToolDiagnostic(pi: ExtensionAPI): ChildToolDiagnostic | undefined {
+	const filePath = process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV]?.trim();
+	const required = readRequiredChildTools();
+	if (!filePath || !required) return undefined;
+	const available = pi.getAllTools().map((tool) => tool.name);
+	return writeChildToolDiagnostic(filePath, required, available, process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim(), readMcpDirectChildTools());
+}
+
 function findSectionEnd(prompt: string, startIndex: number, nextHeaders: string[]): number {
 	let endIndex = prompt.length;
 	for (const header of nextHeaders) {
@@ -114,9 +158,9 @@ export function rewriteSubagentPrompt(
 
 function isParentOnlySubagentMessage(message: unknown): boolean {
 	const m = message as { role?: string; customType?: string };
-	return m?.role === "custom"
-		&& typeof m.customType === "string"
-		&& PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
+	if (m?.role !== "custom" || typeof m.customType !== "string") return false;
+	if (m.customType === SUBAGENT_WATCHDOG_WARNING_TYPE) return true;
+	return PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
 }
 
 function isSubagentToolResultMessage(message: unknown): boolean {
@@ -190,29 +234,59 @@ function registerToolBudget(pi: ExtensionAPI, budget: ResolvedToolBudget | undef
 	});
 }
 
-function registerSteeringInbox(pi: ExtensionAPI): void {
+export function registerSteeringInbox(
+	pi: ExtensionAPI,
+	deps: { watch?: typeof fs.watch; nativeRealpath?: (filePath: string) => string } = {},
+): void {
 	const steerInbox = process.env[SUBAGENT_STEER_INBOX_ENV]?.trim();
 	if (!steerInbox) return;
+	const capabilityPath = process.env[SUBAGENT_STEER_CAPABILITY_ENV]?.trim();
+	const ackDir = process.env[SUBAGENT_STEER_ACK_DIR_ENV]?.trim();
 	const sendUserMessage = (pi as { sendUserMessage?: (content: string, options: { deliverAs: "steer" }) => unknown }).sendUserMessage;
-	if (typeof sendUserMessage !== "function") return;
-
-	let canSteer = false;
+	const childIndex = Number(process.env[SUBAGENT_CHILD_INDEX_ENV]);
+	const pending = new Map<string, string[]>();
 	let disposed = false;
 	let flushing = false;
 	let started = false;
+	let canSteer = typeof sendUserMessage === "function";
 	let watcher: fs.FSWatcher | undefined;
 	let interval: NodeJS.Timeout | undefined;
+	const acknowledge = (request: SteerRequest, state: "delivered" | "failed", message: string): void => {
+		if (!ackDir || !Number.isInteger(childIndex) || childIndex < 0) return;
+		writeSteerAckAt(steerAckPathFromDir(ackDir, request.id), {
+			requestId: request.id,
+			index: childIndex,
+			ts: Date.now(),
+			state,
+			message,
+		});
+	};
+	const publishCapability = (): void => {
+		if (!capabilityPath || !Number.isInteger(childIndex) || childIndex < 0) return;
+		writeSteerCapabilityAt(capabilityPath, { index: childIndex, pid: process.pid, readyAt: Date.now(), supported: canSteer });
+	};
 	const flush = (): void => {
-		if (disposed || flushing || !canSteer) return;
+		if (disposed || flushing) return;
 		flushing = true;
 		try {
 			const requests = consumeSteerRequestsFromDir(steerInbox);
 			for (let index = 0; index < requests.length; index++) {
 				const request = requests[index]!;
+				if (!canSteer || typeof sendUserMessage !== "function") {
+					acknowledge(request, "failed", "Child Pi session does not support sendUserMessage steering.");
+					continue;
+				}
+				const formatted = formatSteerMessage(request);
+				const ids = pending.get(formatted) ?? [];
+				ids.push(request.id);
+				pending.set(formatted, ids);
 				try {
-					sendUserMessage(formatSteerMessage(request), { deliverAs: "steer" });
-				} catch {
-					for (const pending of requests.slice(index)) writeSteerRequestToDir(steerInbox, pending);
+					sendUserMessage(formatted, { deliverAs: "steer" });
+				} catch (error) {
+					ids.pop();
+					if (ids.length === 0) pending.delete(formatted);
+					acknowledge(request, "failed", error instanceof Error ? error.message : String(error));
+					for (const retry of requests.slice(index + 1)) writeSteerRequestToDir(steerInbox, retry);
 					break;
 				}
 			}
@@ -220,16 +294,30 @@ function registerSteeringInbox(pi: ExtensionAPI): void {
 			flushing = false;
 		}
 	};
+	const onInput = (event: unknown): undefined => {
+		if (disposed || !event || typeof event !== "object") return undefined;
+		const input = event as { source?: unknown; streamingBehavior?: unknown; text?: unknown; content?: unknown };
+		if (input.source !== "extension" || input.streamingBehavior !== "steer") return undefined;
+		const text = typeof input.text === "string" ? input.text : typeof input.content === "string" ? input.content : undefined;
+		if (!text) return undefined;
+		const ids = pending.get(text);
+		const requestId = ids?.shift();
+		if (!requestId) return undefined;
+		if (ids?.length === 0) pending.delete(text);
+		acknowledge({ type: "steer", id: requestId, ts: Date.now(), message: text }, "delivered", "Pi accepted the correlated steering input.");
+		return undefined;
+	};
 	const start = (): void => {
 		if (started || disposed) return;
 		try {
 			fs.mkdirSync(steerInbox, { recursive: true });
+			publishCapability();
 		} catch {
 			return;
 		}
 		started = true;
 		try {
-			watcher = fs.watch(steerInbox, () => flush());
+			watcher = (deps.watch ?? fs.watch)(resolveWatchPath(steerInbox, deps.nativeRealpath), () => flush());
 			watcher.on("error", () => {});
 		} catch {
 			watcher = undefined;
@@ -239,28 +327,44 @@ function registerSteeringInbox(pi: ExtensionAPI): void {
 	};
 	const activate = (): undefined => {
 		start();
-		canSteer = true;
 		flush();
 		return undefined;
 	};
 
 	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
+	// Register input before the watcher so an accepted extension input cannot race request dispatch.
+	onRuntimeEvent("input", onInput);
 	onRuntimeEvent("session_start", () => start());
 	for (const eventName of ["message_start", "message_update", "message_end", "tool_execution_start", "tool_execution_end", "turn_end"] as const) {
 		onRuntimeEvent(eventName, activate);
 	}
 	onRuntimeEvent("session_shutdown", () => {
 		disposed = true;
-		try {
-			watcher?.close();
-		} catch {}
+		try { watcher?.close(); } catch {}
 		if (interval) clearInterval(interval);
 	});
 }
 
 export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 	registerSteeringInbox(pi);
-	registerToolBudget(pi, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV]));
+	registerToolBudget(pi, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV], { allowZero: process.env[TOOL_BUDGET_ZERO_AUTH_ENV] === "1" }));
+	registerChildWatchdog(pi);
+	const waitToolEnabled = resolveWaitToolConfig().enabled;
+	const waitState = {
+		baseCwd: "",
+		currentSessionId: null,
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	} as unknown as SubagentState;
+	if (typeof pi.registerTool === "function") registerWaitTool(pi, waitState, waitToolEnabled);
 	let nativeSupervisorClientRegistered = false;
 	let nativeSupervisorFallbackRegistered = false;
 	const registerNativeSupervisorClientOnce = (): void => {
@@ -275,17 +379,24 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 		registerNativeSupervisorClient(pi);
 	};
 	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
-	onRuntimeEvent("session_start", registerNativeSupervisorClientOnce);
+	onRuntimeEvent("session_start", (_event: unknown, ctx: unknown) => {
+		const sessionManager = (ctx as { sessionManager?: Parameters<typeof resolveCurrentSessionId>[0] } | undefined)?.sessionManager;
+		waitState.currentSessionId = sessionManager ? resolveCurrentSessionId(sessionManager) : null;
+		registerNativeSupervisorClientOnce();
+		if (readRequiredChildTools()?.includes("intercom")) registerNativeSupervisorFallbackOnce();
+	});
+	onRuntimeEvent("agent_start", () => {
+		refreshChildToolDiagnostic(pi);
+	});
+	onRuntimeEvent("agent_end", async (_event: unknown, ctx: unknown) => {
+		if ((ctx as { hasUI?: boolean } | undefined)?.hasUI === true) return;
+		await drainOutstandingWork({ state: waitState, events: pi.events });
+	});
 	const structuredOutputPath = process.env[STRUCTURED_OUTPUT_CAPTURE_ENV];
 	const structuredSchemaPath = process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
 	if (structuredOutputPath && structuredSchemaPath) {
 		const schema = JSON.parse(fs.readFileSync(structuredSchemaPath, "utf-8")) as JsonSchemaObject;
-		const parameters = {
-			type: "object",
-			properties: { value: schema },
-			required: ["value"],
-			additionalProperties: false,
-		};
+		const parameters = createStructuredOutputToolParameters(schema);
 		const registerTool = pi.registerTool as unknown as (tool: {
 			name: string;
 			label: string;
@@ -299,7 +410,7 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 			description: "Submit the required final structured output for this subagent step. This terminates the step.",
 			parameters: parameters as never,
 			async execute(_id: string, params: { value: unknown }) {
-				const validation = validateStructuredOutputValue(schema, params.value);
+				const validation = await validateStructuredOutputValue(schema, params.value);
 				if (validation.status === "invalid") {
 					throw new Error(`Structured output validation failed: ${validation.message}`);
 				}
@@ -330,12 +441,14 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 		const inheritProjectContext = readBooleanEnv(SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV);
 		const inheritSkills = readBooleanEnv(SUBAGENT_INHERIT_SKILLS_ENV);
 		const fanoutChild = readBooleanEnv(SUBAGENT_FANOUT_CHILD_ENV);
-		if (inheritProjectContext === undefined && inheritSkills === undefined && fanoutChild === undefined) return;
-		const rewritten = rewriteSubagentPrompt(event.systemPrompt, {
-			inheritProjectContext: inheritProjectContext ?? true,
-			inheritSkills: inheritSkills ?? true,
-			fanoutChild: fanoutChild === true,
-		});
+		let rewritten = event.systemPrompt;
+		if (inheritProjectContext !== undefined || inheritSkills !== undefined || fanoutChild !== undefined) {
+			rewritten = rewriteSubagentPrompt(event.systemPrompt, {
+				inheritProjectContext: inheritProjectContext ?? true,
+				inheritSkills: inheritSkills ?? true,
+				fanoutChild: fanoutChild === true,
+			});
+		}
 		if (rewritten === event.systemPrompt) return;
 		return { systemPrompt: rewritten };
 	});