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

package/dist/builtin/workflows/src/runs/foreground/stage-runner-session.ts

@@ -1,66 +0,0 @@
-import type { AgentSession } from "@bastani/atomic";
-import type { StageSessionCreateResult, StageSessionRuntime } from "./stage-runner-types.js";
-
-type StageSessionExtensionRunner = {
-	hasHandlers(eventType: string): boolean;
-	emit(event: { readonly type: "session_shutdown"; readonly reason: "quit" }): Promise<unknown>;
-};
-
-function stageSessionExtensionRunner(current: StageSessionRuntime): StageSessionExtensionRunner | undefined {
-	const runner = (current as StageSessionRuntime & { extensionRunner?: StageSessionExtensionRunner }).extensionRunner;
-	if (runner && typeof runner.hasHandlers === "function" && typeof runner.emit === "function") {
-		return runner;
-	}
-	return undefined;
-}
-
-export async function disposeStageSession(current: StageSessionRuntime | undefined): Promise<void> {
-	if (!current) return;
-	const runner = stageSessionExtensionRunner(current);
-	if (runner?.hasHandlers("session_shutdown")) {
-		try {
-			await runner.emit({ type: "session_shutdown", reason: "quit" });
-		} catch (error) {
-			console.error("atomic-workflows: stage session_shutdown handler failed", error);
-		}
-	}
-	await current.dispose();
-}
-
-export function asAgentSession(activeSession: StageSessionRuntime | undefined): AgentSession | undefined {
-	if (!activeSession) return undefined;
-	const candidate = activeSession as StageSessionRuntime &
-		Partial<Pick<AgentSession, "state" | "sessionManager" | "modelRuntime" | "getContextUsage">>;
-	if (
-		candidate.state !== undefined &&
-		candidate.sessionManager !== undefined &&
-		candidate.modelRuntime !== undefined &&
-		typeof candidate.getContextUsage === "function"
-	) {
-		return candidate as AgentSession;
-	}
-	return undefined;
-}
-
-export function normalizeSessionCreateResult(
-	created: StageSessionRuntime | StageSessionCreateResult,
-): StageSessionCreateResult {
-	if ("session" in created) return created;
-	return { session: created };
-}
-
-export function attachCreatedStageSession<T>(
-	created: StageSessionRuntime | StageSessionCreateResult,
-	disposed: boolean,
-	stageName: string,
-	attach: (result: StageSessionCreateResult) => T,
-): T | Promise<never> {
-	const result = normalizeSessionCreateResult(created);
-	if (!disposed) return attach(result);
-	return rejectDisposedCreatedSession(result, stageName);
-}
-
-async function rejectDisposedCreatedSession(result: StageSessionCreateResult, stageName: string): Promise<never> {
-	await disposeStageSession(result.session);
-	throw new Error(`atomic-workflows: stage "${stageName}" session has been disposed`);
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-structured-output.ts

@@ -1,120 +0,0 @@
-import { createStructuredOutputTool, type StructuredOutputCapture } from "@bastani/atomic";
-import type { Static, TSchema } from "typebox";
-import type { StageOptions } from "../../shared/types.js";
-
-export const STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS = 3;
-export const STRUCTURED_OUTPUT_MISSING_ERROR =
-	"atomic-workflows: stage configured with schema must finish by calling structured_output.";
-
-const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-
-export interface StructuredOutputExecutionSnapshot<TValue> {
-	readonly toolCallId: string;
-	readonly value: TValue;
-}
-
-export interface StructuredOutputExecutionCapture<TValue> {
-	snapshot?: StructuredOutputExecutionSnapshot<TValue>;
-}
-
-type ToolResultContentBlock = {
-	readonly type?: unknown;
-	readonly text?: unknown;
-};
-
-function toolResultText(content: unknown): string | undefined {
-	if (!Array.isArray(content)) return undefined;
-	const text = content
-		.map((block: ToolResultContentBlock) =>
-			block.type === "text" && typeof block.text === "string" ? block.text : "",
-		)
-		.join("\n")
-		.trim();
-	return text.length > 0 ? text : undefined;
-}
-
-export function structuredOutputToolErrorFromEvent(event: unknown): string | undefined {
-	if (event === null || typeof event !== "object") return undefined;
-	const record = event as Record<string, unknown>;
-	if (record.type !== "tool_execution_end") return undefined;
-	if (record.toolName !== STRUCTURED_OUTPUT_TOOL_NAME) return undefined;
-	const result = record.result;
-	const resultRecord = result !== null && typeof result === "object" ? (result as Record<string, unknown>) : undefined;
-	const isError = record.isError === true || resultRecord?.isError === true;
-	if (!isError) return undefined;
-	return toolResultText(resultRecord?.content) ?? "structured_output tool call failed schema validation.";
-}
-
-export function formatStructuredOutputCorrectionPrompt(
-	error: string,
-	attempt: number,
-	needsArtifactText = false,
-): string {
-	return [
-		"The previous response failed this stage's structured-output contract.",
-		"",
-		`Corrective attempt ${attempt}/${STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS}.`,
-		"",
-		"Error:",
-		error,
-		"",
-		"You must finish by calling the `structured_output` tool exactly once with arguments matching the registered schema.",
-		"If you attempted `structured_output` and validation failed, correct the tool arguments and call `structured_output` again.",
-		needsArtifactText
-			? "In the same final assistant message, include the complete human-readable artifact as ordinary text before calling `structured_output`; the tool arguments are the separate machine-readable result. Do not put prose after the tool call, and do not write the artifact as plain JSON text or Markdown code."
-			: "Do not answer with plain JSON text, Markdown, or prose.",
-	].join("\n");
-}
-
-export function stringifyStructuredOutputValue(value: unknown): string {
-	try {
-		return JSON.stringify(value, null, 2);
-	} catch (error) {
-		throw new Error(
-			`atomic-workflows: structured_output returned a non-serializable value: ${error instanceof Error ? error.message : String(error)}`,
-		);
-	}
-}
-
-export function stageOptionsWithStructuredOutput<TSchemaDef extends TSchema>(
-	options: StageOptions<TSchemaDef | undefined> | undefined,
-	capture: StructuredOutputCapture<Static<TSchemaDef>> | undefined,
-	executionCapture?: StructuredOutputExecutionCapture<Static<TSchemaDef>>,
-): StageOptions | undefined {
-	if (!options?.schema || !capture) return options;
-	const structuredOutputTool = createStructuredOutputTool({
-		schema: options.schema,
-		capture,
-	});
-	const executeStructuredOutput = structuredOutputTool.execute;
-	const capturedStructuredOutputTool = {
-		...structuredOutputTool,
-		async execute(...args: Parameters<typeof executeStructuredOutput>) {
-			const result = await executeStructuredOutput(...args);
-			// Mirror the shared capture, which keeps the latest successful call:
-			// a model-fallback session recreation can execute the tool a second
-			// time, and the snapshot must describe the call the live session (and
-			// its messages) actually holds, not an abandoned earlier one.
-			if (executionCapture !== undefined && capture.called) {
-				executionCapture.snapshot = {
-					toolCallId: args[0],
-					value: args[1],
-				};
-			}
-			return result;
-		},
-	};
-	const tools =
-		options.tools === undefined
-			? options.noTools === "all"
-				? [STRUCTURED_OUTPUT_TOOL_NAME]
-				: undefined
-			: Array.from(new Set([...options.tools, STRUCTURED_OUTPUT_TOOL_NAME]));
-	const excludedTools = options.excludedTools?.filter((toolName) => toolName !== STRUCTURED_OUTPUT_TOOL_NAME);
-	return {
-		...options,
-		...(tools !== undefined ? { tools } : {}),
-		...(excludedTools !== undefined ? { excludedTools } : {}),
-		customTools: [...(options.customTools ?? []), capturedStructuredOutputTool],
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-types.ts

@@ -1,211 +0,0 @@
-import type { AgentSession, CreateAgentSessionOptions, PromptOptions, SettingsManager } from "@bastani/atomic";
-import type {
-	CompleteStageOpts,
-	StageContext,
-	StageExecutionMeta,
-	StageOptions,
-	StageSendUserMessageOptions,
-	StageUserMessageContent,
-	WorkflowExecutionMode,
-	WorkflowModelAttempt,
-	WorkflowModelCatalogPort,
-} from "../../shared/types.js";
-
-type AgentStageSessionEvent = Parameters<AgentSession["subscribe"]>[0] extends (event: infer T) => void ? T : never;
-export type StageSessionEvent = AgentStageSessionEvent & { readonly turnId?: string | number };
-
-export type WorkflowFastModeSettings = {
-	readonly chat: boolean;
-	readonly workflow: boolean;
-};
-export type WorkflowRetrySettings = ReturnType<SettingsManager["getRetrySettings"]>;
-
-export type WorkflowFastModeSettingsManager = {
-	getCodexFastModeSettings(): WorkflowFastModeSettings;
-	getRetrySettings?(): WorkflowRetrySettings;
-};
-
-export type StageUserMessageDeliveryAction = "prompt" | "steer" | "followUp" | "handled";
-
-/** Internal session preparation and side-effect-free eligibility boundary. */
-export interface StageUserMessagePreparation {
-	readonly sessionFile?: string;
-	readonly beforePreparation?: () => void;
-}
-
-export interface StageUserMessageDeliveryHooks {
-	readonly beforeDelivery?: () => void;
-	/** Releases serialized admission once an idle prompt synchronously owns the turn. */
-	readonly promptStarted?: () => void;
-	readonly delivered?: (action: StageUserMessageDeliveryAction) => void;
-}
-
-export interface StageSessionRuntime {
-	prompt(text: string, options?: PromptOptions): Promise<string | undefined>;
-	sendUserMessage?(
-		content: StageUserMessageContent,
-		options?: StageSendUserMessageOptions & { readonly __workflowDelivery?: StageUserMessageDeliveryHooks },
-	): Promise<void>;
-	sealWorkflowStageGeneration?(): void;
-	closeWorkflowStageGeneration?(): Promise<void>;
-	transferWorkflowStageDeliveriesTo?(target: object): void;
-	/** True when this runtime implements a native queued-message pause gate. */
-	readonly queuedMessagesPaused?: boolean;
-	/** Optional native optimization that synchronously holds queued work. */
-	pauseQueuedMessages?(): void;
-	/** Optional native release; calls `beforeRelease` at the final synchronous boundary. */
-	resumeQueuedMessages?(beforeRelease?: () => void): boolean | Promise<boolean>;
-	steer(text: string): Promise<void>;
-	followUp(text: string): Promise<void>;
-	subscribe(listener: (event: StageSessionEvent) => void): () => void;
-	readonly sessionFile: string | undefined;
-	readonly sessionId: string;
-	setModel(model: Parameters<AgentSession["setModel"]>[0]): Promise<void>;
-	setThinkingLevel(level: Parameters<AgentSession["setThinkingLevel"]>[0]): void;
-	cycleModel(): ReturnType<AgentSession["cycleModel"]>;
-	cycleThinkingLevel(): ReturnType<AgentSession["cycleThinkingLevel"]>;
-	readonly agent: AgentSession["agent"];
-	readonly model: AgentSession["model"];
-	readonly thinkingLevel: AgentSession["thinkingLevel"];
-	readonly messages: AgentSession["messages"];
-	readonly isStreaming: AgentSession["isStreaming"];
-	/** Number of SDK-level queued steering/follow-up messages, when supported. */
-	readonly pendingMessageCount?: number;
-	/**
-	 * Pending queued text this session already holds, when the runtime exposes
-	 * it. Read once at attach, because a session created with a queue — one
-	 * adopting a retired stage session's transferred messages, or a retained
-	 * session reopened for post-mortem chat — announced that queue before any
-	 * listener of this stage could be bound to it.
-	 */
-	getSteeringMessages?(): readonly string[];
-	getFollowUpMessages?(): readonly string[];
-	/** Settings manager supplied by the Atomic SDK when the adapter did not pre-create one. */
-	readonly settingsManager?: WorkflowFastModeSettingsManager;
-	navigateTree: AgentSession["navigateTree"];
-	compact: AgentSession["compact"];
-	abortCompaction(): void;
-	abort(): Promise<void>;
-	dispose(): void | Promise<void>;
-	getLastAssistantText?: () => string | undefined;
-}
-
-export type StageSessionCreateOptions = CreateAgentSessionOptions &
-	Pick<StageOptions, "mcp" | "fallbackModels" | "fallbackThinkingLevels">;
-
-export interface StageSessionCreateResult {
-	readonly session: StageSessionRuntime;
-	readonly settingsManager?: WorkflowFastModeSettingsManager;
-}
-
-export interface AgentSessionAdapter {
-	create(
-		options: StageSessionCreateOptions,
-		meta?: StageExecutionMeta,
-	): Promise<StageSessionRuntime | StageSessionCreateResult>;
-}
-
-export interface StageModelFallbackMeta {
-	readonly model?: string;
-	readonly fastMode?: boolean;
-	readonly attemptedModels?: readonly string[];
-	readonly modelAttempts?: readonly WorkflowModelAttempt[];
-	readonly warnings?: readonly string[];
-}
-
-export interface PromptAdapter {
-	prompt(text: string, meta?: StageExecutionMeta): Promise<string>;
-}
-
-export interface CompleteAdapter {
-	complete(text: string, opts?: CompleteStageOpts, meta?: StageExecutionMeta): Promise<string>;
-}
-
-export interface StageAdapters {
-	agentSession?: AgentSessionAdapter;
-	prompt?: PromptAdapter;
-	complete?: CompleteAdapter;
-}
-
-export interface StageRunnerOpts {
-	stageId: string;
-	stageName: string;
-	adapters: StageAdapters;
-	/** Options passed to ctx.stage(name, options?). Forwarded to createAgentSession except mcp. */
-	stageOptions?: StageOptions;
-	/** Run ID of the containing workflow execution — forwarded to session adapter metadata. */
-	runId: string;
-	/** Runtime-owned home group shared by this top-level workflow invocation. */
-	workflowIntercomGroup?: string;
-	/** AbortSignal from the executor's own AbortController — forwarded to session adapter metadata. */
-	signal?: AbortSignal;
-	/** Optional model catalog used for fallback validation/resolution. */
-	models?: WorkflowModelCatalogPort;
-	/** Runtime execution mode forwarded to stage session adapters. */
-	executionMode?: WorkflowExecutionMode;
-	/** Host-resolved non-default session directory inherited by stages without explicit sessionDir. */
-	defaultSessionDir?: string;
-	/** Internal: notifies the executor when an in-flight fallback changes model/fast metadata. */
-	onModelFallbackMetaChange?: (meta: StageModelFallbackMeta) => void;
-	/** Internal: persist stage-session identity once the SDK has created its path. */
-	onSessionReady?: () => void | Promise<void>;
-}
-
-export interface InternalStageContext extends StageContext {
-	/** Internal cleanup hook; intentionally omitted from the public StageContext type. */
-	__dispose(): Promise<void>;
-	/** Internal result snapshot hook for the workflow store/TUI. */
-	__getLastAssistantText(): string | undefined;
-	getLastAssistantText(): string | undefined;
-	/**
-	 * Internal: eagerly create the underlying SDK AgentSession without sending a
-	 * prompt. Used by the live stage-control registry when a user attaches to a
-	 * stage and types their first message before the workflow body's natural
-	 * first `prompt()` lands.
-	 */
-	__ensureSession(): Promise<void>;
-	/** Internal: reopen an archived stage transcript before post-terminal follow-up. */
-	__ensureSessionFromFile(sessionFile: string): Promise<void>;
-	/** Internal idle-aware delivery primitive; returns the action actually taken. */
-	__sendUserMessage(
-		content: StageUserMessageContent,
-		options?: StageSendUserMessageOptions,
-		beforeDelivery?: () => void,
-		preparation?: StageUserMessagePreparation,
-	): Promise<StageUserMessageDeliveryAction>;
-	/**
-	 * Internal: subscribe to workflow-owned delivery lifecycle facts for this
-	 * stage. An accepted idle delivery reports `delivery_start` before the public
-	 * `agent_start` reaches subscribers, so an attached chat can paint Working
-	 * for the whole turn rather than only after the SDK event queue drains.
-	 */
-	__subscribeDeliveryActivity(
-		listener: (event: import("./stage-delivery-activity.js").StageDeliveryActivityEvent) => void,
-	): () => void;
-	/** Internal: synchronously reject new detached traffic without waiting for active work. */
-	__sealGeneration(): void;
-	/** Internal: atomically stop detached traffic admission and drain admitted work. */
-	__closeGeneration(): Promise<void>;
-	/** Internal: snapshot of currently-known SDK session metadata. */
-	__sessionMeta(): { sessionId: string | undefined; sessionFile: string | undefined };
-	/** Internal: live coding-agent session when the adapter returned one. */
-	__agentSession(): AgentSession | undefined;
-	/** Internal: SDK queued steering/follow-up message count, when available. */
-	__pendingMessageCount(): number;
-	/** Internal: selected/effective model and fallback attempt metadata. */
-	__modelFallbackMeta(): StageModelFallbackMeta;
-	/** Internal: register a controlled-pause request. */
-	__requestPause(): Promise<void>;
-	/** Internal: complete a pending controlled pause and report its released raw work. */
-	__resume(
-		message?: string,
-		beforeResolve?: (result: import("./stage-runner-pause.js").StageSessionPauseResumeResult) => void,
-		beforeRelease?: () => void,
-	): Promise<import("./stage-runner-pause.js").StageSessionPauseResumeResult>;
-	/** Internal: true while a controlled pause is in flight. */
-	__isPaused(): boolean;
-	/** Internal: true once a schema-backed prompt captured its final structured output. */
-	__structuredOutputFinalized(): boolean;
-}
-
-export type AgentSessionConsumer = "prompt" | "complete";

package/dist/builtin/workflows/src/runs/foreground/stage-runner-unresolved-overflow.ts

@@ -1,42 +0,0 @@
-import { WorkflowPromptModelFailure } from "./stage-runner-messages.js";
-
-export function unresolvedContextOverflowMessage(event: unknown): string | undefined {
-	if (event === null || typeof event !== "object") return undefined;
-	const record = event as Record<string, unknown>;
-	if (record.type !== "compaction_end" || record.unresolvedOverflow !== true) return undefined;
-	const message = record.errorMessage;
-	return typeof message === "string" && message.trim().length > 0
-		? message
-		: "Context overflow recovery was exhausted for the current model.";
-}
-
-export function unresolvedContextOverflowFailure(message: string): WorkflowPromptModelFailure {
-	return new WorkflowPromptModelFailure({ message, code: "context_length_exceeded", stopReason: "error" });
-}
-
-export function isUnresolvedContextOverflowFailure(error: unknown): boolean {
-	if (!(error instanceof WorkflowPromptModelFailure)) return false;
-	const cause = error.cause;
-	if (cause === null || typeof cause !== "object") return false;
-	return (cause as { readonly code?: unknown }).code === "context_length_exceeded";
-}
-
-export function nextResumedContextOverflowFallbackIndex(
-	error: unknown,
-	currentIndex: number | undefined,
-	candidateCount: number,
-): number | "terminal" | undefined {
-	if (!isUnresolvedContextOverflowFailure(error) || currentIndex === undefined) return undefined;
-	const nextIndex = currentIndex + 1;
-	return nextIndex >= candidateCount ? "terminal" : nextIndex;
-}
-
-export function terminatingToolCallId(event: unknown): string | undefined {
-	if (event === null || typeof event !== "object") return undefined;
-	const record = event as Record<string, unknown>;
-	const result = record.result;
-	if (record.type !== "tool_execution_end" || result === null || typeof result !== "object") return undefined;
-	if ((result as Record<string, unknown>).terminate !== true) return undefined;
-	const callId = record.toolCallId;
-	return typeof callId === "string" && callId.length > 0 ? callId : undefined;
-}

package/dist/builtin/workflows/src/runs/foreground/stage-runner.ts

@@ -1,22 +0,0 @@
-/**
- * Stage runner — creates an AgentSession-like StageContext for a workflow stage.
- *
- * The public stage surface mirrors the supported subset of pi's SDK
- * AgentSession. The executor wraps prompt() for lifecycle tracking and owns
- * disposal; workflow authors get direct SDK session methods without a custom
- * prompt abstraction.
- */
-
-export { createStageContext } from "./stage-runner-context.js";
-export type {
-	AgentSessionAdapter,
-	CompleteAdapter,
-	InternalStageContext,
-	PromptAdapter,
-	StageAdapters,
-	StageModelFallbackMeta,
-	StageRunnerOpts,
-	StageSessionCreateOptions,
-	StageSessionCreateResult,
-	StageSessionRuntime,
-} from "./stage-runner-types.js";

package/dist/builtin/workflows/src/runs/foreground/stage-session-heartbeat.ts

@@ -1,88 +0,0 @@
-export const STAGE_SESSION_HEARTBEAT_INTERVAL_MS = 30_000;
-
-export interface StageSessionHeartbeat {
-	start(): void;
-	stop(): void;
-	/**
-	 * Stop scheduling and await the checkpoint that is still in flight, so a late
-	 * durable failure surfaces at shutdown instead of being discarded with the
-	 * cancelled timer. Rejects with a failure recorded earlier via `fail()` too.
-	 */
-	drain(): Promise<void>;
-	fail(error: unknown): void;
-	race<T>(work: Promise<T>): Promise<T>;
-}
-
-/** Run one non-overlapping, unref'd durability checkpoint every 30 seconds. */
-export function createStageSessionHeartbeat(
-	checkpoint: () => Promise<void>,
-	intervalMs: number = STAGE_SESSION_HEARTBEAT_INTERVAL_MS,
-): StageSessionHeartbeat {
-	let active = false;
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	let generation = 0;
-	let nextDeadline = 0;
-	let failure: unknown;
-	let inFlight: Promise<void> | undefined;
-	let rejectFailure!: (reason: unknown) => void;
-	const failureSignal = new Promise<never>((_resolve, reject) => {
-		rejectFailure = reject;
-	});
-	// A race attaches the normal consumer; this guard prevents a late checkpoint
-	// rejection from becoming an unhandled process error during teardown.
-	void failureSignal.catch(() => undefined);
-	const stopScheduling = (): void => {
-		active = false;
-		generation += 1;
-		if (timer !== undefined) clearTimeout(timer);
-		timer = undefined;
-	};
-	const fail = (error: unknown): void => {
-		if (failure !== undefined) return;
-		failure = error;
-		stopScheduling();
-		rejectFailure(error);
-	};
-
-	const schedule = (scheduledGeneration: number): void => {
-		if (!active || failure !== undefined || scheduledGeneration !== generation) return;
-		const delayMs = Math.max(0, nextDeadline - Date.now());
-		timer = setTimeout(() => {
-			timer = undefined;
-			const startedAt = Date.now();
-			do nextDeadline += intervalMs;
-			while (nextDeadline <= startedAt);
-			const running = checkpoint()
-				.catch(fail)
-				.finally(() => {
-					if (inFlight === running) inFlight = undefined;
-					schedule(scheduledGeneration);
-				});
-			inFlight = running;
-		}, delayMs);
-		(timer as { unref?: () => void }).unref?.();
-	};
-
-	const drain = async (): Promise<void> => {
-		stopScheduling();
-		await inFlight;
-		if (failure !== undefined) throw failure;
-	};
-
-	return {
-		start(): void {
-			if (active || failure !== undefined) return;
-			active = true;
-			generation += 1;
-			nextDeadline = Date.now() + intervalMs;
-			schedule(generation);
-		},
-		stop: stopScheduling,
-		drain,
-		fail,
-		race<T>(work: Promise<T>): Promise<T> {
-			if (failure !== undefined) return Promise.reject(failure);
-			return Promise.race([work, failureSignal]);
-		},
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/stage-tool-execution-buffer.ts

@@ -1,49 +0,0 @@
-import type { AgentSessionEvent } from "@bastani/atomic";
-
-interface PendingToolExecution {
-	start: AgentSessionEvent;
-	update?: AgentSessionEvent;
-}
-
-function eventType(event: AgentSessionEvent): string {
-	return String((event as { type?: unknown }).type ?? "");
-}
-
-function toolCallId(event: AgentSessionEvent): string | undefined {
-	const value = (event as { toolCallId?: unknown }).toolCallId;
-	return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-export class StageToolExecutionBuffer {
-	private readonly pending = new Map<string, PendingToolExecution>();
-
-	record(event: AgentSessionEvent): void {
-		const type = eventType(event);
-		if (type === "agent_start" || type === "agent_end") {
-			this.pending.clear();
-			return;
-		}
-		const id = toolCallId(event);
-		if (id === undefined) return;
-		if (type === "tool_execution_start") {
-			this.pending.set(id, { start: event });
-			return;
-		}
-		if (type === "tool_execution_update") {
-			const existing = this.pending.get(id);
-			if (existing) existing.update = event;
-			return;
-		}
-		if (type === "tool_execution_end") this.pending.delete(id);
-	}
-
-	replayEvents(): readonly AgentSessionEvent[] {
-		return [...this.pending.values()].flatMap((entry) =>
-			entry.update ? [entry.start, entry.update] : [entry.start],
-		);
-	}
-
-	clear(): void {
-		this.pending.clear();
-	}
-}

package/dist/builtin/workflows/src/runs/shared/concurrency.ts

@@ -1,76 +0,0 @@
-/**
- * ConcurrencyLimiter — simple semaphore for per-run stage concurrency.
- *
- * Limits how many stage methods can execute simultaneously within a single run.
- * Callers `await limiter.acquire()` before starting, then call `release()` in a
- * finally block when done. The `run()` helper composes both automatically.
- */
-
-export class ConcurrencyLimiter {
-	private _running = 0;
-	private readonly _queue: Array<() => void> = [];
-
-	constructor(readonly limit: number) {
-		if (!Number.isInteger(limit) || limit < 1) {
-			throw new RangeError(`ConcurrencyLimiter: limit must be a positive integer, got ${limit}`);
-		}
-	}
-
-	/** Current number of in-flight tasks. */
-	get running(): number {
-		return this._running;
-	}
-
-	/** Number of tasks waiting for a slot. */
-	get queued(): number {
-		return this._queue.length;
-	}
-
-	/**
-	 * Acquire a slot.  Resolves immediately when capacity is available; otherwise
-	 * queues the caller until a slot is released.
-	 */
-	acquire(): Promise<void> {
-		if (this._running < this.limit) {
-			this._running++;
-			return Promise.resolve();
-		}
-		return new Promise<void>((resolve) => {
-			this._queue.push(resolve);
-		});
-	}
-
-	/**
-	 * Release a slot.  If callers are queued, the next one is unblocked.
-	 */
-	release(): void {
-		const next = this._queue.shift();
-		if (next !== undefined) {
-			// Keep _running the same — we're handing the slot directly to the next waiter.
-			next();
-		} else {
-			this._running--;
-		}
-	}
-
-	/**
-	 * Convenience wrapper: acquires a slot, runs `fn`, releases on completion.
-	 * Rethrows any error thrown by `fn` after releasing.
-	 */
-	async run<T>(fn: () => Promise<T>): Promise<T> {
-		await this.acquire();
-		try {
-			return await fn();
-		} finally {
-			this.release();
-		}
-	}
-}
-
-/**
- * Create a per-run ConcurrencyLimiter from a resolved config value.
- * Falls back to the library default (4) when `defaultConcurrency` is absent.
- */
-export function createRunLimiter(defaultConcurrency?: number): ConcurrencyLimiter {
-	return new ConcurrencyLimiter(defaultConcurrency ?? 4);
-}

package/dist/builtin/workflows/src/runs/shared/graph-inference.ts

@@ -1,2 +0,0 @@
-export type { StageNode } from "../../engine/graph-inference.js";
-export { GraphFrontierTracker } from "../../engine/graph-inference.js";