@bastani/atomic 0.9.13-alpha.2 → 0.9.13-alpha.3

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

@@ -1,23 +1,32 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { handleManagementAction } from "../../agents/agent-management.ts";
 import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.ts";
 import { buildDoctorReport } from "../../extension/doctor.ts";
 import {
+	INTERCOM_BRIDGE_MARKER,
 	resolveIntercomBridge,
 	resolveIntercomSessionTarget,
 	resolveSubagentIntercomTarget,
 } from "../../intercom/intercom-bridge.ts";
 import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
 import { getArtifactsDir } from "../../shared/artifacts.ts";
-import { toModelInfo } from "../../shared/model-info.ts";
-import { resolveSingleProgress } from "../../shared/settings.ts";
+import { collectKnownModelProviders, toModelInfo } from "../../shared/model-info.ts";
+import { createCandidateModelResolver } from "../../shared/model-resolution.ts";
+import {
+	injectSingleProgressInstruction,
+	resolveSingleProgress,
+	writeInitialProgressFile,
+} from "../../shared/settings.ts";
 import {
 	DEFAULT_ARTIFACT_CONFIG,
 	getCurrentSubagentDepth,
 	isWorkflowStageOrchestrationContext,
 	resolveChildMaxSubagentDepth,
 	resolveWorkflowStageMaxSubagentDepth,
+	type SingleResult,
 	SUBAGENT_ACTIONS,
 	type SubagentToolResult,
 	workflowSessionMetadataFromContext,
@@ -30,16 +39,17 @@ import {
 import { inheritedIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId } from "../shared/model-fallback.ts";
 import { resolveControlConfig } from "../shared/subagent-control.ts";
-import { runAsyncPath } from "./subagent-executor-async.ts";
 import { checkDepthForExecution, prepareExecutionContext } from "./subagent-executor-context.ts";
 import { toExecutionErrorResult, withForkContext } from "./subagent-executor-input.ts";
 import { runParallelPath } from "./subagent-executor-parallel.ts";
 import { resolveRequestedCwd } from "./subagent-executor-resume.ts";
 import { resolveSubagentExecutorRuntimeDeps } from "./subagent-executor-runtime.ts";
-import { runSinglePath } from "./subagent-executor-single.ts";
+import { createForwardSingleUpdate, runSinglePath } from "./subagent-executor-single.ts";
 import {
 	foregroundStatusResult,
 	getForegroundControl,
+	notifyDetachedForegroundChildExit,
+	replaceForegroundRunChild,
 	retainedForegroundStatusResult,
 } from "./subagent-executor-status.ts";
 import {
@@ -54,6 +64,7 @@ async function resumeRetainedForegroundChild(
 	message: string,
 	ctx: ExtensionContext,
 	deps: ResolvedExecutorDeps,
+	onUpdate: ((r: SubagentToolResult) => void) | undefined,
 ): Promise<SubagentToolResult | undefined> {
 	const requested = params.id ?? params.runId;
 	if (!requested) return undefined;
@@ -82,47 +93,93 @@ async function resumeRetainedForegroundChild(
 		? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
 		: undefined;
 	const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, supervisedTarget);
-	return deps.runtime.executeAsyncSingle(run.runId, {
-		agent: child.agent,
-		agentConfig,
-		task: message,
-		ctx: {
-			pi: deps.pi,
+	const artifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: params.artifacts !== false };
+	const artifactsDir = getArtifactsDir(parentSessionFile);
+	const progressDir = resolveSingleProgress(agentConfig, params.progress, message)
+		? path.join(artifactsDir, "progress", run.runId)
+		: undefined;
+	if (progressDir) {
+		writeInitialProgressFile(progressDir);
+		message = injectSingleProgressInstruction(message, progressDir);
+	}
+	const cleanupProgress = (): void => {
+		if (!progressDir || artifactConfig.enabled) return;
+		try {
+			fs.rmSync(progressDir, { recursive: true, force: true });
+		} catch {
+			// Scratch cleanup must never replace the child run's result or original error.
+		}
+	};
+	const forwardSingleUpdate = createForwardSingleUpdate(
+		onUpdate,
+		getForegroundControl(deps.state, run.runId),
+		child.agent,
+		child.index,
+	);
+	let result: SingleResult;
+	try {
+		result = await deps.runtime.runSync(run.cwd, agents, child.agent, message, {
 			cwd: run.cwd,
-			currentSessionId: ctx.sessionManager.getSessionId(),
-			currentModelProvider: ctx.model?.provider,
-			currentModel: currentModelFullId(ctx.model),
-			intercomGroup: inheritedIntercomGroup(ctx),
+			signal: ctx.signal,
+			interruptSignal: ctx.signal,
+			allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: deps.pi.events,
+			runId: run.runId,
+			index: child.index,
+			sessionDir: child.sessionFile ? path.dirname(child.sessionFile) : undefined,
+			sessionFile: child.sessionFile,
+			share: params.share === true,
+			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+			artifactConfig,
+			maxOutput: params.maxOutput,
+			maxSubagentDepth:
+				child.maxSubagentDepth ??
+				resolveChildMaxSubagentDepth(
+					resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
+					agentConfig.maxSubagentDepth,
+				),
+			parentDepth: getCurrentSubagentDepth(ctx),
+			workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
 			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
-		},
-		cwd: run.cwd,
-		maxOutput: params.maxOutput,
-		artifactsDir: getArtifactsDir(parentSessionFile),
-		artifactConfig: { ...DEFAULT_ARTIFACT_CONFIG, enabled: params.artifacts !== false },
-		shareEnabled: params.share === true,
-		sessionRoot: deps.getSubagentSessionRoot(parentSessionFile),
-		sessionFile: child.sessionFile,
-		progress: resolveSingleProgress(agentConfig, params.progress, message),
-		modelOverride: params.model,
-		availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-		// The child's own effective limit, recorded when the run was retained. An
-		// older record without one falls back to narrowing the current limit by the
-		// agent definition, so a resume never widens a child's delegation budget.
-		maxSubagentDepth:
-			child.maxSubagentDepth ??
-			resolveChildMaxSubagentDepth(
-				resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
-				agentConfig.maxSubagentDepth,
-			),
-		parentDepth: getCurrentSubagentDepth(ctx),
-		workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
-		controlConfig: resolveControlConfig(deps.config.control, params.control),
-		controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
-		childIntercomTarget: intercomBridge.active
-			? (agent, index) => resolveSubagentIntercomTarget(run.runId, agent, index)
-			: undefined,
-		supervisorAuthorization,
-	});
+			controlConfig: resolveControlConfig(deps.config.control, params.control),
+			intercomSessionName: intercomBridge.active
+				? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
+				: undefined,
+			orchestratorIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
+			intercomGroup: inheritedIntercomGroup(ctx),
+			supervisorAuthorization,
+			modelOverride: params.model,
+			availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
+			knownModelProviders: collectKnownModelProviders(ctx.modelRegistry),
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, ctx.model?.provider),
+			preferredModelProvider: ctx.model?.provider,
+			currentModel: currentModelFullId(ctx.model),
+			onUpdate: forwardSingleUpdate,
+			onDetachedExit: (detachedResult) => {
+				cleanupProgress();
+				if (detachedResult) {
+					replaceForegroundRunChild(deps.state, run.runId, child.index, detachedResult);
+					notifyDetachedForegroundChildExit({
+						pi: deps.pi,
+						runId: run.runId,
+						mode: "single",
+						index: child.index,
+						result: detachedResult,
+					});
+				}
+			},
+		});
+	} catch (error) {
+		cleanupProgress();
+		throw error;
+	}
+	if (!result.detached) cleanupProgress();
+	replaceForegroundRunChild(deps.state, run.runId, child.index, result, { onlyWhenDetached: false });
+	return {
+		content: [{ type: "text", text: result.finalOutput ?? result.envelope ?? result.error ?? "" }],
+		details: { mode: "single", runId: run.runId, results: [result] },
+		...(result.status === "error" ? { isError: true } : {}),
+	};
 }
 const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
 /**
@@ -141,8 +198,9 @@ async function handleManagementRequest(input: {
 	requestCwd: string;
 	ctx: ExtensionContext;
 	deps: ResolvedExecutorDeps;
+	onUpdate?: (r: SubagentToolResult) => void;
 }): Promise<SubagentToolResult> {
-	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
+	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps, onUpdate } = input;
 	const action = params.action;
 	if (!action) {
 		return {
@@ -243,7 +301,7 @@ async function handleManagementRequest(input: {
 		}
 		const inProcess = await resumeInProcessChild(targetRunId, message, { model: ctx.model });
 		if (inProcess) return inProcess;
-		const retained = await resumeRetainedForegroundChild(paramsWithResolvedCwd, message, ctx, deps);
+		const retained = await resumeRetainedForegroundChild(paramsWithResolvedCwd, message, ctx, deps, onUpdate);
 		if (retained) return retained;
 		return {
 			content: [{ type: "text", text: `No in-process child found for '${targetRunId}'.` }],
@@ -315,7 +373,7 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		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 });
+			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps, onUpdate });
 		}
 		// Fanout authorization gates delegation and every management action that can
 		// start or continue agent execution. Only `list`, `get`, `status`, and
@@ -337,8 +395,6 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		const prepared = built.prepared!;
 		let nestedForegroundStarted = false;
 		try {
-			const asyncResult = await runAsyncPath(prepared.execData, deps);
-			if (asyncResult) return withForkContext(asyncResult, prepared.effectiveParams.context);
 			if (prepared.foregroundControl) {
 				prepared.writeNestedForegroundEvent("subagent.nested.started");
 				nestedForegroundStarted = true;

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

@@ -40,7 +40,7 @@ export type {
 export {
 	AdmittedChild,
 	admit_child_session,
-	continue_in_background,
+	continue_detached,
 	createSubagentControl,
 	deliver_child_result,
 	reload_cold_child,

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

@@ -45,7 +45,7 @@ import { type InProcessNestedResumeOutcome, registerInProcessNestedAttempt } fro
 import { createInProcessChildPromptBehavior } from "./prompt-behavior.ts";
 
 export type ChildStatus = NativeAgentStatus;
-export type ContinuationReason = "async-requested" | "intercom-coordination";
+export type ContinuationReason = "intercom-coordination";
 export type TerminationCauseName = NativeTerminationCause;
 export type TerminalStatus = "ok" | "error" | "skipped" | "interrupted" | "continued";
 
@@ -1105,8 +1105,8 @@ export class SubagentControlRuntime {
 		return running;
 	}
 
-	continueInBackground(running: RunningAttempt, _reason: ContinuationReason): string {
-		if (running.status !== "running") throw new Error("continue_in_background requires a running attempt");
+	continueDetached(running: RunningAttempt, _reason: ContinuationReason): string {
+		if (running.status !== "running") throw new Error("continue_detached requires a running attempt");
 		this.native.publishChildStatus(running.child.identity.path, nativeStatus("continued"));
 		running.status = "continued";
 		running.promise.catch(() => undefined);
@@ -1363,12 +1363,12 @@ export function run_child_attempt(
 	);
 }
 
-export function continue_in_background(
+export function continue_detached(
 	control: SubagentControlRuntime,
 	running: RunningAttempt,
 	reason: ContinuationReason,
 ): string {
-	return control.continueInBackground(running, reason);
+	return control.continueDetached(running, reason);
 }
 
 export function reload_cold_child(control: SubagentControlRuntime, pathValue: string, message: string): AdmittedResult {

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-api.ts

@@ -25,9 +25,7 @@ export {
 	MAX_NESTED_STEPS,
 	MAX_PROCESSED_NESTED_EVENTS,
 	NESTED_EVENTS_DIR,
-	NESTED_RUNS_DIR,
 	resolveInheritedNestedRouteFromEnv,
-	resolveNestedAsyncDir,
 	resolveNestedParentAddressFromEnv,
 	resolveNestedRouteFromEnv,
 	validateNestedRouteShape,
@@ -41,11 +39,6 @@ export {
 export {
 	attachRootChildrenToSteps,
 	hasLiveNestedDescendants,
-	isTopLevelAsyncDir,
-	nestedArtifactEnv,
-	nestedResultsPath,
-	nestedSummaryFromAsyncStatus,
-	updateAsyncJobNestedProjection,
 	updateForegroundNestedProjection,
 } from "./nested-projection.ts";
 export type { NestedRunMatch, NestedRunResolutionScope } from "./nested-registry.ts";

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-core.ts

@@ -7,7 +7,6 @@ import { registerInProcessNestedRoute } from "../nested-routing.ts";
 import { isSafeNestedPathId, type NestedPathEntry } from "./nested-paths.ts";
 
 export const NESTED_EVENTS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-events");
-export const NESTED_RUNS_DIR = path.join(TEMP_ROOT_DIR, "nested-subagent-runs");
 export const ROUTE_FILE = "route.json";
 export const REGISTRY_FILE = "registry.json";
 export const MAX_NESTED_EVENT_BYTES = 64 * 1024;
@@ -163,7 +162,6 @@ function cleanupOldSubdirectories(root: string, maxAgeDays: number): void {
 
 export function cleanupOldNestedRuntimeDirs(maxAgeDays: number): void {
 	cleanupOldSubdirectories(NESTED_EVENTS_DIR, maxAgeDays);
-	cleanupOldSubdirectories(NESTED_RUNS_DIR, maxAgeDays);
 }
 
 export function resolveNestedRouteFromEnv(_env: NodeJS.ProcessEnv = process.env): NestedRoute | undefined {
@@ -180,14 +178,6 @@ export function resolveNestedParentAddressFromEnv(
 	return undefined;
 }
 
-export function resolveNestedAsyncDir(rootRunId: string, run: NestedRunSummary): string | undefined {
-	if (!run.asyncDir) return undefined;
-	const resolved = path.resolve(run.asyncDir);
-	const nestedRoot = path.resolve(NESTED_RUNS_DIR, rootRunId, run.id);
-	const relative = path.relative(nestedRoot, resolved);
-	return resolved === nestedRoot || (!relative.startsWith("..") && !path.isAbsolute(relative)) ? resolved : undefined;
-}
-
 export function clampNumber(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-projection.ts

@@ -1,15 +1,5 @@
-import * as path from "node:path";
-import { APP_NAME } from "@bastani/atomic";
-import {
-	ASYNC_DIR,
-	type AsyncJobState,
-	type AsyncStatus,
-	type NestedRunSummary,
-	RESULTS_DIR,
-	type SubagentRunMode,
-	type SubagentState,
-} from "../../../shared/types.ts";
-import { assertSafeId, containedPath, MAX_NESTED_CHILDREN, MAX_NESTED_STEPS, NESTED_RUNS_DIR } from "./nested-core.ts";
+import type { NestedRunSummary, SubagentState } from "../../../shared/types.ts";
+import { MAX_NESTED_CHILDREN } from "./nested-core.ts";
 import { projectNestedEvents } from "./nested-registry.ts";
 import { terminal } from "./nested-sanitize.ts";
 
@@ -19,9 +9,7 @@ export function attachRootChildrenToSteps<T extends { children?: NestedRunSummar
 	children: NestedRunSummary[] | undefined,
 ): void {
 	if (!steps?.length) return;
-	for (const step of steps) {
-		step.children = undefined;
-	}
+	for (const step of steps) step.children = undefined;
 	if (!children?.length) return;
 	for (const child of children) {
 		if (child.parentRunId !== rootRunId || child.parentStepIndex === undefined) continue;
@@ -35,13 +23,6 @@ export function attachRootChildrenToSteps<T extends { children?: NestedRunSummar
 	}
 }
 
-export function updateAsyncJobNestedProjection(job: AsyncJobState): void {
-	if (!job.nestedRoute) return;
-	const registry = projectNestedEvents(job.nestedRoute);
-	job.nestedChildren = registry.children;
-	attachRootChildrenToSteps(job.asyncId, job.steps, registry.children);
-}
-
 export function updateForegroundNestedProjection(
 	control: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never,
 ): void {
@@ -59,89 +40,3 @@ export function hasLiveNestedDescendants(children: NestedRunSummary[] | undefine
 	}
 	return false;
 }
-
-export function nestedSummaryFromAsyncStatus(
-	status: AsyncStatus,
-	asyncDir: string,
-	fallback: {
-		id: string;
-		parentRunId: string;
-		parentStepIndex?: number;
-		depth: number;
-		path?: Array<{ runId: string; stepIndex?: number; agent?: string }>;
-		mode?: SubagentRunMode;
-		ts: number;
-	},
-): NestedRunSummary {
-	return {
-		id: status.runId || fallback.id,
-		parentRunId: fallback.parentRunId,
-		...(fallback.parentStepIndex !== undefined ? { parentStepIndex: fallback.parentStepIndex } : {}),
-		depth: fallback.depth,
-		path: fallback.path ?? [
-			{
-				runId: fallback.parentRunId,
-				...(fallback.parentStepIndex !== undefined ? { stepIndex: fallback.parentStepIndex } : {}),
-			},
-		],
-		asyncDir,
-		...(status.pid ? { pid: status.pid } : {}),
-		...(status.sessionId ? { sessionId: status.sessionId } : {}),
-		mode: status.mode ?? fallback.mode,
-		state: status.state,
-		...(status.activityState ? { activityState: status.activityState } : {}),
-		...(status.lastActivityAt !== undefined ? { lastActivityAt: status.lastActivityAt } : {}),
-		...(status.currentTool ? { currentTool: status.currentTool } : {}),
-		...(status.currentToolStartedAt !== undefined ? { currentToolStartedAt: status.currentToolStartedAt } : {}),
-		...(status.currentPath ? { currentPath: status.currentPath } : {}),
-		...(status.turnCount !== undefined ? { turnCount: status.turnCount } : {}),
-		...(status.toolCount !== undefined ? { toolCount: status.toolCount } : {}),
-		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
-		...(status.startedAt !== undefined ? { startedAt: status.startedAt } : { startedAt: fallback.ts }),
-		...(status.endedAt !== undefined ? { endedAt: status.endedAt } : {}),
-		lastUpdate: status.lastUpdate ?? fallback.ts,
-		...(status.sessionFile ? { sessionFile: status.sessionFile } : {}),
-		...(status.steps?.length
-			? {
-					steps: status.steps
-						.map((step) => ({
-							agent: step.agent,
-							status: step.status,
-							...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
-							...(step.activityState ? { activityState: step.activityState } : {}),
-							...(step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {}),
-							...(step.currentTool ? { currentTool: step.currentTool } : {}),
-							...(step.currentToolStartedAt !== undefined
-								? { currentToolStartedAt: step.currentToolStartedAt }
-								: {}),
-							...(step.currentPath ? { currentPath: step.currentPath } : {}),
-							...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-							...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-							...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
-							...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
-							...(step.error ? { error: step.error } : {}),
-						}))
-						.slice(0, MAX_NESTED_STEPS),
-				}
-			: {}),
-	};
-}
-
-export function nestedArtifactEnv(rootRunId: string, parentRunId: string): Record<string, string> {
-	const envPrefix = APP_NAME.toUpperCase();
-	return {
-		[`${envPrefix}_SUBAGENT_NESTED_ROOT_RUN_ID`]: rootRunId,
-		[`${envPrefix}_SUBAGENT_NESTED_PARENT_RUN_ID`]: parentRunId,
-	};
-}
-
-export function isTopLevelAsyncDir(asyncDir: string): boolean {
-	const resolved = path.resolve(asyncDir);
-	return containedPath(ASYNC_DIR, resolved) && !containedPath(NESTED_RUNS_DIR, resolved);
-}
-
-export function nestedResultsPath(rootRunId: string, id: string): string {
-	assertSafeId("rootRunId", rootRunId);
-	assertSafeId("id", id);
-	return path.join(RESULTS_DIR, "nested", rootRunId, `${id}.json`);
-}

package/dist/builtin/subagents/src/runs/inprocess/runtime-support/nested-sanitize.ts

@@ -91,10 +91,6 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		depth: Math.min(Math.max(0, clampNumber(raw.depth) ?? 0), MAX_NESTED_DEPTH),
 		path: pathParts,
 		state: sanitizeState(raw.state, "running"),
-		...(stringValue(raw.asyncDir, 2048) ? { asyncDir: stringValue(raw.asyncDir, 2048) } : {}),
-		...(clampNumber(raw.pid) !== undefined && clampNumber(raw.pid)! > 0 && Number.isInteger(clampNumber(raw.pid))
-			? { pid: clampNumber(raw.pid) }
-			: {}),
 		...(stringValue(raw.sessionId, 256) ? { sessionId: stringValue(raw.sessionId, 256) } : {}),
 		...(stringValue(raw.sessionFile, 2048) ? { sessionFile: stringValue(raw.sessionFile, 2048) } : {}),
 		...(stringValue(raw.intercomTarget, 256) ? { intercomTarget: stringValue(raw.intercomTarget, 256) } : {}),

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

@@ -8,7 +8,7 @@ import type {
 } from "../../shared/types.ts";
 
 const CONTROL_EVENT_TYPES: ControlEventType[] = ["active_long_running", "needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "async", "intercom"];
+const CONTROL_NOTIFICATION_CHANNELS: ControlNotificationChannel[] = ["event", "intercom"];
 const DEFAULT_NOTIFY_ON: ControlEventType[] = ["active_long_running", "needs_attention"];
 
 export const DEFAULT_CONTROL_CONFIG: ResolvedControlConfig = {

package/dist/builtin/subagents/src/shared/formatters.ts

@@ -14,13 +14,11 @@ export function formatTokens(n: number): string {
 
 export function formatModelThinking(model?: string, thinking?: string, fastMode?: boolean): string {
 	const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
-	let displayModel = parsed?.baseModel ?? model;
+	// Keep the full `provider/model` id so subagent lines read exactly like the
+	// main chat's model display; only a known thinking suffix is split off.
+	const displayModel = parsed?.baseModel ?? model;
 	const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
 	const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
-	if (displayModel) {
-		const slashIdx = displayModel.lastIndexOf("/");
-		if (slashIdx !== -1) displayModel = displayModel.slice(slashIdx + 1);
-	}
 	const parts = [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean);
 	if (fastMode && parts.length > 0) parts.push("fast");
 	return parts.join(" · ");

package/dist/builtin/subagents/src/shared/model-resolution.ts

@@ -0,0 +1,78 @@
+/**
+ * Resolution of a selected model candidate id to a concrete registry model.
+ *
+ * `buildModelCandidates` yields `provider/model[:thinking]` strings. Those
+ * strings alone never reach the child session: `createAgentSession` takes a
+ * `Model<Api>` object, and when no model is supplied it restores the model
+ * persisted in the session file. For a fork-context child that file is a copy
+ * of the parent's, so the parent's model silently won. Resolving the selected
+ * candidate to a real model here is what lets the configured model be handed
+ * to the child session instead.
+ *
+ * The lookup semantics deliberately mirror the SDK's own fallback-entry
+ * resolution (`resolveFallbackModel`), so the primary candidate and the
+ * fallback candidates handed to the same session agree on what a candidate
+ * string means.
+ */
+
+import type { Api, Model } from "@earendil-works/pi-ai/compat";
+import { splitKnownThinkingSuffix, THINKING_LEVELS, type ThinkingLevel } from "./model-info.ts";
+
+/** Registry surface needed to resolve a candidate; satisfied by `ctx.modelRegistry`. */
+export interface CandidateModelLookup {
+	getAvailable(): Model<Api>[];
+	find(provider: string, modelId: string): Model<Api> | undefined;
+	hasConfiguredAuth(model: Model<Api>): boolean;
+}
+
+/** A candidate string resolved to a concrete model and its requested thinking level. */
+export interface ResolvedCandidateModel {
+	model: Model<Api>;
+	thinkingLevel?: ThinkingLevel;
+}
+
+/**
+ * Resolve one `provider/model[:thinking]` candidate id against the registry.
+ * Returns `undefined` when the candidate names no usable model, which leaves
+ * the caller on its previous behavior rather than failing the run.
+ */
+export type CandidateModelResolver = (candidateId: string) => ResolvedCandidateModel | undefined;
+
+function thinkingLevelFromSuffix(suffix: string): ThinkingLevel | undefined {
+	if (!suffix) return undefined;
+	const level = suffix.slice(1);
+	return THINKING_LEVELS.find((known) => known === level);
+}
+
+export function resolveCandidateModel(
+	candidateId: string,
+	lookup: CandidateModelLookup,
+	preferredProvider?: string,
+): ResolvedCandidateModel | undefined {
+	const trimmed = candidateId.trim();
+	if (!trimmed) return undefined;
+	const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(trimmed);
+	const thinkingLevel = thinkingLevelFromSuffix(thinkingSuffix);
+	const slash = baseModel.indexOf("/");
+	if (slash < 0) {
+		const available = lookup.getAvailable().filter((entry) => entry.id === baseModel);
+		const model =
+			available.find((entry) => entry.provider === preferredProvider) ??
+			(available.length === 1 ? available[0] : undefined);
+		if (!model) return undefined;
+		return thinkingLevel === undefined ? { model } : { model, thinkingLevel };
+	}
+	const provider = baseModel.slice(0, slash);
+	const modelId = baseModel.slice(slash + 1);
+	const model = lookup.find(provider, modelId);
+	if (!model || !lookup.hasConfiguredAuth(model)) return undefined;
+	return thinkingLevel === undefined ? { model } : { model, thinkingLevel };
+}
+
+/** Bind a registry and the parent's provider into a reusable candidate resolver. */
+export function createCandidateModelResolver(
+	lookup: CandidateModelLookup,
+	preferredProvider?: string,
+): CandidateModelResolver {
+	return (candidateId: string) => resolveCandidateModel(candidateId, lookup, preferredProvider);
+}

package/dist/builtin/subagents/src/shared/status-format.ts

@@ -1,6 +1,7 @@
-import type { ActivityState, AsyncJobStep } from "./types.ts";
+import type { ActivityState } from "./types.ts";
 
-type StepStatusLike = Pick<AsyncJobStep, "status">;
+type StepStatus = "pending" | "running" | "complete" | "completed" | "failed" | "paused";
+type StepStatusLike = { status: StepStatus };
 
 function formatActivityAge(ms: number): string {
 	if (ms < 1000) return "now";
@@ -24,18 +25,10 @@ export function formatActivityLabel(
 	return age === "now" ? "active now" : `active ${age} ago`;
 }
 
-function isCompletedStepStatus(status: AsyncJobStep["status"]): boolean {
+function isCompletedStepStatus(status: StepStatus): boolean {
 	return status === "complete" || status === "completed";
 }
 
-export function aggregateStepStatus(steps: StepStatusLike[]): AsyncJobStep["status"] {
-	if (steps.some((step) => step.status === "running")) return "running";
-	if (steps.some((step) => step.status === "failed")) return "failed";
-	if (steps.some((step) => step.status === "paused")) return "paused";
-	if (steps.length > 0 && steps.every((step) => isCompletedStepStatus(step.status))) return "complete";
-	return "pending";
-}
-
 export function formatAgentRunningLabel(count: number): string {
 	return count === 1 ? "1 agent running" : `${count} agents running`;
 }