@bastani/atomic 0.9.15 → 0.9.16-alpha.2

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

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import {
 	type AgentSession,
@@ -45,7 +45,6 @@ import {
 	type MaxOutputConfig,
 	truncateOutput,
 } from "../../shared/types.js";
-import { type InProcessAttemptResumeOutcome, registerInProcessAttempt } from "./attempt-handles.js";
 import { type ChildModePolicy, resolveChildModePolicy } from "./child-policy.js";
 import { createInProcessChildPromptBehavior, createInProcessChildSystemPromptTransform } from "./prompt-behavior.js";
 
@@ -673,9 +672,6 @@ export class SubagentControlRuntime {
 	readonly native: SubagentControl;
 	readonly parent: ParentContext;
 	readonly sessionRoot: string;
-	private readonly sessions = new Map<string, AgentSession>();
-	private readonly specs = new Map<string, ChildSpec>();
-	private readonly sessionFiles = new Map<string, string>();
 	private readonly runningAttempts = new Map<number, RunningAttempt>();
 	private readonly attemptTokens = new Map<string, number>();
 	private readonly attemptTerminators = new Map<string, (cause: TerminationCauseName) => Promise<void>>();
@@ -713,7 +709,6 @@ export class SubagentControlRuntime {
 			? dirname(spec.sessionFile)
 			: sessionDirectory(this.sessionRoot, identity.path);
 		mkdirSync(sessionDir, { recursive: true });
-		this.specs.set(identity.path, spec);
 		return {
 			admitted: AdmittedChild.create({
 				identity,
@@ -896,10 +891,9 @@ export class SubagentControlRuntime {
 						})
 					).session,
 				};
+				await created.session.extensionRunner.emit({ type: "session_start", reason: "startup" });
 			}
 			session = created.session;
-			if (session.sessionFile) this.sessionFiles.set(admitted.identity.path, session.sessionFile);
-			this.sessions.set(admitted.identity.path, session);
 			const initialModelId = modelIdForSession(session) ?? candidateModelId;
 			effectiveModelId = initialModelId;
 			effectiveThinking =
@@ -1070,7 +1064,6 @@ export class SubagentControlRuntime {
 			} catch {
 				// Session teardown must not replace the attempt result.
 			}
-			this.sessions.delete(admitted.identity.path);
 			if (this.attemptTokens.get(admitted.identity.path) === token)
 				this.attemptTokens.delete(admitted.identity.path);
 			if (this.attemptTerminators.get(admitted.identity.path) === terminate)
@@ -1142,56 +1135,6 @@ export class SubagentControlRuntime {
 		return running.child.identity.path;
 	}
 
-	reloadColdChild(pathValue: string, message: string): AdmittedResult {
-		let sessionDir: string;
-		try {
-			sessionDir = sessionDirectory(this.sessionRoot, pathValue);
-		} catch (error) {
-			return {
-				refusal: {
-					kind: "invalidCwd",
-					reason: error instanceof Error ? error.message : String(error),
-				},
-			};
-		}
-		const identity = this.native.listChildren().find((child) => child.path === pathValue);
-		if (!identity)
-			return {
-				refusal: { kind: "unknownAgent", reason: "unknown child identity" },
-			};
-		const sessionFile = this.sessionFiles.get(pathValue) ?? this.findSessionFile(sessionDir);
-		if (!sessionFile)
-			return {
-				refusal: {
-					kind: "invalidCwd",
-					reason: "child session file is missing",
-				},
-			};
-		sessionDir = dirname(sessionFile);
-		const native = this.native.reloadColdChild(pathValue, message);
-		if (!native.child) return refusal(native);
-		const previous = this.specs.get(pathValue);
-		if (!previous)
-			return {
-				refusal: {
-					kind: "unknownAgent",
-					reason: "child policy is not resident",
-				},
-			};
-		const spec: ChildSpec = { ...previous, task: message };
-		this.specs.set(pathValue, spec);
-		return {
-			admitted: AdmittedChild.create({
-				identity: native.child,
-				spec,
-				policy: { ...this.policyFor(spec, native.child.depth) },
-				sessionDir,
-				sessionFile,
-				control: this,
-			}),
-		};
-	}
-
 	getChildMetadata(pathValue: string): ChildRuntimeMetadata | undefined {
 		const running = [...this.runningAttempts.values()].find(
 			(attempt) =>
@@ -1209,34 +1152,6 @@ export class SubagentControlRuntime {
 		};
 	}
 
-	/** Expose a direct child's live attempt so `interrupt`/`resume` can reach it by run id or path. */
-	registerAttempt(runId: string, running: RunningAttempt, candidate: ModelCandidate): void {
-		registerInProcessAttempt({
-			runId,
-			path: running.child.identity.path,
-			status: () => running.status,
-			interrupt: () => this.terminateChildAttempt(running, "interrupt"),
-			resume: async (message): Promise<InProcessAttemptResumeOutcome> => {
-				const admission = this.reloadColdChild(running.child.identity.path, message);
-				if (!admission.admitted) {
-					throw new Error(admission.refusal?.reason ?? "child cold reload was refused");
-				}
-				const neverAbort = new AbortController().signal;
-				const resumed = this.startAttempt(admission.admitted, candidate, {
-					abort: neverAbort,
-					interrupt: neverAbort,
-				});
-				const outcome = await resumed.promise;
-				return {
-					status: outcome.status,
-					path: outcome.path,
-					sessionFile: outcome.sessionFile,
-					envelope: outcome.envelope,
-				};
-			},
-		});
-	}
-
 	async terminateChildAttempt(running: RunningAttempt, cause: TerminationCauseName): Promise<void> {
 		if (running.status !== "running" && running.status !== "continued") return;
 		await running.terminate?.(cause);
@@ -1285,50 +1200,11 @@ export class SubagentControlRuntime {
 		await this.terminateChildAttempt(running, "interrupt");
 		return true;
 	}
-	async resumeChild(
-		pathValue: string,
-		message: string,
-		candidate: ModelCandidate,
-		signals: AttemptSignals = {
-			abort: new AbortController().signal,
-			interrupt: new AbortController().signal,
-		},
-	): Promise<AttemptOutcome> {
-		const admission = this.reloadColdChild(pathValue, message);
-		if (!admission.admitted) {
-			const reason = admission.refusal?.reason ?? "cold child reload was refused";
-			return {
-				status: "error",
-				cause: reason,
-				stats: { ...EMPTY_STATS, sessionId: pathValue },
-				path: pathValue,
-				envelope: boundedEnvelope(reason),
-			};
-		}
-		const running = this.startAttempt(admission.admitted, candidate, signals);
-		return running.promise;
-	}
 
 	subscribe(pathValue: string, callback: (status: ChildStatus) => void): void {
 		this.native.subscribeChildStatus(pathValue, callback);
 	}
 
-	private policyFor(spec: ChildSpec, depth: number): ChildPolicy {
-		return {
-			...resolveChildModePolicy(spec),
-			cwd: spec.cwd,
-			tools: spec.tools ?? spec.agent.tools,
-			excludedTools: spec.excludedTools,
-			mcpDirectTools: spec.mcpDirectTools ?? spec.agent.mcpDirectTools,
-			skills: [...(spec.skills ?? spec.agent.skills ?? [])],
-			customTools: spec.customTools,
-			model: spec.model,
-			thinkingLevel: spec.thinkingLevel ?? (spec.agent.thinking as ChildPolicy["thinkingLevel"]),
-			intercomGroup: spec.parent?.intercomGroup,
-			depth,
-		};
-	}
-
 	private async terminateRunningAttempt(running: RunningAttempt, cause: TerminationCauseName): Promise<void> {
 		const terminate = this.attemptTerminators.get(running.child.identity.path);
 		if (terminate) {
@@ -1346,17 +1222,6 @@ export class SubagentControlRuntime {
 			// The runner's signal path owns the race with terminal completion.
 		}
 	}
-
-	private findSessionFile(sessionDir: string): string | undefined {
-		try {
-			const entry = readdirSync(sessionDir, { withFileTypes: true }).find(
-				(candidate) => candidate.isFile() && candidate.name.endsWith(".jsonl"),
-			);
-			return entry ? join(sessionDir, entry.name) : undefined;
-		} catch {
-			return undefined;
-		}
-	}
 }
 
 export function createSubagentControl(parent: ParentContext, sessionRoot?: string): SubagentControlRuntime {
@@ -1398,10 +1263,6 @@ export function continue_detached(
 	return control.continueDetached(running, reason);
 }
 
-export function reload_cold_child(control: SubagentControlRuntime, pathValue: string, message: string): AdmittedResult {
-	return control.reloadColdChild(pathValue, message);
-}
-
 export function terminate_child_attempt(
 	control: SubagentControlRuntime,
 	running: RunningAttempt,

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -59,4 +59,12 @@ export function aggregateParallelOutputs(
 		.join("\n\n");
 }
 
+export function formatParallelResultContent(
+	results: ParallelTaskResult[],
+	headerFormat: (index: number, agent: string) => string,
+): string {
+	const ok = results.filter((result) => result.status === "ok").length;
+	return `${ok}/${results.length} succeeded\n\n${aggregateParallelOutputs(results, headerFormat)}`;
+}
+
 export const MAX_PARALLEL_CONCURRENCY = 4;

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

@@ -1,6 +1,6 @@
 import type { ActivityState } from "./types.js";
 
-type StepStatus = "pending" | "running" | "complete" | "completed" | "failed" | "paused";
+type StepStatus = "pending" | "running" | "complete" | "completed" | "failed" | "interrupted";
 type StepStatusLike = { status: StepStatus };
 
 function formatActivityAge(ms: number): string {
@@ -41,10 +41,10 @@ export function formatParallelOutcome(
 	const running = steps.filter((step) => step.status === "running").length;
 	const done = steps.filter((step) => isCompletedStepStatus(step.status)).length;
 	const failed = steps.filter((step) => step.status === "failed").length;
-	const paused = steps.filter((step) => step.status === "paused").length;
+	const interrupted = steps.filter((step) => step.status === "interrupted").length;
 	const parts = [`${done}/${total} done`];
 	if (options.showRunning !== false && running > 0) parts.unshift(formatAgentRunningLabel(running));
 	if (failed > 0) parts.push(`${failed} failed`);
-	if (paused > 0) parts.push(`${paused} paused`);
+	if (interrupted > 0) parts.push(`${interrupted} interrupted`);
 	return parts.join(" · ");
 }

package/dist/builtin/subagents/src/shared/types-config.ts

@@ -41,6 +41,7 @@ export interface IntercomEventBus {
 }
 
 export const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+export const PARENT_ASK_HANDOFF_REQUEST_EVENT = "subagent:parent-ask-handoff-request";
 export const SUBAGENT_COMPLETE_EVENT = "subagent:complete";
 export const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
@@ -49,6 +50,44 @@ export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT = "subagent:terminal-ordering-barrier";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 
+export type ParentAskKind = "decision" | "interview" | "intercom";
+
+export interface ParentAskInterviewQuestion extends Record<string, unknown> {
+	id: string;
+	type: "single" | "multi" | "text" | "image" | "info";
+	question: string;
+	options?: unknown[];
+}
+
+export interface ParentAskInterviewRequest extends Record<string, unknown> {
+	title?: string;
+	description?: string;
+	questions: ParentAskInterviewQuestion[];
+}
+
+export interface ParentAskAttachment {
+	type: "file" | "snippet" | "context";
+	name: string;
+	content: string;
+	language?: string;
+}
+
+export interface ParentAskHandoffRequest {
+	runId: string;
+	index: number;
+	agent: string;
+	childIntercomTarget: string;
+	orchestratorTarget: string;
+	kind: ParentAskKind;
+	question: string;
+	attachments?: ParentAskAttachment[];
+	interview?: ParentAskInterviewRequest;
+	resolvedTargetId?: string;
+	/** Original delegated task supplied by the parent model for a fresh-child handoff. */
+	taskContext?: string;
+	claimed: boolean;
+}
+
 // ============================================================================
 // Execution Options
 // ============================================================================
@@ -64,6 +103,8 @@ export interface RunSyncOptions {
 	intercomDetachSignal?: AbortSignal;
 	/** Releases every active foreground sibling only after this exact child accepts a detach commit. */
 	onIntercomDetachCommit?: () => void;
+	/** Claims a blocking ask from this exact child and ends it with a fresh-child handoff. */
+	onParentAskHandoff?: (request: ParentAskHandoffRequest) => void;
 	onUpdate?: (r: AgentToolResult<Details>) => void;
 	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig?: ResolvedControlConfig;

package/dist/builtin/subagents/src/shared/types-foreground-state.ts

@@ -7,29 +7,21 @@
  */
 
 import type { ExtensionContext } from "@bastani/atomic";
-import type { ActivityState, SingleResult, SubagentResultStatus, SubagentRunMode } from "./types-results.js";
+import type { ParentAskHandoffRequest } from "./types-config.js";
 
-export interface ForegroundResumeChild {
-	agent: string;
-	index: number;
-	sessionFile?: string;
-	status: SubagentResultStatus;
-	result?: SingleResult;
+export interface ForegroundParentAskHandoff {
+	askingChildIndex: number;
+	releasedChildIndices: number[];
+	unlaunchedChildIndices: number[];
+	request: ParentAskHandoffRequest;
 }
 
-export interface ForegroundResumeRun {
-	runId: string;
-	mode: SubagentRunMode;
-	cwd: string;
-	updatedAt: number;
-	children: ForegroundResumeChild[];
-}
+import type { ActivityState, SubagentRunMode } from "./types-results.js";
 
 export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
 	subagentInProgress?: boolean;
-	foregroundRuns?: Map<string, ForegroundResumeRun>;
 	foregroundControls: Map<
 		string,
 		{

package/dist/builtin/subagents/src/shared/types-results.ts

@@ -91,7 +91,7 @@ export interface ControlEvent {
 	recentFailureSummary?: string;
 }
 
-export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached";
+export type SubagentResultStatus = "completed" | "failed" | "interrupted" | "detached";
 export type SubagentRunMode = "single" | "parallel";
 
 export interface SubagentResultIntercomChild {
@@ -220,6 +220,8 @@ export interface Details {
 	controlEvents?: ControlEvent[];
 	progress?: AgentProgress[];
 	totalSteps?: number;
+	/** Parent ask ended the current child and returned a fresh-subagent handoff. */
+	parentAskYielded?: boolean;
 	progressSummary?: ProgressSummary;
 	artifacts?: {
 		dir: string;

package/dist/builtin/subagents/src/shared/types-runtime.ts

@@ -81,17 +81,7 @@ export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
 export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
 export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
 export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
-export const SUBAGENT_ACTIONS = [
-	"list",
-	"get",
-	"create",
-	"update",
-	"delete",
-	"status",
-	"interrupt",
-	"resume",
-	"doctor",
-] as const;
+export const SUBAGENT_ACTIONS = ["list", "get", "create", "update", "delete", "status", "interrupt"] as const;
 
 export const DEFAULT_FORK_PREAMBLE =
 	"You are a delegated subagent running from a fork of the parent session. " +