@oai404iao/pi-subagent 0.4.0-alpha.0 → 0.4.0

package/src/descriptor.ts

@@ -3,29 +3,25 @@ import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type {
 	AgentScope,
 	AgentSnapshot,
-	AgentSnapshotSource,
-	BackgroundProtocol,
+	AgentSource,
 	ContextInheritance,
-	ReportDelivery,
+	RuntimeMode,
 	SubagentDescriptor,
 	SubagentMode,
 	SubagentProviderName,
+	SubagentRuntimeSnapshot,
 } from "./types.ts";
+import { DESCRIPTOR_VERSION } from "./types.ts";
 import { validateDescriptorTask } from "./task-path.ts";
 
 export const DESCRIPTOR_CUSTOM_TYPE = "pi-subagent/descriptor";
-export const DESCRIPTOR_VERSION = 3;
-export const LEGACY_DESCRIPTOR_VERSION = 2;
-const LEGACY_MAX_CONCURRENT_BACKGROUND_RUNS = 4;
-const LEGACY_MAX_IDLE_RUNTIMES = 0;
-const LEGACY_BACKGROUND_PROTOCOL: BackgroundProtocol = "legacy";
+export { DESCRIPTOR_VERSION };
 
 const THINKING_LEVELS = new Set<ThinkingLevel>(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const AGENT_SOURCES = new Set<AgentSnapshotSource>(["bundled", "user", "project"]);
+const AGENT_SOURCES = new Set<AgentSource>(["user", "project"]);
 const MODES = new Set<SubagentMode>(["one-shot", "continuable"]);
 const PROVIDERS = new Set<SubagentProviderName>(["spawn", "fork"]);
-const REPORT_DELIVERIES = new Set<ReportDelivery>(["wakeup", "quiet"]);
-const BACKGROUND_PROTOCOLS = new Set<BackgroundProtocol>(["legacy", "mailbox-v2"]);
+const RUNTIME_MODES = new Set<RuntimeMode>(["foreground", "background"]);
 const AGENT_SCOPES = new Set<AgentScope>(["user", "project", "both"]);
 const AGENT_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 /** UUIDv7 with the standard RFC 9562 variant bits (version 7, variant 10xx). */
@@ -110,7 +106,7 @@ function stringArray(value: unknown, field: string): string[] | undefined {
 
 function parseAgent(value: unknown): AgentSnapshot {
 	const input = record(value, "agent");
-	const source = string(input.source, "agent.source") as AgentSnapshotSource;
+	const source = string(input.source, "agent.source") as AgentSource;
 	if (!AGENT_SOURCES.has(source)) throw new Error(`agent.source is unsupported: ${source}`);
 	const thinking = optionalString(input.thinking, "agent.thinking") as ThinkingLevel | undefined;
 	if (thinking && !THINKING_LEVELS.has(thinking)) throw new Error(`agent.thinking is unsupported: ${thinking}`);
@@ -154,15 +150,25 @@ function parseContext(value: unknown): ContextInheritance {
 	return { mode };
 }
 
-export function parseDescriptor(value: unknown): SubagentDescriptor {
-	const input = record(value, "descriptor");
+function parseRuntimeMode(value: unknown): RuntimeMode {
 	if (
-		input.version !== LEGACY_DESCRIPTOR_VERSION
-		&& input.version !== DESCRIPTOR_VERSION
+		typeof value !== "string"
+		|| !RUNTIME_MODES.has(value as RuntimeMode)
 	) {
-		throw new Error(`unsupported descriptor version: ${String(input.version)}`);
+		throw new Error(
+			'runtime.runtimeMode must be "foreground" or "background"',
+		);
+	}
+	return value as RuntimeMode;
+}
+
+export function parseDescriptor(value: unknown): SubagentDescriptor {
+	const input = record(value, "descriptor");
+	if (input.version !== DESCRIPTOR_VERSION) {
+		throw new Error(
+			`unsupported descriptor version: ${String(input.version)}; this release persists version ${DESCRIPTOR_VERSION}`,
+		);
 	}
-	const version = input.version;
 	const mode = string(input.mode, "mode") as SubagentMode;
 	if (!MODES.has(mode)) throw new Error(`unsupported descriptor mode: ${mode}`);
 	const provider = string(input.provider, "provider") as SubagentProviderName;
@@ -174,22 +180,31 @@ export function parseDescriptor(value: unknown): SubagentDescriptor {
 	const runtime = record(input.runtime, "runtime");
 	const agentScope = string(runtime.agentScope, "runtime.agentScope") as AgentScope;
 	if (!AGENT_SCOPES.has(agentScope)) throw new Error(`unsupported runtime.agentScope: ${agentScope}`);
-	const reportDelivery = string(runtime.reportDelivery, "runtime.reportDelivery") as ReportDelivery;
-	if (!REPORT_DELIVERIES.has(reportDelivery)) {
-		throw new Error(`unsupported runtime.reportDelivery: ${reportDelivery}`);
-	}
-	const backgroundProtocol =
-		runtime.backgroundProtocol === undefined
-			? LEGACY_BACKGROUND_PROTOCOL
-			: string(runtime.backgroundProtocol, "runtime.backgroundProtocol") as BackgroundProtocol;
-	if (!BACKGROUND_PROTOCOLS.has(backgroundProtocol)) {
-		throw new Error(`unsupported runtime.backgroundProtocol: ${backgroundProtocol}`);
-	}
-	if (runtime.syncBundledAgents !== undefined) {
-		// Validate, then discard the retired 0.2/0.3 runtime switch. Keeping this
-		// read compatibility allows persisted children to cold-resume.
-		boolean(runtime.syncBundledAgents, "runtime.syncBundledAgents");
-	}
+	const parsedRuntime: SubagentRuntimeSnapshot = {
+		agentScope,
+		maxDepth: safeNatural(runtime.maxDepth, "runtime.maxDepth"),
+		runtimeMode: parseRuntimeMode(runtime.runtimeMode),
+		maxConcurrentBackgroundRuns: boundedInteger(
+			runtime.maxConcurrentBackgroundRuns,
+			"runtime.maxConcurrentBackgroundRuns",
+			1,
+			Number.MAX_SAFE_INTEGER,
+		),
+		maxIdleRuntimes: boundedInteger(
+			runtime.maxIdleRuntimes,
+			"runtime.maxIdleRuntimes",
+			0,
+			Number.MAX_SAFE_INTEGER,
+		),
+		inheritExtensions: boolean(runtime.inheritExtensions, "runtime.inheritExtensions"),
+		openAIIdentity: boolean(runtime.openAIIdentity, "runtime.openAIIdentity"),
+		maxOutputBytes: boundedInteger(
+			runtime.maxOutputBytes,
+			"runtime.maxOutputBytes",
+			1024,
+			1024 * 1024,
+		),
+	};
 
 	const createdAt = string(input.createdAt, "createdAt");
 	if (Number.isNaN(Date.parse(createdAt))) throw new Error("createdAt must be an ISO date string");
@@ -213,50 +228,8 @@ export function parseDescriptor(value: unknown): SubagentDescriptor {
 			id: string(model.id, "model.id"),
 		},
 		thinkingLevel,
-		runtime: {
-			agentScope,
-			maxDepth: safeNatural(runtime.maxDepth, "runtime.maxDepth"),
-			enableRunInBackground:
-				runtime.enableRunInBackground === undefined
-					? true
-					: boolean(runtime.enableRunInBackground, "runtime.enableRunInBackground"),
-			defaultBackground: boolean(runtime.defaultBackground, "runtime.defaultBackground"),
-			maxConcurrentBackgroundRuns:
-				runtime.maxConcurrentBackgroundRuns === undefined
-					? LEGACY_MAX_CONCURRENT_BACKGROUND_RUNS
-					: boundedInteger(
-							runtime.maxConcurrentBackgroundRuns,
-							"runtime.maxConcurrentBackgroundRuns",
-							1,
-							Number.MAX_SAFE_INTEGER,
-						),
-			maxIdleRuntimes:
-				runtime.maxIdleRuntimes === undefined
-					? LEGACY_MAX_IDLE_RUNTIMES
-					: boundedInteger(
-							runtime.maxIdleRuntimes,
-							"runtime.maxIdleRuntimes",
-							0,
-							Number.MAX_SAFE_INTEGER,
-						),
-			backgroundProtocol,
-			reportDelivery,
-			inheritExtensions: boolean(runtime.inheritExtensions, "runtime.inheritExtensions"),
-			openAIIdentity: boolean(runtime.openAIIdentity, "runtime.openAIIdentity"),
-			maxOutputBytes: boundedInteger(
-				runtime.maxOutputBytes,
-				"runtime.maxOutputBytes",
-				1024,
-				1024 * 1024,
-			),
-		},
+		runtime: parsedRuntime,
 	};
-	if (version === LEGACY_DESCRIPTOR_VERSION) {
-		return {
-			version: LEGACY_DESCRIPTOR_VERSION,
-			...base,
-		};
-	}
 	const task = record(input.task, "task");
 	return {
 		version: DESCRIPTOR_VERSION,
@@ -288,8 +261,5 @@ export function foldDescriptor(entries: readonly SessionEntry[]): DescriptorFold
 export function descriptorContext(
 	descriptor: SubagentDescriptor,
 ): ContextInheritance {
-	if (descriptor.version === 3) return structuredClone(descriptor.context);
-	return descriptor.provider === "fork"
-		? { mode: "all_completed" }
-		: { mode: "fresh" };
+	return structuredClone(descriptor.context);
 }

package/src/index.ts

@@ -4,7 +4,6 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_SETTINGS, loadSettings } from "./config.ts";
 import {
 	REPORT_CUSTOM_TYPE,
-	SETTLED_CUSTOM_TYPE,
 	SubagentCoordinator,
 	type DelegationInput,
 } from "./coordinator.ts";
@@ -60,61 +59,53 @@ function disableOwnedTools(
 }
 
 function assertBackgroundControlsEnabled(settings: SubagentSettings, toolName: string): void {
-	if (!settings.enableRunInBackground) {
+	if (settings.runtimeMode === "foreground") {
 		throw new Error(
-			`tool "${toolName}" is unavailable in foreground-only mode (enableRunInBackground: false)`,
+			`tool "${toolName}" is unavailable in foreground-only mode (runtimeMode: "foreground")`,
 		);
 	}
 }
 
+function modeDescription(settings: SubagentSettings): string {
+	return settings.runtimeMode === "foreground"
+		? "Delegate a complete task to a named child path with selectable completed-turn context. " +
+				"This foreground-only tool waits for the child and returns its final answer. " +
+				"Independent sibling calls may still execute in parallel."
+		: "Delegate a complete task to a named child path with selectable completed-turn context. " +
+				"Background mode is continuable and returns a readable path plus durable id; use send_message to enqueue, followup_task to start, and wait_agent for quiet completions. " +
+				"Start independent children together in one assistant message.";
+}
+
 function registerDelegationTool(
 	pi: ExtensionAPI,
 	coordinator: SubagentCoordinator,
 	settings: SubagentSettings,
 	agentDiscovery?: AgentDiscoveryResult,
 ): unknown {
-	const { enableRunInBackground, defaultBackground } = settings;
+	const foregroundOnly = settings.runtimeMode === "foreground";
 	const agentNames = agentDiscovery?.agents.map((agent) => agent.name);
-	const description = !enableRunInBackground
-		? "Delegate a complete task to a named child path with selectable completed-turn context. " +
-			"This foreground-only tool waits for the child and returns its final answer. " +
-			"Independent sibling calls may still execute in parallel."
-		: defaultBackground
-		? "Delegate a complete task to a named child path with selectable completed-turn context. " +
-			(settings.backgroundProtocol === "mailbox-v2"
-				? "Background mode is continuable and returns a readable path plus durable id; use send_message to enqueue, followup_task to start, and wait_agent for quiet completions. "
-				: "Background mode is continuable and returns a readable path plus durable id; use send_message for later FIFO turns. ") +
-			"Start independent children together in one assistant message."
-		: "Delegate a complete task to a named child path with selectable completed-turn context. " +
-			"This tool waits for the result by default; set run_in_background to true to return a readable path plus durable id.";
-	const promptGuidelines = (!enableRunInBackground
+	const promptGuidelines = (foregroundOnly
 		? [
 				"Use subagent for focused independent work and give it a complete standalone prompt.",
 				"This subagent tool is foreground-only: every call waits for and returns the child's final answer.",
 				"Independent subagent calls can still be issued together in one assistant message and execute in parallel.",
 			]
-		: defaultBackground
-			? [
-					"Use subagent for focused independent work and give it a complete standalone prompt.",
-					"Call subagent multiple times in one assistant message when delegations are independent.",
-					"Keep useful parent work moving after a background subagent starts; use foreground only when the next action needs its result.",
-				]
-			: [
-					"Use subagent for focused independent work and give it a complete standalone prompt.",
-					"Subagent calls wait for the result by default; request background mode only when work can continue independently.",
-					"Independent subagent calls can still be issued together in one assistant message and execute in parallel.",
-				]).concat([
+		: [
+				"Use subagent for focused independent work and give it a complete standalone prompt.",
+				"Call subagent multiple times in one assistant message when delegations are independent.",
+				"Every child is durable: continue parent work, then use send_message plus followup_task to give it more work and wait_agent for its completion updates.",
+			]).concat([
 					"Set task_name when a stable readable path will help later control calls; otherwise a name is generated from description.",
 					"Use fresh context by default and request all_completed or last_n_completed only when parent history materially helps.",
 				]);
-	const parameters = delegationParameters(enableRunInBackground, agentNames);
+	const parameters = delegationParameters(agentNames);
 	pi.registerTool({
 		name: "subagent",
 		label: "Subagent",
-		description,
-		promptSnippet: enableRunInBackground
-			? "Delegate focused work to named child agents"
-			: "Run focused independent work in foreground child agents",
+		description: modeDescription(settings),
+		promptSnippet: foregroundOnly
+			? "Run focused independent work in foreground child agents"
+			: "Delegate focused work to named child agents",
 		promptGuidelines,
 		executionMode: "parallel",
 		parameters,
@@ -136,7 +127,7 @@ function registerDelegationTool(
 			return coordinator.outcomeToolResult(outcome);
 		},
 		renderCall(args, theme) {
-			return renderDelegationCall(args, theme, "spawn");
+			return renderDelegationCall(args, theme, "spawn", settings.runtimeMode);
 		},
 		renderResult(result, options, theme) {
 			return renderDelegationResult(
@@ -157,16 +148,16 @@ function registerForkDelegationTool(
 	agentDiscovery?: AgentDiscoveryResult,
 ): unknown {
 	const agentNames = agentDiscovery?.agents.map((agent) => agent.name);
-	const parameters = forkDelegationParameters(
-		agentNames,
-		settings.enableRunInBackground,
-	);
+	const parameters = forkDelegationParameters(agentNames);
 	pi.registerTool({
 		name: "subagent_fork",
 		label: "Subagent Fork",
 		description:
 			"Delegate a task to a child seeded with all completed turns in this conversation. " +
-			"The current in-flight tool-calling turn is excluded. It is foreground by default; request background mode for a continuable fork.",
+			"The current in-flight tool-calling turn is excluded. " +
+			(settings.runtimeMode === "foreground"
+				? "This foreground-only tool waits for the child's final answer."
+				: "The fork is continuable and returns a readable path plus durable id."),
 		promptSnippet: "Delegate context-dependent work to a child seeded with completed turns",
 		promptGuidelines: [
 			"Use subagent_fork only when completed conversation history materially helps the delegated task.",
@@ -191,7 +182,7 @@ function registerForkDelegationTool(
 			return coordinator.outcomeToolResult(outcome);
 		},
 		renderCall(args, theme) {
-			return renderDelegationCall(args, theme, "fork");
+			return renderDelegationCall(args, theme, "fork", settings.runtimeMode);
 		},
 		renderResult(result, options, theme) {
 			return renderDelegationResult(
@@ -226,7 +217,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		name: "send_message",
 		label: "Send Message",
 		description:
-			"Send a message to a direct continuable child. Legacy children start or join a FIFO turn; mailbox-v2 children only durably enqueue it and require followup_task to execute. " +
+			"Send a message to a direct continuable child. It is durably appended to the child's FIFO mailbox and requires followup_task to start a turn. " +
 			"This call returns acceptance only, never the child's answer.",
 		promptSnippet: "Send or enqueue a message for a direct continuable subagent",
 		executionMode: "parallel",
@@ -244,10 +235,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				content: [
 					{
 						type: "text",
-						text:
-							delivery.kind === "mailbox-v2"
-								? `message ${delivery.messageId} durably enqueued for ${delivery.taskPath}; ${delivery.pendingMessages} pending`
-								: `message queued as the next turn for ${delivery.taskPath}`,
+						text: `message ${delivery.messageId} durably enqueued for ${delivery.taskPath}; ${delivery.pendingMessages} pending`,
 					},
 				],
 				details: {
@@ -255,12 +243,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 					action: "send",
 					agentId: delivery.agentId,
 					taskPath: delivery.taskPath,
-					...(delivery.kind === "mailbox-v2"
-						? {
-								messageId: delivery.messageId,
-								pendingMessages: delivery.pendingMessages,
-							}
-						: {}),
+					messageId: delivery.messageId,
+					pendingMessages: delivery.pendingMessages,
 				} satisfies ControlDetails,
 			};
 		},
@@ -270,9 +254,9 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		name: "followup_task",
 		label: "Follow-up Task",
 		description:
-			"For a direct mailbox-v2 continuable child, atomically claim its current pending FIFO mailbox and start exactly one scheduled turn. " +
+			"For a direct continuable child, atomically claim its current pending FIFO mailbox and start exactly one scheduled turn. " +
 			"This call returns turn acceptance, not the child's answer.",
-		promptSnippet: "Start one mailbox-v2 child turn from queued messages",
+		promptSnippet: "Start one child turn from queued mailbox messages",
 		executionMode: "parallel",
 		parameters: FollowupTaskParameters,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -306,8 +290,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		name: "wait_agent",
 		label: "Wait Agent",
 		description:
-			"Wait event-driven for unread completion updates from direct mailbox-v2 children. Existing updates return immediately; timeout does not consume later updates.",
-		promptSnippet: "Wait for quiet mailbox-v2 child completion updates",
+			"Wait event-driven for unread completion updates from direct children. Existing updates return immediately; timeout does not consume later updates.",
+		promptSnippet: "Wait for quiet child completion updates",
 		parameters: WaitAgentParameters,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			assertBackgroundControlsEnabled(sessionSettings, "wait_agent");
@@ -371,7 +355,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		label: "List Agents",
 		description:
 			"List direct continuable children or all descendants. running means an active turn, idle means resident between turns, " +
-			"ready means persisted and cold-resumable, and mailbox-v2 children show pending task messages separately from unread completion updates.",
+			"ready means persisted and cold-resumable, and children show pending task messages separately from unread completion updates.",
 		promptSnippet: "List continuable child agents and their lifecycle status",
 		parameters: ListAgentsParameters,
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -386,7 +370,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		},
 	});
 
-	for (const customType of [REPORT_CUSTOM_TYPE, SETTLED_CUSTOM_TYPE]) {
+	for (const customType of [REPORT_CUSTOM_TYPE]) {
 		pi.registerMessageRenderer<ParentMessageDetails>(customType, (message, options, theme) => {
 			const content =
 				typeof message.content === "string"
@@ -411,21 +395,19 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				);
 			const parent = await coordinator.parentFromContext(ctx);
 			const entries = await coordinator.list(parent, "descendants");
-			const schedulingMode = !sessionSettings.enableRunInBackground
-				? "foreground-only"
-				: sessionSettings.defaultBackground
-					? "background-first"
-					: "foreground-first";
 			const sections = [
-				`Mode: ${schedulingMode}`,
+				`Mode: ${sessionSettings.runtimeMode}`,
 				`Background concurrency: ${sessionSettings.maxConcurrentBackgroundRuns}`,
 				`Idle runtime LRU: ${sessionSettings.maxIdleRuntimes}`,
-				`Background protocol: ${sessionSettings.backgroundProtocol ?? "legacy"}`,
+				"Background protocol: durable mailbox",
 				`OpenAI identity inline: ${sessionSettings.openAIIdentity ? "enabled" : "disabled"}`,
 				agentSync?.diagnostics.length
 					? "Bundled templates: initialization skipped (see diagnostics)"
 					: `Bundled templates: initialization only (${agentSync?.packageVersion ?? "not initialized"})`,
 				`User agent dir: ${agentSync?.userAgentsDir ?? coordinator.getUserAgentsDir()}`,
+				agentSync && agentSync.retired.length > 0
+					? `Deleted presets (never restored): ${agentSync.retired.join(", ")}`
+					: null,
 				`Agents:\n${formatAgentCatalog(discovery.agents)}`,
 				`Children:\n${coordinator.formatCatalog(entries, "descendants")}`,
 			];
@@ -464,31 +446,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		if (sessionDiscovery.agents.length === 0) {
 			disableOwnedTools(pi, registeredParameters);
 		}
-		if (!sessionSettings.enableRunInBackground) {
+		if (sessionSettings.runtimeMode === "foreground") {
 			disableOwnedTools(pi, backgroundControlParameters);
-		} else if (sessionSettings.backgroundProtocol !== "mailbox-v2") {
-			let hasMailboxChild = true;
-			try {
-				const parent = await coordinator.parentFromContext(ctx);
-				const entries = await coordinator.list(parent, "descendants");
-				hasMailboxChild = entries.some(
-					(entry) =>
-						entry.kind === "child"
-						&& entry.descriptor.runtime.backgroundProtocol === "mailbox-v2",
-				);
-			} catch {
-				// Keep the control available when catalog inspection fails so a
-				// transient diagnostic cannot strand an existing mailbox child.
-			}
-			if (!hasMailboxChild) {
-				disableOwnedTools(
-					pi,
-					new Map<string, unknown>([
-						["followup_task", FollowupTaskParameters],
-						["wait_agent", WaitAgentParameters],
-					]),
-				);
-			}
 		}
 		if (!agentSyncNotified && agentSync) {
 			agentSyncNotified = true;
@@ -502,6 +461,14 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			if (agentSync.removed.length > 0) {
 				lines.push(`retired: ${agentSync.removed.join(", ")}`);
 			}
+			if (agentSync.retirementChanged && agentSync.retired.length > 0) {
+				lines.push(
+					`deleted by you (not restored): ${agentSync.retired.join(", ")}`,
+				);
+			}
+			if (agentSync.restored.length > 0) {
+				lines.push(`restored as managed presets: ${agentSync.restored.join(", ")}`);
+			}
 			if (agentSync.backups.length > 0) {
 				lines.push("backups:", ...agentSync.backups.map((backup) => `- ${backup.name}: ${backup.path}`));
 			}
@@ -509,6 +476,8 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				agentSync.installed.length > 0 ||
 				agentSync.updated.length > 0 ||
 				agentSync.removed.length > 0 ||
+				(agentSync.retirementChanged && agentSync.retired.length > 0) ||
+				agentSync.restored.length > 0 ||
 				agentSync.backups.length > 0
 			) {
 				ctx.ui.notify(lines.join("\n"), "info");

package/src/render.ts

@@ -9,7 +9,6 @@ export function renderDelegationCall(
 		task_name?: string;
 		description?: string;
 		prompt?: string;
-		run_in_background?: boolean;
 		context?: { mode?: string };
 	},
 	theme: {
@@ -17,17 +16,10 @@ export function renderDelegationCall(
 		bold(text: string): string;
 	},
 	provider: "spawn" | "fork",
+	runtimeMode: "foreground" | "background" = "background",
 ): Text {
-	const mode =
-		provider === "fork"
-			? args.run_in_background === true
-				? "fork · background"
-				: "fork · foreground"
-			: args.run_in_background === false
-				? `${args.context?.mode ?? "fresh"} · foreground`
-				: args.run_in_background === true
-					? `${args.context?.mode ?? "fresh"} · background`
-					: `${args.context?.mode ?? "fresh"} · configured default`;
+	const contextMode = provider === "fork" ? "all_completed" : (args.context?.mode ?? "fresh");
+	const mode = `${contextMode} · ${runtimeMode}`;
 	let text =
 		theme.fg("toolTitle", theme.bold(provider === "fork" ? "subagent_fork " : "subagent ")) +
 		theme.fg("accent", args.agent ?? "…") +
@@ -109,13 +101,11 @@ export function renderParentMessage(
 	},
 ): Text | Markdown {
 	if (expanded) return new Markdown(content, outputPad, 0, getMarkdownTheme());
-	const kind = details?.kind === "report" ? "report" : "settled";
-	const icon = details?.stopReason && details.stopReason !== "completed" ? "◐" : "●";
 	const label = details?.label ? ` — ${details.label}` : "";
 	return new Text(
-		theme.fg("accent", icon) +
+		theme.fg("accent", "●") +
 			" " +
-			theme.fg("toolTitle", theme.bold(`subagent ${kind}`)) +
+			theme.fg("toolTitle", theme.bold("subagent report")) +
 			theme.fg(
 				"muted",
 				` ${details?.taskPath ?? details?.childAgentId ?? "unknown"}${label}`,

package/src/schemas.ts

@@ -70,87 +70,25 @@ function forkDelegationFields(agentNames?: readonly string[]) {
 	};
 }
 
-function createDelegationParameters(
-	enableRunInBackground: boolean,
-	agentNames?: readonly string[],
-) {
+export function delegationParameters(agentNames?: readonly string[]) {
 	const fields = delegationFields(agentNames);
-	const contextualFields = {
-		...fields,
-		context: Type.Optional(ContextParameters),
-	};
 	return Type.Object(
-		enableRunInBackground
-			? {
-					...contextualFields,
-					run_in_background: Type.Optional(
-						Type.Boolean({
-							description:
-								"Run as a continuable background child. The spawn provider defaults this from configuration.",
-						}),
-					),
-				}
-			: contextualFields,
+		{
+			...fields,
+			context: Type.Optional(ContextParameters),
+		},
 		{ additionalProperties: false },
 	);
 }
 
-export const ForegroundDelegationParameters = createDelegationParameters(false);
-
-export const DelegationParameters = createDelegationParameters(true);
-
-export function delegationParameters(
-	enableRunInBackground: boolean,
-	agentNames?: readonly string[],
-) {
-	if (agentNames === undefined) {
-		return enableRunInBackground ? DelegationParameters : ForegroundDelegationParameters;
-	}
-	return createDelegationParameters(enableRunInBackground, agentNames);
-}
-
-function createForkDelegationParameters(
-	enableRunInBackground: boolean,
-	agentNames?: readonly string[],
-) {
+export function forkDelegationParameters(agentNames?: readonly string[]) {
 	const fields = forkDelegationFields(agentNames);
 	return Type.Object(
-		enableRunInBackground
-			? {
-					...fields,
-					run_in_background: Type.Optional(
-						Type.Boolean({
-							description:
-								"Run as a continuable inherited-context background child. Fork remains foreground by default.",
-						}),
-					),
-				}
-			: fields,
+		fields,
 		{ additionalProperties: false },
 	);
 }
 
-export const ForegroundForkDelegationParameters =
-	createForkDelegationParameters(false);
-
-export const ForkDelegationParameters =
-	createForkDelegationParameters(true);
-
-export function forkDelegationParameters(
-	agentNames?: readonly string[],
-	enableRunInBackground = true,
-) {
-	if (agentNames === undefined) {
-		return enableRunInBackground
-			? ForkDelegationParameters
-			: ForegroundForkDelegationParameters;
-	}
-	return createForkDelegationParameters(
-		enableRunInBackground,
-		agentNames,
-	);
-}
-
 export const SendMessageParameters = Type.Object(
 	{
 		subagent_id: Type.String({
@@ -171,7 +109,7 @@ export const FollowupTaskParameters = Type.Object(
 	{
 		subagent_id: Type.String({
 			description:
-				"Readable absolute/relative task path or durable id of a direct mailbox-v2 continuable child",
+				"Readable absolute/relative task path or durable id of a direct continuable child",
 			minLength: 1,
 			maxLength: 4096,
 		}),