@duckmind/dm-darwin-x64 0.43.2 → 0.43.8

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

@@ -1,223 +0,0 @@
-import {
-	type ActivityState,
-	type ControlConfig,
-	type ControlEvent,
-	type ControlEventType,
-	type ControlNotificationChannel,
-	type ResolvedControlConfig,
-} from "../../shared/types.ts";
-
-const CONTROL_EVENT_TYPES: ControlEventType[] = ["active_long_running", "needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "async", "intercom"];
-const DEFAULT_NOTIFY_ON: ControlEventType[] = ["active_long_running", "needs_attention"];
-
-export const DEFAULT_CONTROL_CONFIG: ResolvedControlConfig = {
-	enabled: true,
-	needsAttentionAfterMs: 60_000,
-	activeNoticeAfterMs: 240_000,
-	failedToolAttemptsBeforeAttention: 3,
-	notifyOn: DEFAULT_NOTIFY_ON,
-	notifyChannels: CONTROL_NOTIFICATION_CHANNELS,
-};
-
-function parsePositiveInt(value: unknown): number | undefined {
-	if (typeof value !== "number") return undefined;
-	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) return undefined;
-	return value;
-}
-
-function parseControlList<T extends string>(value: unknown, allowed: readonly T[]): T[] | undefined {
-	if (!Array.isArray(value)) return undefined;
-	if (value.length === 0) return [];
-	const allowedSet = new Set(allowed);
-	const parsed = value.filter((entry): entry is T => typeof entry === "string" && allowedSet.has(entry as T));
-	return parsed.length > 0 ? Array.from(new Set(parsed)) : undefined;
-}
-
-export function resolveControlConfig(
-	globalConfig?: ControlConfig,
-	override?: ControlConfig,
-): ResolvedControlConfig {
-	const enabled = override?.enabled ?? globalConfig?.enabled ?? DEFAULT_CONTROL_CONFIG.enabled;
-	const needsAttentionAfterMs = parsePositiveInt(override?.needsAttentionAfterMs)
-		?? parsePositiveInt(globalConfig?.needsAttentionAfterMs)
-		?? DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs;
-	const activeNoticeAfterMs = parsePositiveInt(override?.activeNoticeAfterMs)
-		?? parsePositiveInt(globalConfig?.activeNoticeAfterMs)
-		?? DEFAULT_CONTROL_CONFIG.activeNoticeAfterMs;
-	const activeNoticeAfterTurns = parsePositiveInt(override?.activeNoticeAfterTurns)
-		?? parsePositiveInt(globalConfig?.activeNoticeAfterTurns);
-	const activeNoticeAfterTokens = parsePositiveInt(override?.activeNoticeAfterTokens)
-		?? parsePositiveInt(globalConfig?.activeNoticeAfterTokens);
-	const failedToolAttemptsBeforeAttention = parsePositiveInt(override?.failedToolAttemptsBeforeAttention)
-		?? parsePositiveInt(globalConfig?.failedToolAttemptsBeforeAttention)
-		?? DEFAULT_CONTROL_CONFIG.failedToolAttemptsBeforeAttention;
-	const notifyOn = parseControlList(override?.notifyOn, CONTROL_EVENT_TYPES)
-		?? parseControlList(globalConfig?.notifyOn, CONTROL_EVENT_TYPES)
-		?? DEFAULT_CONTROL_CONFIG.notifyOn;
-	const notifyChannels = parseControlList(override?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS)
-		?? parseControlList(globalConfig?.notifyChannels, CONTROL_NOTIFICATION_CHANNELS)
-		?? DEFAULT_CONTROL_CONFIG.notifyChannels;
-	return {
-		enabled,
-		needsAttentionAfterMs,
-		activeNoticeAfterMs,
-		activeNoticeAfterTurns,
-		activeNoticeAfterTokens,
-		failedToolAttemptsBeforeAttention,
-		notifyOn: [...notifyOn],
-		notifyChannels: [...notifyChannels],
-	};
-}
-
-export function deriveActivityState(input: {
-	config: ResolvedControlConfig;
-	startedAt: number;
-	lastActivityAt?: number;
-	now?: number;
-}): ActivityState | undefined {
-	if (!input.config.enabled) return undefined;
-	const now = input.now ?? Date.now();
-	const lastActivity = input.lastActivityAt ?? input.startedAt;
-	const ageMs = Math.max(0, now - lastActivity);
-	return ageMs > input.config.needsAttentionAfterMs ? "needs_attention" : undefined;
-}
-
-export function buildControlEvent(input: {
-	type?: ControlEventType;
-	from?: ActivityState;
-	to: ActivityState;
-	runId: string;
-	agent: string;
-	index?: number;
-	ts?: number;
-	lastActivityAt?: number;
-	message?: string;
-	reason?: ControlEvent["reason"];
-	turns?: number;
-	tokens?: number;
-	toolCount?: number;
-	currentTool?: string;
-	currentToolDurationMs?: number;
-	currentPath?: string;
-	elapsedMs?: number;
-	recentFailureSummary?: string;
-}): ControlEvent {
-	const ts = input.ts ?? Date.now();
-	const type = input.type ?? (input.to === "active_long_running" ? "active_long_running" : "needs_attention");
-	const elapsedMs = input.elapsedMs ?? (input.lastActivityAt ? Math.max(0, ts - input.lastActivityAt) : undefined);
-	const elapsedSeconds = elapsedMs !== undefined ? Math.floor(elapsedMs / 1000) : undefined;
-	const message = input.message ?? (type === "active_long_running"
-		? `${input.agent} is still active but long-running`
-		: elapsedSeconds !== undefined
-			? `${input.agent} needs attention (no observed activity for ${elapsedSeconds}s)`
-			: `${input.agent} needs attention`);
-	return {
-		type,
-		...(input.from ? { from: input.from } : {}),
-		to: input.to,
-		ts,
-		runId: input.runId,
-		agent: input.agent,
-		...(input.index !== undefined ? { index: input.index } : {}),
-		message,
-		reason: input.reason ?? (type === "active_long_running" ? "active_long_running" : "idle"),
-		...(input.turns !== undefined ? { turns: input.turns } : {}),
-		...(input.tokens !== undefined ? { tokens: input.tokens } : {}),
-		...(input.toolCount !== undefined ? { toolCount: input.toolCount } : {}),
-		...(input.currentTool ? { currentTool: input.currentTool } : {}),
-		...(input.currentToolDurationMs !== undefined ? { currentToolDurationMs: input.currentToolDurationMs } : {}),
-		...(input.currentPath ? { currentPath: input.currentPath } : {}),
-		...(elapsedMs !== undefined ? { elapsedMs } : {}),
-		...(input.recentFailureSummary ? { recentFailureSummary: input.recentFailureSummary } : {}),
-	};
-}
-
-export function shouldNotifyControlEvent(config: ResolvedControlConfig, event: ControlEvent): boolean {
-	return config.enabled && config.notifyOn.includes(event.type);
-}
-
-export function controlNotificationKey(event: ControlEvent, childIntercomTarget?: string): string {
-	const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
-	return `${childKey}:${event.type}:${event.reason ?? "idle"}`;
-}
-
-export function claimControlNotification(config: ResolvedControlConfig, event: ControlEvent, seenKeys: Set<string>, childIntercomTarget?: string): boolean {
-	if (!shouldNotifyControlEvent(config, event)) return false;
-	const key = controlNotificationKey(event, childIntercomTarget);
-	if (seenKeys.has(key)) return false;
-	seenKeys.add(key);
-	return true;
-}
-
-function formatLongRunningFacts(event: ControlEvent): string | undefined {
-	const facts: string[] = [];
-	if (event.elapsedMs !== undefined) facts.push(`elapsed ${Math.floor(Math.max(0, event.elapsedMs) / 1000)}s`);
-	if (event.turns !== undefined) facts.push(`${event.turns} turns`);
-	if (event.tokens !== undefined) facts.push(`${event.tokens} tokens`);
-	if (event.toolCount !== undefined) facts.push(`${event.toolCount} tools`);
-	if (event.currentTool) facts.push(`tool ${event.currentTool}${event.currentToolDurationMs !== undefined ? ` ${Math.floor(Math.max(0, event.currentToolDurationMs) / 1000)}s` : ""}`);
-	if (event.currentPath) facts.push(`path ${event.currentPath}`);
-	return facts.length > 0 ? facts.join(" | ") : undefined;
-}
-
-export function formatControlNoticeMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	const runTarget = event.runId;
-	if (event.reason === "completion_guard") {
-		return [
-			`Subagent failed: ${event.agent}`,
-			`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-			`Signal: ${event.message}`,
-			"Next: read the output artifact or session from the subagent result, then retry with a more explicit implementation prompt or handle the fix directly.",
-			childIntercomTarget ? `Run intercom target (may be inactive): ${childIntercomTarget}` : undefined,
-		].filter((line): line is string => Boolean(line)).join("\n");
-	}
-
-	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}" })`;
-	if (event.type === "active_long_running") {
-		const facts = formatLongRunningFacts(event);
-		return [
-			`Subagent active but long-running: ${event.agent}`,
-			`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}`,
-			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");
-	}
-
-	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}`,
-		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");
-}
-
-export function formatControlIntercomMessage(event: ControlEvent, childIntercomTarget?: string): string {
-	const statusLabel = event.reason === "completion_guard"
-		? "subagent failed"
-		: event.type === "active_long_running"
-			? "subagent active but long-running"
-			: "subagent needs attention";
-	return [
-		statusLabel,
-		"",
-		event.reason === "completion_guard"
-			? `${event.agent} failed in run ${event.runId}.`
-			: event.type === "active_long_running"
-				? `${event.agent} is still active but long-running in run ${event.runId}.`
-				: `${event.agent} needs attention in run ${event.runId}.`,
-		"",
-		formatControlNoticeMessage(event, childIntercomTarget),
-	].join("\n");
-}

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

@@ -1,342 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionAPI } from "@duckmind/dm-coding-agent";
-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 "./dm-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";
-
-const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "DM_SUBAGENT_INHERIT_PROJECT_CONTEXT";
-const SUBAGENT_INHERIT_SKILLS_ENV = "DM_SUBAGENT_INHERIT_SKILLS";
-export const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "DM_SUBAGENT_INTERCOM_SESSION_NAME";
-
-const STRUCTURED_OUTPUT_INSTRUCTIONS = [
-	"This subagent step has a strict structured output contract.",
-	"Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
-	"Do not rely on prose-only completion; if you do not call `structured_output`, the parent will fail this step.",
-].join("\n");
-
-export const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
-	"You are a child subagent, not the parent orchestrator.",
-	"The parent session owns delegation, orchestration, review fanout, and follow-up worker launches.",
-	"Ignore prior parent-only orchestration instructions in inherited conversation history.",
-	"Do not propose or run subagents. Complete only your assigned role-specific task with the tools available to you.",
-	"If you need to edit files, use the available editing tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
-].join("\n");
-
-export const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
-	"You are a child subagent with explicit fanout responsibility for this assigned task.",
-	"The parent session owns final orchestration, acceptance, and follow-up implementation launches.",
-	"You may use the `subagent` tool only for the fanout work explicitly requested in this task.",
-	"Do not broaden yourself into general parent orchestration. Do not launch follow-up workers unless the task explicitly asks for that.",
-	"The maxSubagentDepth cap still applies and may block further fanout.",
-	"If you need to edit files, use the available editing tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
-].join("\n");
-
-const PARENT_ONLY_CUSTOM_MESSAGE_TYPES = new Set([
-	"subagent-orchestration-instructions",
-	"subagent-slash-result",
-	"subagent-slash-text-result",
-	"subagent-notify",
-	"subagent_control_notice",
-	"subagent-control",
-	"subagent-control-notice",
-]);
-const SUBAGENT_ORCHESTRATION_SKILL_NAME_PATTERN = /<name>\s*dm-subagents\s*<\/name>/;
-const PROJECT_CONTEXT_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
-const SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
-const DATE_HEADER = "\nCurrent date:";
-
-function readBooleanEnv(name: string): boolean | undefined {
-	const value = process.env[name];
-	if (value === undefined) return undefined;
-	return value !== "0";
-}
-
-function findSectionEnd(prompt: string, startIndex: number, nextHeaders: string[]): number {
-	let endIndex = prompt.length;
-	for (const header of nextHeaders) {
-		const index = prompt.indexOf(header, startIndex);
-		if (index !== -1 && index < endIndex) {
-			endIndex = index;
-		}
-	}
-	return endIndex;
-}
-
-export function stripProjectContext(prompt: string): string {
-	const startIndex = prompt.indexOf(PROJECT_CONTEXT_HEADER);
-	if (startIndex === -1) return prompt;
-	const endIndex = findSectionEnd(prompt, startIndex + PROJECT_CONTEXT_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
-	return `${prompt.slice(0, startIndex)}${prompt.slice(endIndex)}`;
-}
-
-export function stripInheritedSkills(prompt: string): string {
-	const startIndex = prompt.indexOf(SKILLS_HEADER);
-	if (startIndex === -1) return prompt;
-	const endIndex = findSectionEnd(prompt, startIndex + SKILLS_HEADER.length, [DATE_HEADER]);
-	return `${prompt.slice(0, startIndex)}${prompt.slice(endIndex)}`;
-}
-
-export function stripSubagentOrchestrationSkill(prompt: string): string {
-	return prompt
-		.replace(/\n{0,2}<skill\s+name=["']dm-subagents["'][^>]*>[\s\S]*?<\/skill>\n{0,2}/g, "\n\n")
-		.replace(/[ \t]*<skill>\s*[\s\S]*?<\/skill>\s*/g, (block) => SUBAGENT_ORCHESTRATION_SKILL_NAME_PATTERN.test(block) ? "" : block);
-}
-
-function stripChildBoundaryInstructions(prompt: string): string {
-	let rewritten = prompt;
-	for (const boundary of [CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS, CHILD_FANOUT_BOUNDARY_INSTRUCTIONS]) {
-		rewritten = rewritten.split(boundary).join("");
-	}
-	return rewritten.replace(/^(?:[ \t]*\r?\n)+/, "");
-}
-
-export function rewriteSubagentPrompt(
-	prompt: string,
-	options: { inheritProjectContext: boolean; inheritSkills: boolean; fanoutChild?: boolean },
-): string {
-	let rewritten = prompt;
-	if (!options.inheritProjectContext) {
-		rewritten = stripProjectContext(rewritten);
-	}
-	if (!options.inheritSkills) {
-		rewritten = stripInheritedSkills(rewritten);
-	}
-	rewritten = stripSubagentOrchestrationSkill(rewritten);
-	rewritten = stripChildBoundaryInstructions(rewritten);
-	const boundary = options.fanoutChild ? CHILD_FANOUT_BOUNDARY_INSTRUCTIONS : CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS;
-	const structured = process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] ? `\n\n${STRUCTURED_OUTPUT_INSTRUCTIONS}` : "";
-	return `${boundary}${structured}\n\n${rewritten}`;
-}
-
-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);
-}
-
-function isSubagentToolResultMessage(message: unknown): boolean {
-	const m = message as { role?: string; toolName?: string };
-	return m?.role === "toolResult" && m.toolName === "subagent";
-}
-
-function isSubagentToolCallBlock(block: unknown): boolean {
-	const b = block as { type?: string; name?: string };
-	return b?.type === "toolCall" && b.name === "subagent";
-}
-
-function stripAssistantSubagentToolCallBlocks(message: unknown): unknown | undefined {
-	const m = message as { role?: string; content?: unknown };
-	if (m?.role !== "assistant" || !Array.isArray(m.content)) return message;
-	const filteredContent = m.content.filter((block) => !isSubagentToolCallBlock(block));
-	if (filteredContent.length === m.content.length) return message;
-	if (filteredContent.length === 0) return undefined;
-	return { ...m, content: filteredContent };
-}
-
-export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[] {
-	const preserveCurrentFanoutToolHistory = process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
-	let changed = false;
-	const filtered: unknown[] = [];
-	for (const message of messages) {
-		if (isParentOnlySubagentMessage(message) || (!preserveCurrentFanoutToolHistory && isSubagentToolResultMessage(message))) {
-			changed = true;
-			continue;
-		}
-		const stripped = preserveCurrentFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
-		if (stripped === undefined) {
-			changed = true;
-			continue;
-		}
-		if (stripped !== message) changed = true;
-		filtered.push(stripped);
-	}
-	return changed ? filtered : messages;
-}
-
-export function formatSteerMessage(request: SteerRequest): string {
-	return [
-		"Mid-run steering from the parent orchestrator:",
-		"",
-		request.message,
-		"",
-		"Incorporate this guidance at the next safe point. Do not restart the task unless the guidance explicitly asks you to.",
-	].join("\n");
-}
-
-function registerToolBudget(pi: ExtensionAPI, budget: ResolvedToolBudget | undefined): void {
-	if (!budget) return;
-	let toolCount = 0;
-	let softNudged = false;
-	const sendUserMessage = (pi as { sendUserMessage?: (content: string, options: { deliverAs: "steer" }) => unknown }).sendUserMessage;
-	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: { toolName?: string }) => unknown) => void;
-	onRuntimeEvent("tool_call", (event) => {
-		const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
-		toolCount++;
-		if (budget.soft !== undefined && toolCount >= budget.soft && !softNudged) {
-			softNudged = true;
-			try {
-				sendUserMessage?.(toolBudgetSoftNudge(budget, toolCount), { deliverAs: "steer" });
-			} catch {
-				// Budget nudges are advisory; blocking below remains authoritative.
-			}
-		}
-		if (!shouldBlockToolForBudget(budget, toolName, toolCount)) return undefined;
-		return { block: true, reason: toolBudgetBlockedMessage(budget, toolName, toolCount) };
-	});
-}
-
-function registerSteeringInbox(pi: ExtensionAPI): void {
-	const steerInbox = process.env[SUBAGENT_STEER_INBOX_ENV]?.trim();
-	if (!steerInbox) return;
-	const sendUserMessage = (pi as { sendUserMessage?: (content: string, options: { deliverAs: "steer" }) => unknown }).sendUserMessage;
-	if (typeof sendUserMessage !== "function") return;
-
-	let canSteer = false;
-	let disposed = false;
-	let flushing = false;
-	let started = false;
-	let watcher: fs.FSWatcher | undefined;
-	let interval: NodeJS.Timeout | undefined;
-	const flush = (): void => {
-		if (disposed || flushing || !canSteer) return;
-		flushing = true;
-		try {
-			const requests = consumeSteerRequestsFromDir(steerInbox);
-			for (let index = 0; index < requests.length; index++) {
-				const request = requests[index]!;
-				try {
-					sendUserMessage(formatSteerMessage(request), { deliverAs: "steer" });
-				} catch {
-					for (const pending of requests.slice(index)) writeSteerRequestToDir(steerInbox, pending);
-					break;
-				}
-			}
-		} finally {
-			flushing = false;
-		}
-	};
-	const start = (): void => {
-		if (started || disposed) return;
-		try {
-			fs.mkdirSync(steerInbox, { recursive: true });
-		} catch {
-			return;
-		}
-		started = true;
-		try {
-			watcher = fs.watch(steerInbox, () => flush());
-			watcher.on("error", () => {});
-		} catch {
-			watcher = undefined;
-		}
-		interval = setInterval(flush, 250);
-		interval.unref?.();
-	};
-	const activate = (): undefined => {
-		start();
-		canSteer = true;
-		flush();
-		return undefined;
-	};
-
-	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
-	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 {}
-		if (interval) clearInterval(interval);
-	});
-}
-
-export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
-	registerSteeringInbox(pi);
-	registerToolBudget(pi, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV]));
-	let nativeSupervisorClientRegistered = false;
-	let nativeSupervisorFallbackRegistered = false;
-	const registerNativeSupervisorClientOnce = (): void => {
-		if (nativeSupervisorClientRegistered) return;
-		nativeSupervisorClientRegistered = true;
-		registerNativeSupervisorClient(pi, { includeIntercomFallback: false });
-	};
-	const registerNativeSupervisorFallbackOnce = (): void => {
-		registerNativeSupervisorClientOnce();
-		if (nativeSupervisorFallbackRegistered) return;
-		nativeSupervisorFallbackRegistered = true;
-		registerNativeSupervisorClient(pi);
-	};
-	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
-	onRuntimeEvent("session_start", registerNativeSupervisorClientOnce);
-	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 registerTool = pi.registerTool as unknown as (tool: {
-			name: string;
-			label: string;
-			description: string;
-			parameters: unknown;
-			execute: (_id: string, params: { value: unknown }) => Promise<unknown>;
-		}) => void;
-		registerTool({
-			name: "structured_output",
-			label: "Structured Output",
-			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);
-				if (validation.status === "invalid") {
-					throw new Error(`Structured output validation failed: ${validation.message}`);
-				}
-				fs.mkdirSync(path.dirname(structuredOutputPath), { recursive: true });
-				fs.writeFileSync(structuredOutputPath, JSON.stringify(params.value), { mode: 0o600 });
-				return {
-					content: [{ type: "text", text: "Structured output captured." }],
-					details: { path: structuredOutputPath },
-					terminate: true,
-				};
-			},
-		});
-	}
-
-	onRuntimeEvent("context", (event: { messages: unknown[] }) => {
-		const messages = stripParentOnlySubagentMessages(event.messages);
-		if (messages === event.messages) return undefined;
-		return { messages };
-	});
-
-	onRuntimeEvent("before_agent_start", async (event: { systemPrompt: string }) => {
-		registerNativeSupervisorFallbackOnce();
-		const intercomSessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
-		if (intercomSessionName && typeof pi.setSessionName === "function") {
-			pi.setSessionName(intercomSessionName);
-		}
-
-		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,
-		});
-		if (rewritten === event.systemPrompt) return;
-		return { systemPrompt: rewritten };
-	});
-}

package/extensions/dm-subagents/src/runs/shared/tool-budget.ts

@@ -1,74 +0,0 @@
-import type { ResolvedToolBudget, ToolBudgetConfig, ToolBudgetState } from "../../shared/types.ts";
-
-export const DEFAULT_TOOL_BUDGET_BLOCK = ["read", "grep", "find", "ls"] as const;
-export const TOOL_BUDGET_ENV = "DM_SUBAGENT_TOOL_BUDGET";
-
-export function normalizeToolBudgetBlock(block: ToolBudgetConfig["block"] | undefined): "*" | string[] {
-	if (block === "*") return "*";
-	if (block === undefined) return [...DEFAULT_TOOL_BUDGET_BLOCK];
-	return [...new Set(block.map((tool) => tool.trim()).filter(Boolean))];
-}
-
-export function validateToolBudgetConfig(raw: unknown, label = "toolBudget"): { budget?: ResolvedToolBudget; error?: string } {
-	if (raw === undefined) return {};
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { error: `${label} must be an object with hard and optional soft/block.` };
-	const value = raw as ToolBudgetConfig;
-	if (typeof value.hard !== "number" || !Number.isInteger(value.hard) || value.hard < 1) {
-		return { error: `${label}.hard must be an integer >= 1.` };
-	}
-	if (value.soft !== undefined && (typeof value.soft !== "number" || !Number.isInteger(value.soft) || value.soft < 1)) {
-		return { error: `${label}.soft must be an integer >= 1 when provided.` };
-	}
-	if (value.soft !== undefined && value.soft > value.hard) {
-		return { error: `${label}.soft must be <= ${label}.hard.` };
-	}
-	if (value.block !== undefined && value.block !== "*") {
-		if (!Array.isArray(value.block)) return { error: `${label}.block must be "*" or an array of tool names.` };
-		if (value.block.length === 0) return { error: `${label}.block must contain at least one tool name.` };
-		for (const item of value.block) {
-			if (typeof item !== "string" || !item.trim()) return { error: `${label}.block must contain non-empty tool names.` };
-		}
-	}
-	return { budget: { hard: value.hard, ...(value.soft !== undefined ? { soft: value.soft } : {}), block: normalizeToolBudgetBlock(value.block) } };
-}
-
-export function initialToolBudgetState(budget: ResolvedToolBudget): ToolBudgetState {
-	return { ...budget, toolCount: 0, outcome: "within-budget" };
-}
-
-export function toolBudgetState(budget: ResolvedToolBudget, toolCount: number, blockedTool?: string): ToolBudgetState {
-	const overHard = toolCount > budget.hard;
-	const overSoft = budget.soft !== undefined && toolCount >= budget.soft;
-	return {
-		...budget,
-		toolCount,
-		outcome: overHard ? "hard-blocked" : overSoft ? "soft-reached" : "within-budget",
-		...(overSoft ? { softReachedAt: budget.soft } : {}),
-		...(overHard ? { hardReachedAt: budget.hard, blockedTool } : {}),
-	};
-}
-
-export function shouldBlockToolForBudget(budget: ResolvedToolBudget, toolName: string, nextToolCount: number): boolean {
-	if (nextToolCount <= budget.hard) return false;
-	return budget.block === "*" || budget.block.includes(toolName);
-}
-
-export function toolBudgetSoftNudge(budget: ResolvedToolBudget, toolCount: number): string {
-	return `Tool budget soft limit reached after ${toolCount} tool call${toolCount === 1 ? "" : "s"} (soft ${budget.soft}, hard ${budget.hard}). Stop starting new browsing/search work and finalize from the context you already have.`;
-}
-
-export function toolBudgetBlockedMessage(budget: ResolvedToolBudget, toolName: string, toolCount: number): string {
-	return `Tool budget hard limit reached after ${toolCount} tool call${toolCount === 1 ? "" : "s"} (hard ${budget.hard}). The '${toolName}' tool is blocked so you can finalize from the context you already have.`;
-}
-
-export function encodeToolBudgetEnv(budget: ResolvedToolBudget | undefined): string | undefined {
-	return budget ? JSON.stringify(budget) : undefined;
-}
-
-export function decodeToolBudgetEnv(value: string | undefined): ResolvedToolBudget | undefined {
-	if (!value?.trim()) return undefined;
-	const parsed = JSON.parse(value) as unknown;
-	const normalized = validateToolBudgetConfig(parsed, TOOL_BUDGET_ENV);
-	if (normalized.error) throw new Error(normalized.error);
-	return normalized.budget;
-}