@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

package/dist/builtin/subagents/src/runs/foreground/subagent-executor.ts

@@ -1,254 +0,0 @@
-import type { ExtensionContext } from "@bastani/atomic";
-import { handleManagementAction } from "../../agents/agent-management.js";
-import { clearPendingForegroundControlNotices } from "../../extension/control-notices.js";
-import { buildDoctorReport } from "../../extension/doctor.js";
-import { resolveIntercomSessionTarget } from "../../intercom/intercom-bridge.js";
-import { SUBAGENT_ACTIONS, type SubagentToolResult } from "../../shared/types.js";
-import { inspectInProcessChildStatus, interruptInProcessChild } from "../inprocess/control-status.js";
-import { createExecutionBurstDispatcher } from "./subagent-executor-burst.js";
-import { prepareExecutionContext, refuseSubagentChildDelegation } from "./subagent-executor-context.js";
-import { resolveRequestedCwd } from "./subagent-executor-cwd.js";
-import { toExecutionErrorResult, withForkContext } from "./subagent-executor-input.js";
-import { runParallelPath } from "./subagent-executor-parallel.js";
-import { resolveSubagentExecutorRuntimeDeps } from "./subagent-executor-runtime.js";
-import { runSinglePath } from "./subagent-executor-single.js";
-import { foregroundStatusResult, getForegroundControl } from "./subagent-executor-status.js";
-import {
-	type ExecutorDeps,
-	isManagementActionsRestricted,
-	type ResolvedExecutorDeps,
-	type SubagentParamsLike,
-} from "./subagent-executor-types.js";
-
-const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
-/** Observing management actions do not start or mutate child execution. */
-const READ_ONLY_MANAGEMENT_ACTIONS = new Set(["list", "get", "status", "doctor"]);
-const FANOUT_REFUSAL_MESSAGE = "Subagent fanout is not authorized for this child.";
-
-export type { SubagentExecutorRuntimeDeps, SubagentParamsLike } from "./subagent-executor-types.js";
-
-async function handleManagementRequest(input: {
-	params: SubagentParamsLike;
-	paramsWithResolvedCwd: SubagentParamsLike;
-	requestCwd: string;
-	ctx: ExtensionContext;
-	deps: ResolvedExecutorDeps;
-}): Promise<SubagentToolResult> {
-	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
-	const action = params.action;
-	if (!action) {
-		return {
-			content: [{ type: "text", text: "Missing action." }],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	if (!(SUBAGENT_ACTIONS as readonly string[]).includes(action)) {
-		return {
-			content: [{ type: "text", text: `Unknown action: ${action}. Valid: ${SUBAGENT_ACTIONS.join(", ")}` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	if (isManagementActionsRestricted(deps) && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
-		return {
-			content: [{ type: "text", text: `Action '${action}' is not available from child-safe subagent fanout mode.` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	// `interrupt` is privileged control over a running child, so only the
-	// observing actions reach handlers for a child without fanout authorization.
-	if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized && !READ_ONLY_MANAGEMENT_ACTIONS.has(action)) {
-		return {
-			content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	// Delegation is one level deep: a child may never control another child.
-	if (!READ_ONLY_MANAGEMENT_ACTIONS.has(action)) {
-		const childRefusal = refuseSubagentChildDelegation(ctx, "management");
-		if (childRefusal) return childRefusal;
-	}
-	if (action === "doctor") {
-		let currentSessionFile: string | null = null;
-		let currentSessionId = deps.state.currentSessionId;
-		let sessionError: string | undefined;
-		try {
-			currentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
-			currentSessionId = ctx.sessionManager.getSessionId();
-		} catch (error) {
-			sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-		}
-		let orchestratorTarget: string | undefined;
-		try {
-			orchestratorTarget = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
-		} catch {}
-		return {
-			content: [
-				{
-					type: "text",
-					text: buildDoctorReport({
-						cwd: requestCwd,
-						config: deps.config,
-						state: deps.state,
-						context: paramsWithResolvedCwd.context,
-						requestedSessionDir: paramsWithResolvedCwd.sessionDir,
-						currentSessionFile,
-						currentSessionId,
-						orchestratorTarget,
-						sessionError,
-						expandTilde: deps.expandTilde,
-					}),
-				},
-			],
-			details: { mode: "management", results: [] },
-		};
-	}
-	if (action === "status") {
-		const targetRunId = paramsWithResolvedCwd.id ?? paramsWithResolvedCwd.runId;
-		const inProcess = inspectInProcessChildStatus(targetRunId);
-		if (inProcess) return inProcess;
-		const foreground = getForegroundControl(deps.state, targetRunId);
-		if (foreground) return foregroundStatusResult(foreground);
-		return {
-			content: [
-				{
-					type: "text",
-					text: targetRunId ? `No in-process child found for '${targetRunId}'.` : "No in-process subagent found.",
-				},
-			],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	if (action === "interrupt") {
-		const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
-		if (targetRunId) {
-			const inProcess = await interruptInProcessChild(targetRunId);
-			if (inProcess) return inProcess;
-		}
-		return {
-			content: [
-				{
-					type: "text",
-					text: targetRunId
-						? `No running in-process child found for '${targetRunId}'.`
-						: "No interrupt-capable child found.",
-				},
-			],
-			isError: true,
-			details: { mode: "management", results: [] },
-		};
-	}
-	return handleManagementAction(action, paramsWithResolvedCwd, { ...ctx, cwd: requestCwd });
-}
-
-function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" {
-	if ((params.tasks?.length ?? 0) > 0) return "parallel";
-	return "single";
-}
-
-function duplicateSubagentCallResult(params: SubagentParamsLike): SubagentToolResult {
-	return {
-		content: [
-			{
-				type: "text",
-				text: "Rejected: a subagent call is already in progress. Issue exactly ONE subagent call per turn.",
-			},
-		],
-		isError: true,
-		details: { mode: inferExecutionMode(params), results: [] },
-	};
-}
-
-export function createSubagentExecutor(rawDeps: ExecutorDeps): {
-	execute: (
-		id: string,
-		params: SubagentParamsLike,
-		signal: AbortSignal,
-		onUpdate: ((r: SubagentToolResult) => void) | undefined,
-		ctx: ExtensionContext,
-	) => Promise<SubagentToolResult>;
-} {
-	const deps: ResolvedExecutorDeps = { ...rawDeps, runtime: resolveSubagentExecutorRuntimeDeps(rawDeps.runtime) };
-	const execute = async (
-		_id: string,
-		params: SubagentParamsLike,
-		signal: AbortSignal,
-		onUpdate: ((r: SubagentToolResult) => void) | undefined,
-		ctx: ExtensionContext,
-	): Promise<SubagentToolResult> => {
-		deps.state.baseCwd = ctx.cwd;
-		deps.state.foregroundControls ??= new Map();
-		deps.state.lastForegroundControlId ??= null;
-		const requestCwd = resolveRequestedCwd(ctx.cwd, params.cwd);
-		const paramsWithResolvedCwd = params.cwd === undefined ? params : { ...params, cwd: requestCwd };
-		if (params.action) {
-			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps });
-		}
-		// Fanout authorization gates delegation and privileged control. Only `list`,
-		// `get`, `status`, and `doctor` stay available to an unauthorized child;
-		// `interrupt` and mutating management are refused by handleManagementRequest.
-		if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized) {
-			return {
-				content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
-				isError: true,
-				details: { mode: inferExecutionMode(params), results: [] },
-			};
-		}
-
-		const childRefusal = refuseSubagentChildDelegation(ctx, inferExecutionMode(params));
-		if (childRefusal) return childRefusal;
-
-		const built = prepareExecutionContext({ params: paramsWithResolvedCwd, ctx, signal, onUpdate, deps });
-		if (built.error) return built.error;
-		const prepared = built.prepared!;
-		try {
-			if (prepared.hasTasks && prepared.effectiveParams.tasks) {
-				const result = await runParallelPath(prepared.execData, deps);
-				return withForkContext(result, prepared.effectiveParams.context);
-			}
-			if (prepared.hasSingle) {
-				const result = await runSinglePath(prepared.execData, deps);
-				return withForkContext(result, prepared.effectiveParams.context);
-			}
-		} catch (error) {
-			return toExecutionErrorResult(prepared.effectiveParams, error);
-		} finally {
-			if (prepared.foregroundControl) {
-				clearPendingForegroundControlNotices(deps.state, prepared.runId);
-				deps.state.foregroundControls.delete(prepared.runId);
-				if (deps.state.lastForegroundControlId === prepared.runId) {
-					deps.state.lastForegroundControlId = null;
-				}
-			}
-		}
-
-		return withForkContext(
-			{
-				content: [{ type: "text", text: "Invalid params" }],
-				isError: true,
-				details: { mode: "single" as const, results: [] },
-			},
-			prepared.effectiveParams.context,
-		);
-	};
-
-	const executeWithBurstCollection = createExecutionBurstDispatcher({
-		execute,
-		isActive: () => deps.state.subagentInProgress === true,
-		setActive: (active) => {
-			deps.state.subagentInProgress = active;
-		},
-		duplicateResult: duplicateSubagentCallResult,
-	});
-
-	return {
-		execute: (id, params, signal, onUpdate, ctx) =>
-			params.action
-				? execute(id, params, signal, onUpdate, ctx)
-				: executeWithBurstCollection(id, params, signal, onUpdate, ctx),
-	};
-}

package/dist/builtin/subagents/src/runs/inprocess/child-policy.ts

@@ -1,27 +0,0 @@
-import type { SubagentChildPolicy } from "@bastani/atomic";
-
-export type ChildModePolicy = SubagentChildPolicy;
-
-/**
- * Resolve the child-mode capabilities at the in-process admission door.
- *
- * Every admitted child is management-restricted. Fanout is granted only when
- * the admitted tool allowlist explicitly includes the subagent tool; an
- * omitted allowlist cannot widen a descendant's capabilities.
- */
-export function resolveChildModePolicy(spec: {
-	readonly tools?: readonly string[];
-	readonly agent: {
-		readonly tools?: readonly string[];
-		readonly inheritProjectContext: boolean;
-		readonly inheritSkills: boolean;
-	};
-}): ChildModePolicy {
-	const tools = spec.tools ?? spec.agent.tools;
-	return {
-		managementActions: "restricted",
-		fanoutAuthorized: tools?.includes("subagent") === true,
-		inheritProjectContext: spec.agent.inheritProjectContext,
-		inheritSkills: spec.agent.inheritSkills,
-	};
-}

package/dist/builtin/subagents/src/runs/inprocess/control-registry.ts

@@ -1,55 +0,0 @@
-import type { ChildIdentity } from "@bastani/atomic-natives";
-import { createSubagentControl, type ParentContext, type SubagentControlRuntime } from "./runner.js";
-
-/**
- * Host-local registry for the Rust control planes owned by the current Atomic
- * session. The native registry remains authoritative for child identity and
- * status; this map only lets management actions find the corresponding
- * in-process runtime without a file-backed run directory.
- */
-const controls = new Map<string, SubagentControlRuntime>();
-
-export function registerSubagentControl(control: SubagentControlRuntime): void {
-	controls.set(control.parent.path, control);
-}
-
-export function getOrCreateSubagentControl(parent: ParentContext, sessionRoot: string): SubagentControlRuntime {
-	const existing = controls.get(parent.path);
-	// The control plane is parent-scoped. Parallel callers pass their per-child
-	// session directories here, but those storage paths must not split identity
-	// allocation across fresh native registries.
-	if (existing) return existing;
-	const control = createSubagentControl(parent, sessionRoot);
-	controls.set(parent.path, control);
-	return control;
-}
-
-export function unregisterSubagentControl(control: SubagentControlRuntime): void {
-	if (controls.get(control.parent.path) === control) controls.delete(control.parent.path);
-}
-
-export function findSubagentControl(id: string): SubagentControlRuntime | undefined {
-	const direct = controls.get(id);
-	if (direct) return direct;
-	for (const control of controls.values()) {
-		if (control.native.listChildren().some((child) => child.path === id)) return control;
-	}
-	return undefined;
-}
-
-export function listSubagentControls(): readonly SubagentControlRuntime[] {
-	return [...controls.values()];
-}
-
-export function findChildIdentity(
-	id: string,
-): { control: SubagentControlRuntime; identity: ChildIdentity } | undefined {
-	const control = findSubagentControl(id);
-	if (!control) return undefined;
-	const identity = control.native.listChildren().find((child) => child.path === id);
-	return identity ? { control, identity } : undefined;
-}
-
-export function clearSubagentControls(): void {
-	controls.clear();
-}

package/dist/builtin/subagents/src/runs/inprocess/control-status.ts

@@ -1,72 +0,0 @@
-import type { SubagentToolResult } from "../../shared/types.js";
-import { findSubagentControl, listSubagentControls } from "./control-registry.js";
-
-function canonicalChildren(control: NonNullable<ReturnType<typeof findSubagentControl>>) {
-	return [...control.listChildren()].sort((left, right) => left.path.localeCompare(right.path));
-}
-
-function childLines(control: ReturnType<typeof findSubagentControl>, id?: string): string[] {
-	if (!control) return [];
-	if (id) {
-		const child = control.findChild(id);
-		if (!child) return [];
-		const delivered = control.getDeliveredResult(id);
-		return [
-			`Child: ${child.path}`,
-			`Parent: ${child.parentPath}`,
-			`Task: ${child.taskName}`,
-			`Depth: ${child.depth}`,
-			`Status: ${child.status}`,
-			`Residency: ${child.loaded ? "loaded" : "cold"}`,
-			...(delivered?.sessionFile ? [`Session: ${delivered.sessionFile}`] : []),
-		];
-	}
-	return control
-		.listChildren()
-		.map((child) => `${child.path} — ${child.status} (${child.loaded ? "loaded" : "cold"})`);
-}
-
-export function inspectInProcessChildStatus(id?: string): SubagentToolResult | undefined {
-	if (id) {
-		const control = findSubagentControl(id);
-		if (!control) return undefined;
-		const text =
-			id === control.parent.path
-				? [`Parent: ${control.parent.path}`, ...childLines(control)].join("\n")
-				: childLines(control, id).join("\n");
-		if (!text) return undefined;
-		return {
-			content: [{ type: "text", text }],
-			details: { mode: "management", results: [] },
-		};
-	}
-	const lines = listSubagentControls().flatMap((control) => [
-		`Parent: ${control.parent.path}`,
-		...childLines(control),
-	]);
-	if (lines.length === 0) return undefined;
-	return {
-		content: [{ type: "text", text: lines.join("\n") }],
-		details: { mode: "management", results: [] },
-	};
-}
-
-export async function interruptInProcessChild(id: string): Promise<SubagentToolResult | undefined> {
-	const control = findSubagentControl(id);
-	if (!control) return undefined;
-	const identities = canonicalChildren(control);
-	const candidates = id === control.parent.path ? identities : identities.filter((child) => child.path === id);
-	for (const child of candidates) {
-		if (await control.interruptChild(child.path)) {
-			return {
-				content: [{ type: "text", text: `Interrupt requested for in-process child ${child.path}.` }],
-				details: { mode: "management", results: [] },
-			};
-		}
-	}
-	return {
-		content: [{ type: "text", text: `No running in-process child found for '${id}'.` }],
-		isError: true,
-		details: { mode: "management", results: [] },
-	};
-}

package/dist/builtin/subagents/src/runs/inprocess/index.ts

@@ -1,27 +0,0 @@
-export type {
-	AdmissionRefusal,
-	AdmittedResult,
-	AttemptOutcome,
-	AttemptSignals,
-	AttemptStats,
-	ChildPolicy,
-	ChildSpec,
-	ChildStatus,
-	ContinuationReason,
-	ModelCandidate,
-	ParentContext,
-	ResultEnvelope,
-	RunningAttempt,
-	TerminalStatus,
-	TerminationCauseName,
-} from "./runner.js";
-export {
-	AdmittedChild,
-	admit_child_session,
-	continue_detached,
-	createSubagentControl,
-	deliver_child_result,
-	run_child_attempt,
-	SubagentControlRuntime,
-	terminate_child_attempt,
-} from "./runner.js";

package/dist/builtin/subagents/src/runs/inprocess/prompt-behavior.ts

@@ -1,168 +0,0 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-
-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, call the actual edit/write 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, completion decisions, and follow-up implementation launches.",
-	"Delegation is one level deep: the `subagent` tool refuses every launch and interrupt from inside a subagent.",
-	"Do the assigned fanout work yourself and report what you found; do not plan around delegating it.",
-	"If you need to edit files, call the actual edit/write 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*subagent(?:@[^<\s]*)?\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:";
-
-export interface ChildPromptPolicy {
-	readonly inheritProjectContext: boolean;
-	readonly inheritSkills: boolean;
-	readonly fanoutAuthorized: boolean;
-}
-
-export interface PromptRewriteOptions {
-	readonly inheritProjectContext: boolean;
-	readonly inheritSkills: boolean;
-	readonly fanoutChild?: boolean;
-}
-
-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=["']subagent(?:@[^"']*)?["'][^>]*>[\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: PromptRewriteOptions): 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;
-	return `${boundary}\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<T>(message: T): T | 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 } as T;
-}
-
-/** Remove parent-only orchestration history while preserving it for an authorized fanout child. */
-export function stripParentOnlySubagentMessages<T>(messages: T[], preserveFanoutToolHistory = false): T[] {
-	let changed = false;
-	const filtered: T[] = [];
-	for (const message of messages) {
-		if (
-			isParentOnlySubagentMessage(message) ||
-			(!preserveFanoutToolHistory && isSubagentToolResultMessage(message))
-		) {
-			changed = true;
-			continue;
-		}
-		const stripped = preserveFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
-		if (stripped === undefined) {
-			changed = true;
-			continue;
-		}
-		if (stripped !== message) changed = true;
-		filtered.push(stripped);
-	}
-	return changed ? filtered : messages;
-}
-
-export interface InProcessChildPromptBehavior {
-	readonly systemPromptTransform: (prompt: string) => string;
-	readonly initialContextTransform: (messages: AgentMessage[]) => AgentMessage[];
-}
-
-export function createInProcessChildSystemPromptTransform(
-	policy: ChildPromptPolicy,
-	explicitSkillInjection = "",
-): (prompt: string) => string {
-	return (prompt) => {
-		const rewritten = rewriteSubagentPrompt(prompt, {
-			inheritProjectContext: policy.inheritProjectContext,
-			inheritSkills: policy.inheritSkills,
-			fanoutChild: policy.fanoutAuthorized,
-		});
-		return explicitSkillInjection ? `${rewritten}\n\n${explicitSkillInjection}` : rewritten;
-	};
-}
-
-/** Build the construction-time transforms for one admitted in-process child. */
-export function createInProcessChildPromptBehavior(policy: ChildPromptPolicy): InProcessChildPromptBehavior {
-	return {
-		systemPromptTransform: createInProcessChildSystemPromptTransform(policy),
-		initialContextTransform: (messages) => stripParentOnlySubagentMessages(messages, policy.fanoutAuthorized),
-	};
-}