@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,466 +0,0 @@
-/**
- * Live stage-control registry — runtime-only handle table keyed by
- * `runId + stageId`. Snapshots in `StoreSnapshot` are JSON-cloned and
- * cannot carry function/AgentSession references, so live "attach a
- * pane to this stage" wiring lives here instead.
- *
- * The registry exposes:
- *  - `StageControlHandle` — per-stage prompt/steer/follow-up/pause/resume
- *    surface used by the attached chat pane.
- *  - `WorkflowRunControlHandle` — per-run aggregate used by `/workflow pause`
- *    and `/workflow resume` to fan an action across the stages that are
- *    actually pausable right now.
- *
- * A completed stage may keep its chat handle alive while being detached from
- * run-level pause/resume control. That lets the chat stay interactive without
- * letting a finished stage keep blocking or pausing downstream work.
- *
- * The registry does not know about Pi SDK details; it talks to the
- * stage-runner via a small interface so tests can fake it without a real
- * `AgentSession`.
- *
- * cross-ref:
- *   - src/runs/foreground/stage-runner.ts (InternalStageContext)
- *   - src/runs/foreground/executor.ts (registers/unregisters handles)
- *   - pi docs/sdk.md (AgentSession.prompt/steer/followUp/abort)
- */
-
-import type { AgentSession, AgentSessionEvent } from "@bastani/atomic";
-import { createSessionScopedSingleton } from "../../shared/session-scoped-singleton.js";
-import type { StageDeliveryActivityEvent } from "./stage-delivery-activity.js";
-import type { StageQueuedUserMessages } from "./stage-queued-user-messages.js";
-import type { StageUserMessageDeliveryAction } from "./stage-runner-types.js";
-
-export type StageControlStatus =
-	| "pending"
-	| "running"
-	| "awaiting_input"
-	| "paused"
-	| "blocked"
-	| "completed"
-	| "failed"
-	| "skipped";
-
-export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-
-/**
- * Per-stage interactive surface exposed to the attached chat pane.
- *
- * Implementations wrap an `InternalStageContext` (which lazily creates
- * the underlying Pi SDK `AgentSession`) and add controlled pause/resume
- * semantics that the raw SDK does not provide.
- */
-export interface StageControlHandle {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly stageName: string;
-	readonly status: StageControlStatus;
-	readonly sessionId: string | undefined;
-	readonly sessionFile: string | undefined;
-	readonly isStreaming: boolean;
-	/** True after the executor has released the live SDK session behind this handle. */
-	readonly isDisposed?: boolean;
-	readonly messages: AgentSession["messages"];
-	/** Live coding-agent session when available, used by embedded chat/footer UI. */
-	readonly agentSession?: AgentSession;
-	/** Replayable in-flight tool starts/partial updates for stage-chat remounts. */
-	pendingToolExecutionEvents?(): readonly AgentSessionEvent[];
-	/**
-	 * Pending steering/follow-up text on this stage's session, kept current from
-	 * `queue_update` for the handle's whole lifetime so a detached graph node and
-	 * a remounted stage chat can both read it. Deliberately independent of
-	 * `agentSession`: an adapter-backed runtime that publishes the ordinary
-	 * events keeps queue-aware UI.
-	 */
-	queuedUserMessages?(): StageQueuedUserMessages;
-	/** Ensure the SDK session exists. Cheap when already attached. */
-	ensureAttached(): Promise<void>;
-	/**
-	 * Deliver through the idle-aware session primitive and report the action.
-	 * `beforeDelivery` must run synchronously after async setup and immediately
-	 * before the underlying SDK admits or queues the message.
-	 */
-	sendUserMessage?(
-		text: string,
-		options?: { readonly deliverAs?: "steer" | "followUp" },
-		beforeDelivery?: () => void,
-	): Promise<StageUserMessageDeliveryAction>;
-
-	/** Send a prompt. Use only when the stage is idle / not streaming. */
-	prompt(text: string): Promise<void>;
-	/** Steer the current streaming operation (interrupt mid-turn). */
-	steer(text: string): Promise<void>;
-	/** Queue a follow-up after the current operation completes. */
-	followUp(text: string): Promise<void>;
-	/**
-	 * True controlled pause. Aborts the current Pi op without finalizing
-	 * the stage as failed; the original `prompt()` awaiter is held until
-	 * `resume()` is called.
-	 */
-	pause(): Promise<void>;
-	/**
-	 * Release a paused stage. If `message` is provided it is sent as the
-	 * next user message before resuming. `beforeResume` guards final admission.
-	 */
-	resume(message?: string, beforeResume?: () => void): Promise<undefined | StageUserMessageDeliveryAction>;
-	/**
-	 * Subscribe to AgentSession events. The pending-listener semantics
-	 * from `InternalStageContext.subscribe` apply: listeners registered
-	 * before the session exists are buffered and bound on first attach.
-	 */
-	subscribe(listener: AgentSessionEventListener): () => void;
-	/**
-	 * Subscribe to workflow-owned delivery lifecycle facts. Present only for
-	 * handles backed by a live stage runner. An accepted idle delivery reports
-	 * `delivery_start` before the public `agent_start` is published, letting an
-	 * attached chat show Working for the whole turn.
-	 */
-	subscribeDeliveryActivity?(listener: (event: StageDeliveryActivityEvent) => void): () => void;
-	/** Release the underlying SDK session and unregister this direct chat handle. */
-	dispose?(): void | Promise<void>;
-}
-
-/** Tentative ownership used by workflow sends until final message admission. */
-export interface DetachedStageHandleLease {
-	readonly handle: StageControlHandle;
-	/** Keep the handle registered after admission; false when it was displaced. */
-	commit(): boolean;
-	/** Release tentative ownership and dispose an unclaimed provisional handle. */
-	release(): Promise<void>;
-}
-
-/**
- * Per-run aggregate. Fans pause/resume to currently-running stage
- * handles. Backed by the same `StageControlRegistry`.
- */
-export interface WorkflowRunControlHandle {
-	readonly runId: string;
-	/** Stage handles still participating in run-level workflow control. */
-	stages(): readonly StageControlHandle[];
-	/** Currently paused stage handles. */
-	pausedStages(): readonly StageControlHandle[];
-	/**
-	 * Pause every currently running stage (or the specific stage when
-	 * `stageId` is supplied). Returns every handle whose pause state changed,
-	 * including cascade-blocked descendants; keeping the array return preserves
-	 * existing slash-command iteration ergonomics.
-	 */
-	pause(stageId?: string): Promise<readonly StageControlHandle[]>;
-	/**
-	 * Resume every paused stage (or the specific stage when `stageId`
-	 * is supplied). `message`, if given, is forwarded to each resumed
-	 * stage as the next user message.
-	 */
-	resume(stageId?: string, message?: string): Promise<readonly StageControlHandle[]>;
-}
-
-export interface StageControlRegistry {
-	/**
-	 * Register a stage handle. The returned disposer removes the chat handle
-	 * entirely. Stage completion should normally call `detachControl()` first so
-	 * run-level pause/resume stops seeing the stage while any open chat pane can
-	 * keep using its direct handle reference.
-	 */
-	register(handle: StageControlHandle): () => void;
-	/**
-	 * Atomically resolve an existing non-disposed handle for `runId + stageId`
-	 * or create one via `create`, register it, and immediately detach it from
-	 * run-level pause/resume control. Used by the post-mortem stage-chat
-	 * resolver so repeated attach/send calls single-flight onto one detached
-	 * writer per real stage instead of racing competing sessions.
-	 */
-	getOrCreateDetached(runId: string, stageId: string, create: () => StageControlHandle): StageControlHandle;
-	/**
-	 * Acquire tentative ownership of a detached handle. A newly-created handle
-	 * stays provisional until one lease commits or an ordinary consumer claims
-	 * it through `claim()` / `getOrCreateDetached()`.
-	 */
-	acquireDetached(runId: string, stageId: string, create: () => StageControlHandle): DetachedStageHandleLease;
-	/** Inspect without claiming a provisional detached handle. */
-	peek(runId: string, stageId: string): StageControlHandle | undefined;
-	/** Resolve and permanently claim a provisional detached handle. */
-	claim(runId: string, stageId: string): StageControlHandle | undefined;
-	/**
-	 * Remove this stage from run-level pause/resume aggregates while keeping
-	 * `get()` chat attachment live until the registration disposer runs.
-	 */
-	detachControl(runId: string, stageId: string, handle?: StageControlHandle): boolean;
-	/** Resolve one stage handle by run + stage id, including detached chats. */
-	get(runId: string, stageId: string): StageControlHandle | undefined;
-	/** Resolve all currently-registered chat handles for a run. */
-	forRun(runId: string): readonly StageControlHandle[];
-	/** True when this run currently has a registration map. */
-	has(runId: string): boolean;
-	/** Build a run-level control aggregate. Cheap; not memoised. */
-	run(runId: string): WorkflowRunControlHandle;
-	/**
-	 * Drop every registration and invoke each handle's optional dispose hook.
-	 * Used on session boundaries to release retained direct chat handles and
-	 * their subscriptions when the host store is cleared.
-	 */
-	clear(): void;
-	/**
-	 * Drop only handles detached from run-level control (`controlsDependencies`
-	 * false), disposing them through the background-dispose path. Live executor
-	 * handles that still own workflow execution stay registered. Emptied run
-	 * maps are pruned.
-	 */
-	clearDetached(): void;
-}
-
-/**
- * In-memory implementation. Handles live in a `Map<runId, Map<stageId, handle>>`
- * so per-run lookups stay cheap as workflows scale.
- */
-export function createStageControlRegistry(): StageControlRegistry {
-	type RegistryEntry = {
-		handle: StageControlHandle;
-		controlsDependencies: boolean;
-		permanent: boolean;
-		readonly leases: Set<symbol>;
-		disposal?: Promise<void>;
-	};
-
-	const _byRun = new Map<string, Map<string, RegistryEntry>>();
-
-	function ensureRun(runId: string): Map<string, RegistryEntry> {
-		let runMap = _byRun.get(runId);
-		if (!runMap) {
-			runMap = new Map();
-			_byRun.set(runId, runMap);
-		}
-		return runMap;
-	}
-
-	function controlledEntries(runId: string): RegistryEntry[] {
-		const runMap = _byRun.get(runId);
-		if (!runMap) return [];
-		return [...runMap.values()].filter((entry) => entry.controlsDependencies);
-	}
-
-	function disposeEntry(entry: RegistryEntry): Promise<void> {
-		if (entry.disposal !== undefined) return entry.disposal;
-		try {
-			entry.disposal = Promise.resolve(entry.handle.dispose?.());
-		} catch (error) {
-			entry.disposal = Promise.reject(error);
-		}
-		return entry.disposal;
-	}
-
-	function disposeEntryInBackground(entry: RegistryEntry, message: string): void {
-		void disposeEntry(entry).catch((err: unknown) => console.warn(message, err));
-	}
-
-	function makeRunHandle(runId: string): WorkflowRunControlHandle {
-		return {
-			runId,
-			stages(): readonly StageControlHandle[] {
-				return controlledEntries(runId).map((entry) => entry.handle);
-			},
-			pausedStages(): readonly StageControlHandle[] {
-				return controlledEntries(runId)
-					.map((entry) => entry.handle)
-					.filter((h) => h.status === "paused");
-			},
-			async pause(stageId?: string): Promise<readonly StageControlHandle[]> {
-				const runMap = _byRun.get(runId);
-				if (!runMap) return [];
-				const controlEntries = controlledEntries(runId);
-				const targets = stageId
-					? [runMap.get(stageId)]
-							.filter((entry): entry is RegistryEntry => entry?.controlsDependencies === true)
-							.map((entry) => entry.handle)
-					: controlEntries
-							.map((entry) => entry.handle)
-							.filter((h) => h.status === "running" || h.status === "pending");
-				const before = new Map(controlEntries.map((entry) => [entry.handle.stageId, entry.handle.status]));
-				for (const handle of targets) {
-					if (handle.status === "paused") continue;
-					if (handle.status === "completed" || handle.status === "failed" || handle.status === "skipped") continue;
-					await handle.pause();
-				}
-				return controlledEntries(runId)
-					.map((entry) => entry.handle)
-					.filter((handle) => {
-						const previous = before.get(handle.stageId);
-						return previous !== handle.status && (handle.status === "paused" || handle.status === "blocked");
-					});
-			},
-			async resume(stageId?: string, message?: string): Promise<readonly StageControlHandle[]> {
-				const runMap = _byRun.get(runId);
-				if (!runMap) return [];
-				const controlEntries = controlledEntries(runId);
-				const before = new Map(controlEntries.map((entry) => [entry.handle.stageId, entry.handle.status]));
-				const targets = stageId
-					? [runMap.get(stageId)]
-							.filter((entry): entry is RegistryEntry => entry?.controlsDependencies === true)
-							.map((entry) => entry.handle)
-					: controlEntries.map((entry) => entry.handle).filter((h) => h.status === "paused");
-				for (const handle of targets) {
-					if (handle.status !== "paused") continue;
-					await handle.resume(message);
-				}
-				return controlledEntries(runId)
-					.map((entry) => entry.handle)
-					.filter((handle) => {
-						const previous = before.get(handle.stageId);
-						return (previous === "paused" || previous === "blocked") && previous !== handle.status;
-					});
-			},
-		};
-	}
-
-	return {
-		register(handle: StageControlHandle): () => void {
-			const runMap = ensureRun(handle.runId);
-			const displaced = runMap.get(handle.stageId);
-			runMap.set(handle.stageId, {
-				handle,
-				controlsDependencies: true,
-				permanent: true,
-				leases: new Set(),
-			});
-			if (displaced !== undefined && displaced.handle !== handle && !displaced.permanent) {
-				disposeEntryInBackground(displaced, "atomic-workflows: displaced provisional stage handle dispose failed");
-			}
-			return () => {
-				const existing = _byRun.get(handle.runId);
-				if (!existing) return;
-				if (existing.get(handle.stageId)?.handle === handle) {
-					existing.delete(handle.stageId);
-				}
-				if (existing.size === 0) _byRun.delete(handle.runId);
-			};
-		},
-		getOrCreateDetached(runId: string, stageId: string, create: () => StageControlHandle): StageControlHandle {
-			const runMap = ensureRun(runId);
-			const existing = runMap.get(stageId);
-			if (existing !== undefined && existing.handle.isDisposed !== true) {
-				existing.permanent = true;
-				return existing.handle;
-			}
-			if (existing !== undefined) {
-				runMap.delete(stageId);
-				disposeEntryInBackground(existing, "atomic-workflows: stale stage handle dispose failed");
-			}
-			const handle = create();
-			runMap.set(handle.stageId, {
-				handle,
-				controlsDependencies: false,
-				permanent: true,
-				leases: new Set(),
-			});
-			return handle;
-		},
-		acquireDetached(runId: string, stageId: string, create: () => StageControlHandle): DetachedStageHandleLease {
-			const runMap = ensureRun(runId);
-			let entry = runMap.get(stageId);
-			if (entry?.handle.isDisposed === true) {
-				runMap.delete(stageId);
-				disposeEntryInBackground(entry, "atomic-workflows: stale stage handle dispose failed");
-				entry = undefined;
-			}
-			if (entry === undefined) {
-				entry = {
-					handle: create(),
-					controlsDependencies: false,
-					permanent: false,
-					leases: new Set(),
-				};
-				runMap.set(stageId, entry);
-			}
-			const leasedEntry = entry;
-			const token = Symbol("detached-stage-handle-lease");
-			leasedEntry.leases.add(token);
-			let settled = false;
-			return {
-				handle: leasedEntry.handle,
-				commit() {
-					if (settled) return false;
-					if (runMap.get(stageId) !== leasedEntry || leasedEntry.disposal !== undefined) {
-						return false;
-					}
-					settled = true;
-					leasedEntry.leases.delete(token);
-					leasedEntry.permanent = true;
-					return true;
-				},
-				async release() {
-					if (settled) return;
-					settled = true;
-					leasedEntry.leases.delete(token);
-					if (runMap.get(stageId) !== leasedEntry) {
-						if (leasedEntry.disposal !== undefined) await leasedEntry.disposal;
-						return;
-					}
-					if (leasedEntry.permanent || leasedEntry.leases.size > 0) return;
-					runMap.delete(stageId);
-					if (runMap.size === 0) _byRun.delete(runId);
-					await disposeEntry(leasedEntry);
-				},
-			};
-		},
-		detachControl(runId: string, stageId: string, handle?: StageControlHandle): boolean {
-			const entry = _byRun.get(runId)?.get(stageId);
-			if (!entry) return false;
-			if (handle !== undefined && entry.handle !== handle) return false;
-			if (!entry.controlsDependencies) return false;
-			entry.controlsDependencies = false;
-			return true;
-		},
-		peek(runId: string, stageId: string): StageControlHandle | undefined {
-			return _byRun.get(runId)?.get(stageId)?.handle;
-		},
-		claim(runId: string, stageId: string): StageControlHandle | undefined {
-			const entry = _byRun.get(runId)?.get(stageId);
-			if (entry !== undefined) entry.permanent = true;
-			return entry?.handle;
-		},
-		get(runId: string, stageId: string): StageControlHandle | undefined {
-			return _byRun.get(runId)?.get(stageId)?.handle;
-		},
-		forRun(runId: string): readonly StageControlHandle[] {
-			const runMap = _byRun.get(runId);
-			if (!runMap) return [];
-			return [...runMap.values()].map((entry) => entry.handle);
-		},
-		has(runId: string): boolean {
-			return _byRun.has(runId);
-		},
-		run(runId: string): WorkflowRunControlHandle {
-			return makeRunHandle(runId);
-		},
-		clear(): void {
-			const entries = [..._byRun.values()].flatMap((runMap) => [...runMap.values()]);
-			_byRun.clear();
-			for (const entry of entries) {
-				disposeEntryInBackground(entry, "atomic-workflows: stage handle dispose failed");
-			}
-		},
-		clearDetached(): void {
-			for (const [runId, runMap] of [..._byRun]) {
-				for (const [stageId, entry] of [...runMap]) {
-					if (entry.controlsDependencies) continue;
-					runMap.delete(stageId);
-					disposeEntryInBackground(entry, "atomic-workflows: detached stage handle dispose failed");
-				}
-				if (runMap.size === 0) _byRun.delete(runId);
-			}
-		},
-	};
-}
-
-/**
- * Process-wide registry. Tests and embedders SHOULD prefer passing an
- * explicit instance via `RunOpts.stageControlRegistry`; the singleton
- * is the default consumer surface used by the extension factory.
- */
-const SESSION_KEY = "workflows:stage-control:v1";
-const singleton = createSessionScopedSingleton(SESSION_KEY, createStageControlRegistry);
-
-export const stageControlRegistry: StageControlRegistry = singleton.facade;
-
-export function adoptStageControlRegistry(scope: object): StageControlRegistry {
-	return singleton.adopt(scope);
-}

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

@@ -1,86 +0,0 @@
-/**
- * Internal stage delivery-activity channel.
- *
- * An accepted *idle* stage delivery starts a real backend turn long before the
- * public `agent_start` clears the session's ordered extension event queue. The
- * attached stage chat therefore had no signal to paint `Working` with, and the
- * pane looked idle while the model was already running.
- *
- * This channel carries only that fact — "an idle delivery was admitted and is
- * now starting a turn" — as a workflow-internal event, so the chat can start
- * its existing Working lifecycle without fabricating SDK lifecycle events or
- * reordering the public event stream.
- *
- * Streaming deliveries (`steer` / `followUp`) never emit here: they join an
- * in-flight turn that already owns the indicator.
- *
- * cross-ref:
- *   - src/runs/foreground/stage-runner-send-user-message.ts (emitter)
- *   - src/tui/stage-chat-view-delivery-activity.ts (consumer)
- */
-
-export type StageDeliveryActivityEvent =
-	| { readonly type: "delivery_start"; readonly deliveryId: number }
-	| { readonly type: "delivery_settled"; readonly deliveryId: number };
-
-export type StageDeliveryActivityListener = (event: StageDeliveryActivityEvent) => void;
-
-export class StageDeliveryActivity {
-	private readonly listeners = new Set<StageDeliveryActivityListener>();
-	private readonly active = new Set<number>();
-	private nextDeliveryId = 0;
-
-	/**
-	 * Register `listener`, then synchronously replay every currently-active
-	 * delivery as `delivery_start`.
-	 *
-	 * A stage chat can attach after a delivery was admitted — a late `/workflow
-	 * attach`, or a remount — and would otherwise see nothing until the public
-	 * `agent_start` finally arrives. Registering before replaying matters:
-	 * snapshotting first would drop a start or settlement that lands in between.
-	 */
-	subscribe(listener: StageDeliveryActivityListener): () => void {
-		this.listeners.add(listener);
-		for (const deliveryId of [...this.active]) {
-			if (!this.listeners.has(listener)) break;
-			listener({ type: "delivery_start", deliveryId });
-		}
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-
-	/** Report an admitted idle delivery that is about to start a turn. */
-	start(): number {
-		const deliveryId = ++this.nextDeliveryId;
-		this.active.add(deliveryId);
-		this.emit({ type: "delivery_start", deliveryId });
-		return deliveryId;
-	}
-
-	/** Keep one correlated delivery active for the full asynchronous operation. */
-	async runWithLease<T>(operation: () => Promise<T>): Promise<T> {
-		const deliveryId = this.start();
-		try {
-			return await operation();
-		} finally {
-			this.settle(deliveryId);
-		}
-	}
-
-	/** Report that a delivery finished, failed, or started no turn at all. */
-	settle(deliveryId: number | undefined): void {
-		if (deliveryId === undefined || !this.active.delete(deliveryId)) return;
-		this.emit({ type: "delivery_settled", deliveryId });
-	}
-
-	/** Settle every outstanding delivery, then drop listeners. */
-	dispose(): void {
-		for (const deliveryId of [...this.active]) this.settle(deliveryId);
-		this.listeners.clear();
-	}
-
-	private emit(event: StageDeliveryActivityEvent): void {
-		for (const listener of [...this.listeners]) listener(event);
-	}
-}

package/dist/builtin/workflows/src/runs/foreground/stage-queued-user-messages.ts

@@ -1,95 +0,0 @@
-/**
- * Handle-owned projection of a stage session's pending user-message queue.
- *
- * The queue itself lives on the session, but its display lives in a stage-chat
- * pane that detach destroys, and the graph needs a count for a stage nobody is
- * attached to. Both read this buffer instead of the concrete coding-agent
- * `AgentSession`, so a custom `StageSessionRuntime` that publishes ordinary
- * `queue_update` events keeps queue-aware UI without having to satisfy the
- * whole concrete session surface.
- *
- * This is a runtime projection of the event stream, never durable workflow
- * state: nothing here belongs in a cloned `StageSnapshot`.
- *
- * cross-ref:
- *   - src/runs/foreground/executor-stage-control.ts (live handle wiring)
- *   - src/runs/foreground/postmortem-stage-chat.ts (retained-session wiring)
- *   - packages/coding-agent/src/core/agent-session-events.ts (`queue_update`)
- */
-
-import type { AgentSessionEvent } from "@bastani/atomic";
-
-/** Pending steering and follow-up text on one stage session. */
-export interface StageQueuedUserMessages {
-	readonly steering: readonly string[];
-	readonly followUp: readonly string[];
-}
-
-export const EMPTY_STAGE_QUEUED_USER_MESSAGES: StageQueuedUserMessages = Object.freeze({
-	steering: Object.freeze([]) as readonly string[],
-	followUp: Object.freeze([]) as readonly string[],
-});
-
-function queuedTexts(value: unknown): readonly string[] {
-	if (!Array.isArray(value)) return [];
-	return value.filter((entry): entry is string => typeof entry === "string");
-}
-
-export class StageQueuedUserMessageBuffer {
-	private queued: StageQueuedUserMessages = EMPTY_STAGE_QUEUED_USER_MESSAGES;
-
-	/**
-	 * Each `queue_update` is a complete snapshot, including the reduced snapshot
-	 * published just before a queued message is consumed, so replace both lists
-	 * rather than merging. Duplicates, text, and per-queue order are preserved
-	 * exactly as the session published them.
-	 */
-	record(event: AgentSessionEvent): void {
-		if (String((event as { type?: unknown }).type ?? "") !== "queue_update") return;
-		const update = event as { steering?: unknown; followUp?: unknown };
-		this.queued = {
-			steering: queuedTexts(update.steering),
-			followUp: queuedTexts(update.followUp),
-		};
-	}
-
-	snapshot(): StageQueuedUserMessages {
-		return this.queued;
-	}
-
-	clear(): void {
-		this.queued = EMPTY_STAGE_QUEUED_USER_MESSAGES;
-	}
-}
-
-/**
- * The `queue_update` a session would publish for the queue it is already
- * holding, or `undefined` when it holds nothing or does not expose its queues.
- *
- * A session announces its queue by event, so a queue that exists before this
- * stage's listeners are bound to that session is announced to nobody: the
- * retirement transfer publishes on the adopting session while the stage's
- * listeners are still unsubscribed, and a reopened retained session publishes
- * before a post-mortem handle's projection reaches it. Reading the session once
- * at attach closes that window; every later change still arrives as an event.
- *
- * The lists are copied, never aliased: a session returns its live arrays.
- */
-export function stageSessionQueueUpdateEvent(session: {
-	getSteeringMessages?(): readonly string[];
-	getFollowUpMessages?(): readonly string[];
-}): AgentSessionEvent | undefined {
-	if (typeof session.getSteeringMessages !== "function" || typeof session.getFollowUpMessages !== "function") {
-		return undefined;
-	}
-	const steering = queuedTexts(session.getSteeringMessages());
-	const followUp = queuedTexts(session.getFollowUpMessages());
-	if (steering.length === 0 && followUp.length === 0) return undefined;
-	return { type: "queue_update", steering, followUp };
-}
-
-/** Total pending entries across both queues. */
-export function stageQueuedUserMessageCount(queued: StageQueuedUserMessages | undefined): number {
-	if (!queued) return 0;
-	return queued.steering.length + queued.followUp.length;
-}

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

@@ -1,21 +0,0 @@
-import type { StageOptions, WorkflowModelAttempt } from "../../shared/types.js";
-import type { WorkflowResolvedModelCandidate } from "../shared/model-fallback.js";
-
-export function effectiveCandidateReasoning(
-	candidate: WorkflowResolvedModelCandidate,
-	fallback: StageOptions["thinkingLevel"] | undefined,
-): StageOptions["thinkingLevel"] | undefined {
-	return candidate.reasoningLevel ?? fallback;
-}
-
-export function modelAttemptReasoning(
-	candidate: WorkflowResolvedModelCandidate,
-	fallback: StageOptions["thinkingLevel"] | undefined,
-): Pick<WorkflowModelAttempt, "reasoningLevel"> {
-	const reasoningLevel = effectiveCandidateReasoning(candidate, fallback);
-	return reasoningLevel !== undefined ? { reasoningLevel } : {};
-}
-
-export function candidateLabel(candidate: WorkflowResolvedModelCandidate): string {
-	return candidate.reasoningLevel !== undefined ? `${candidate.id}:${candidate.reasoningLevel}` : candidate.id;
-}