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

package/dist/builtin/workflows/src/runs/foreground/executor-outputs.ts

@@ -1,156 +0,0 @@
-import { Value } from "typebox/value";
-import { schemaChoices, schemaFieldKind, schemaIsRequired } from "../../shared/schema-introspection.js";
-import {
-	assertWorkflowSerializableObject,
-	WORKFLOW_SERIALIZABLE_DESCRIPTION,
-	workflowSerializableTypeName,
-	workflowSerializableValidationError,
-} from "../../shared/serializable.js";
-import type {
-	WorkflowDefinition,
-	WorkflowOutputSchema,
-	WorkflowOutputValues,
-	WorkflowSerializableValue,
-} from "../../shared/types.js";
-import type { WorkflowExitOutputSnapshot } from "./executor-abort.js";
-import { isWorkflowExitSnapshotInvalidValue, workflowExitSnapshotInvalidValueMessage } from "./executor-abort.js";
-
-function hasOwnWorkflowOutput(
-	record: WorkflowOutputValues | Readonly<Record<string, WorkflowOutputSchema>>,
-	key: string,
-): boolean {
-	return Object.hasOwn(record, key);
-}
-
-function assertWorkflowOutputsExplicit(
-	scope: string,
-	sourceOutput: WorkflowOutputValues,
-	declarations: Readonly<Record<string, WorkflowOutputSchema>>,
-	missingOutputSuffix = "",
-): void {
-	for (const key of Object.keys(sourceOutput)) {
-		if (!hasOwnWorkflowOutput(declarations, key)) {
-			throw new Error(
-				`atomic-workflows: ${scope} returned undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from the .run() return`,
-			);
-		}
-	}
-	for (const [key, schema] of Object.entries(declarations)) {
-		if (!(key in sourceOutput)) {
-			if (schemaIsRequired(schema)) {
-				throw new Error(`atomic-workflows: ${scope} missing output "${key}"${missingOutputSuffix}`);
-			}
-			continue;
-		}
-		const value = sourceOutput[key];
-		const kind = schemaFieldKind(schema);
-		if (!Value.Check(schema, value)) {
-			const choices = schemaChoices(schema);
-			if (kind === "select" && choices !== undefined && typeof value === "string") {
-				throw new Error(
-					`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`,
-				);
-			}
-			throw new Error(
-				`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`,
-			);
-		}
-		const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
-		if (serializableError !== undefined) throw new Error(`atomic-workflows: ${serializableError}`);
-	}
-}
-
-function normalizeWorkflowOutputObject(
-	workflowName: string,
-	rawOutput: unknown,
-	label: string,
-): WorkflowOutputValues | undefined {
-	if (rawOutput === undefined) return undefined;
-	const normalized =
-		rawOutput !== null && typeof rawOutput === "object" && !Array.isArray(rawOutput)
-			? Object.fromEntries(Object.entries(rawOutput as Record<string, unknown>).filter(([, v]) => v !== undefined))
-			: rawOutput;
-	assertWorkflowSerializableObject(normalized, `workflow "${workflowName}" ${label}`);
-	return normalized;
-}
-
-export function normalizeWorkflowRunOutput(workflowName: string, rawOutput: unknown): WorkflowOutputValues | undefined {
-	return normalizeWorkflowOutputObject(workflowName, rawOutput, ".run() return");
-}
-
-export function normalizeWorkflowExitOutput(
-	workflowName: string,
-	snapshot: WorkflowExitOutputSnapshot | undefined,
-): WorkflowOutputValues | undefined {
-	if (snapshot === undefined) return undefined;
-	if (!snapshot.ok) throw snapshot.error;
-	if (isWorkflowExitSnapshotInvalidValue(snapshot.value)) {
-		const invalidMessage = workflowExitSnapshotInvalidValueMessage(
-			`workflow "${workflowName}" ctx.exit() outputs`,
-			snapshot.value,
-		);
-		throw new Error(
-			`atomic-workflows: ${invalidMessage ?? `workflow "${workflowName}" ctx.exit() outputs must be ${WORKFLOW_SERIALIZABLE_DESCRIPTION}, got object`}`,
-		);
-	}
-	return normalizeWorkflowOutputObject(workflowName, snapshot.value, "ctx.exit() outputs");
-}
-
-export function assertWorkflowRunOutputs(
-	workflowName: string,
-	result: WorkflowOutputValues | undefined,
-	declaredOutputs: Readonly<Record<string, WorkflowOutputSchema>> | undefined,
-): void {
-	assertWorkflowOutputsExplicit(`workflow "${workflowName}"`, result ?? {}, declaredOutputs ?? {});
-}
-
-export function assertWorkflowExitOutputs(
-	workflowName: string,
-	result: WorkflowOutputValues | undefined,
-	declaredOutputs: Readonly<Record<string, WorkflowOutputSchema>> | undefined,
-): void {
-	const declarations = declaredOutputs ?? {};
-	const sourceOutput = result ?? {};
-	const scope = `workflow "${workflowName}" ctx.exit()`;
-	for (const key of Object.keys(sourceOutput)) {
-		if (!hasOwnWorkflowOutput(declarations, key)) {
-			throw new Error(
-				`atomic-workflows: ${scope} provided undeclared output "${key}"; declare it in outputs: { "${key}": Type.... } or remove it from ctx.exit({ outputs })`,
-			);
-		}
-	}
-	for (const [key, schema] of Object.entries(declarations)) {
-		if (!(key in sourceOutput)) continue;
-		const value = sourceOutput[key];
-		const invalidSnapshotValue = workflowExitSnapshotInvalidValueMessage(`${scope} output "${key}"`, value);
-		if (invalidSnapshotValue !== undefined) throw new Error(`atomic-workflows: ${invalidSnapshotValue}`);
-		const kind = schemaFieldKind(schema);
-		if (!Value.Check(schema, value)) {
-			const choices = schemaChoices(schema);
-			if (kind === "select" && choices !== undefined && typeof value === "string") {
-				throw new Error(
-					`atomic-workflows: ${scope} output "${key}" must be one of [${choices.join(", ")}], got ${JSON.stringify(value)}`,
-				);
-			}
-			throw new Error(
-				`atomic-workflows: ${scope} output "${key}" expected ${kind}, got ${workflowSerializableTypeName(value)}`,
-			);
-		}
-		const serializableError = workflowSerializableValidationError(value, `${scope} output "${key}"`);
-		if (serializableError !== undefined) throw new Error(`atomic-workflows: ${serializableError}`);
-	}
-}
-
-export function selectWorkflowOutputs(
-	child: WorkflowDefinition,
-	rawOutput: WorkflowOutputValues | undefined,
-): WorkflowOutputValues {
-	const declarations = child.outputs ?? {};
-	const sourceOutput = rawOutput ?? {};
-	const selected: Record<string, WorkflowSerializableValue> = {};
-	for (const key of Object.keys(declarations)) {
-		const value = sourceOutput[key];
-		if (value !== undefined) selected[key] = value;
-	}
-	return selected;
-}

package/dist/builtin/workflows/src/runs/foreground/executor-prompt-nodes.ts

@@ -1,379 +0,0 @@
-import type { DurableStageTopology } from "../../durable/types.js";
-import type { DurableUiReplayRequest } from "../../durable/ui-primitive.js";
-import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
-import { appendStageEnd, appendStageStart } from "../../shared/persistence-session-entries.js";
-import { requirePrimitivePromptAnswer } from "../../shared/prompt-answer.js";
-import { withPromptCallerStack } from "../../shared/prompt-callsite-context.js";
-import { stageUiBroker } from "../../shared/stage-ui-broker.js";
-import type { Store } from "../../shared/store.js";
-import type { StageSnapshot } from "../../shared/store-types.js";
-import { elapsedStageMs } from "../../shared/timing.js";
-import type { WorkflowCustomUiFactory, WorkflowCustomUiOptions, WorkflowUIContext } from "../../shared/types.js";
-import type { WorkflowFailure } from "../../shared/workflow-failures.js";
-import type { ContinuationReplayIndex } from "./executor-continuation.js";
-import { getPromptAnswerState, sameStringSet } from "./executor-continuation.js";
-import {
-	customPromptDescriptor,
-	fallbackForPromptDescriptor,
-	hilAbortError,
-	isCustomPromptDescriptor,
-	makePrompt,
-	mergeHilSignals,
-	type PromptDescriptor,
-	promptReplayKey,
-} from "./executor-hil.js";
-import { applyFailureToStage, stageReplayFields } from "./executor-lifecycle.js";
-import type { RunOpts, WorkflowExitCleanup } from "./executor-types.js";
-import type { StageControlRegistry } from "./stage-control-registry.js";
-
-export interface PromptNodeUiAdapter extends WorkflowUIContext {
-	replayDurable(request: DurableUiReplayRequest): Promise<void>;
-}
-
-export function buildPromptNodeUiAdapter(input: {
-	readonly runId: string;
-	readonly activeStore: Store;
-	readonly opts: RunOpts;
-	readonly stageControlRegistry: StageControlRegistry;
-	readonly tracker: GraphFrontierTracker;
-	readonly replayIndex: ContinuationReplayIndex;
-	readonly signal: AbortSignal;
-	readonly throwIfWorkflowExitSelected: () => void;
-	readonly registerWorkflowExitCleanup: (stageId: string, cleanup: WorkflowExitCleanup) => () => void;
-	readonly workflowExitSkippedReason: (reason?: string) => string;
-	readonly preserveWorkflowExitSkippedReason: (stage: StageSnapshot, fallback: string) => void;
-	readonly classifyExecutorFailure: (error: unknown) => WorkflowFailure;
-	readonly durableTopologyForReplayKey?: (replayKey: string) => DurableStageTopology | undefined;
-	/** Durably publish an unanswered prompt node before exposing its live wait. */
-	readonly onPendingStage?: (runId: string, snapshot: StageSnapshot) => Promise<void>;
-}): PromptNodeUiAdapter {
-	const ask = async <T>(descriptor: PromptDescriptor<T>, durableReplay?: DurableUiReplayRequest): Promise<unknown> => {
-		input.throwIfWorkflowExitSelected();
-		const isCustom = isCustomPromptDescriptor(descriptor);
-		if (input.signal.aborted) {
-			if (isCustom) throw hilAbortError(input.signal);
-			return fallbackForPromptDescriptor(descriptor);
-		}
-		if (isCustom && descriptor.options?.signal?.aborted) throw hilAbortError(descriptor.options.signal);
-
-		const prompt = makePrompt(descriptor);
-		const replayKey = promptReplayKey(descriptor);
-		const durableTopology = input.durableTopologyForReplayKey?.(replayKey);
-		const stageId = durableTopology?.stageId ?? crypto.randomUUID();
-		const provisionalParentIds = input.tracker.onSpawn(stageId, descriptor.kind);
-		const replayDecision = input.replayIndex.decide({
-			displayName: descriptor.kind,
-			replayKey,
-			parentIds: provisionalParentIds,
-			stageId,
-			kind: "prompt",
-		});
-		const parentIds = durableTopology?.parentIds ?? replayDecision.parentIds;
-		if (!sameStringSet(parentIds, provisionalParentIds)) input.tracker.replaceParents(stageId, parentIds);
-		const replaySource = replayDecision.source;
-		const continuationAnswer =
-			replayDecision.kind === "replay"
-				? input.activeStore.getStagePromptAnswer(input.opts.continuation!.source.id, replayDecision.source.id)
-				: undefined;
-		const replayAnswer = durableReplay === undefined ? continuationAnswer : { value: durableReplay.response };
-		const shouldReplay = replayAnswer !== undefined;
-		if (shouldReplay && durableReplay === undefined) input.replayIndex.markPromptAnswerReplayed(stageId);
-		const replaySourceId = replaySource?.id;
-		const promptAnswerStatus =
-			durableReplay === undefined
-				? getPromptAnswerState(shouldReplay, replaySourceId, replayDecision.answerReplay)
-				: "available";
-		const stageSnapshot: StageSnapshot = {
-			id: stageId,
-			name: descriptor.kind,
-			replayKey,
-			status: shouldReplay ? "completed" : "running",
-			parentIds: Object.freeze(parentIds),
-			startedAt: prompt.createdAt,
-			promptFootprint: { ...prompt },
-			toolEvents: [],
-			attachable: !shouldReplay,
-			...(shouldReplay
-				? {
-						endedAt: prompt.createdAt,
-						durationMs: 0,
-						promptAnswerState: promptAnswerStatus,
-						replayedFromStageId: replaySourceId,
-						replayed: true,
-					}
-				: replaySourceId !== undefined
-					? {
-							promptAnswerState: promptAnswerStatus,
-							replayedFromStageId: replaySourceId,
-							replayed: false,
-						}
-					: {}),
-		};
-		let finalized = false;
-		let finalization: Promise<void> | undefined;
-		let unregisterWorkflowExitCleanup = (): void => {};
-		let unregisterStageControl = (): void => {};
-		let pauseGate: PromiseWithResolvers<void> | undefined;
-		const waitForExplicitResume = async (): Promise<void> => {
-			if (pauseGate !== undefined) await pauseGate.promise;
-		};
-		const finalizePromptStage = async (status: "completed" | "failed" | "skipped"): Promise<void> => {
-			if (finalization !== undefined) return finalization;
-			finalization = (async (): Promise<void> => {
-				finalized = true;
-				unregisterWorkflowExitCleanup();
-				unregisterStageControl();
-				const currentPauseGate = pauseGate;
-				pauseGate = undefined;
-				currentPauseGate?.resolve();
-				stageSnapshot.status = status;
-				stageSnapshot.endedAt = Date.now();
-				stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
-				input.activeStore.recordStageAttachable(input.runId, stageId, false);
-				input.activeStore.recordStageEnd(input.runId, stageSnapshot);
-				await input.opts.onStageEnd?.(input.runId, stageSnapshot);
-				if (input.opts.persistence) {
-					appendStageEnd(input.opts.persistence, {
-						runId: input.runId,
-						stageId,
-						status: stageSnapshot.status,
-						durationMs: stageSnapshot.durationMs,
-						...(stageSnapshot.error !== undefined ? { error: stageSnapshot.error } : {}),
-						...(stageSnapshot.failureKind !== undefined ? { failureKind: stageSnapshot.failureKind } : {}),
-						...(stageSnapshot.failureCode !== undefined ? { failureCode: stageSnapshot.failureCode } : {}),
-						...(stageSnapshot.failureRecoverability !== undefined
-							? { failureRecoverability: stageSnapshot.failureRecoverability }
-							: {}),
-						...(stageSnapshot.failureDisposition !== undefined
-							? { failureDisposition: stageSnapshot.failureDisposition }
-							: {}),
-						...(stageSnapshot.failureMessage !== undefined
-							? { failureMessage: stageSnapshot.failureMessage }
-							: {}),
-						...(stageSnapshot.retryAfterMs !== undefined ? { retryAfterMs: stageSnapshot.retryAfterMs } : {}),
-						...(stageSnapshot.skippedReason !== undefined ? { skippedReason: stageSnapshot.skippedReason } : {}),
-						...stageReplayFields(stageSnapshot),
-					});
-				}
-				input.tracker.onSettle(stageId);
-			})();
-			return finalization;
-		};
-
-		input.activeStore.recordStageStart(input.runId, stageSnapshot);
-		input.opts.onStageStart?.(input.runId, stageSnapshot);
-		unregisterStageControl = input.stageControlRegistry.register({
-			runId: input.runId,
-			stageId,
-			stageName: descriptor.kind,
-			get status() {
-				return stageSnapshot.status;
-			},
-			sessionId: undefined,
-			sessionFile: undefined,
-			isStreaming: false,
-			messages: [],
-			async ensureAttached() {},
-			async prompt() {},
-			async steer() {},
-			async followUp() {},
-			async pause() {
-				if (pauseGate === undefined) pauseGate = Promise.withResolvers<void>();
-				input.activeStore.recordStagePaused(input.runId, stageId);
-			},
-			async resume() {
-				input.activeStore.recordStageResumed(input.runId, stageId);
-				// Answering a human-in-the-loop prompt continues work already in flight.
-				// It is not a control action and must never reach the main chat.
-				input.activeStore.recordRunResumed(input.runId, undefined, { source: "prompt_answer" });
-				const currentPauseGate = pauseGate;
-				pauseGate = undefined;
-				currentPauseGate?.resolve();
-			},
-			subscribe: () => () => {},
-		});
-		unregisterWorkflowExitCleanup = input.registerWorkflowExitCleanup(stageId, {
-			async skipForWorkflowExit(reason?: string): Promise<void> {
-				if (finalized) {
-					await finalization;
-					return;
-				}
-				stageSnapshot.skippedReason = input.workflowExitSkippedReason(reason);
-				if (!shouldReplay) {
-					stageUiBroker.cancelStagePrompt(
-						input.runId,
-						stageId,
-						new Error(`atomic-workflows: prompt ${stageId} skipped by workflow exit`),
-					);
-				}
-				await finalizePromptStage("skipped");
-			},
-		});
-		if (input.opts.persistence) {
-			appendStageStart(input.opts.persistence, {
-				runId: input.runId,
-				stageId,
-				name: stageSnapshot.name,
-				parentIds: stageSnapshot.parentIds,
-				...stageReplayFields(stageSnapshot),
-				ts: prompt.createdAt,
-			});
-		}
-		if (shouldReplay) {
-			await Promise.resolve();
-			input.throwIfWorkflowExitSelected();
-			let response = replayAnswer.value;
-			try {
-				if (!isCustom) response = requirePrimitivePromptAnswer(descriptor, response);
-			} catch (err) {
-				applyFailureToStage(stageSnapshot, input.classifyExecutorFailure(err));
-				await finalizePromptStage("failed");
-				throw err;
-			}
-			await finalizePromptStage("completed");
-			return response;
-		}
-
-		try {
-			await input.onPendingStage?.(input.runId, stageSnapshot);
-		} catch (err) {
-			applyFailureToStage(stageSnapshot, input.classifyExecutorFailure(err));
-			await finalizePromptStage("failed");
-			throw err;
-		}
-
-		if (isCustom) {
-			// `overlay: true` is a placement hint the attached stage-chat host
-			// honours by mounting on its ordinary custom-UI slot, so a workflow
-			// asking for an overlay is served rather than failed here.
-			const mergedSignal = mergeHilSignals(input.signal, descriptor.options?.signal);
-			try {
-				if (mergedSignal.signal.aborted) throw hilAbortError(mergedSignal.signal);
-				const accepted = input.activeStore.recordStageAwaitingInput(input.runId, stageId, true, prompt.createdAt);
-				if (!accepted) {
-					const error = new Error("atomic-workflows: ctx.ui.custom prompt node is unavailable");
-					stageSnapshot.skippedReason = "prompt-unavailable";
-					await finalizePromptStage("skipped");
-					throw error;
-				}
-				const response = await stageUiBroker.requestCustomUi(
-					input.runId,
-					stageId,
-					descriptor.factory as unknown as Parameters<typeof stageUiBroker.requestCustomUi>[2],
-					descriptor.options as Parameters<typeof stageUiBroker.requestCustomUi>[3],
-					mergedSignal.signal,
-				);
-				await waitForExplicitResume();
-				input.activeStore.recordStagePromptAnswer(input.runId, stageId, prompt, response, {
-					answerSource: "workflow_ui",
-				});
-				await finalizePromptStage("completed");
-				return response;
-			} catch (err) {
-				input.activeStore.recordStageAwaitingInput(input.runId, stageId, false);
-				stageUiBroker.cancelStagePrompt(input.runId, stageId, err);
-				if (mergedSignal.signal.aborted) {
-					input.preserveWorkflowExitSkippedReason(
-						stageSnapshot,
-						input.signal.aborted ? "run-aborted" : "prompt-aborted",
-					);
-					await finalizePromptStage("skipped");
-					throw hilAbortError(mergedSignal.signal);
-				}
-				if (!finalized) {
-					applyFailureToStage(stageSnapshot, input.classifyExecutorFailure(err));
-					await finalizePromptStage("failed");
-				}
-				throw err;
-			} finally {
-				mergedSignal.dispose();
-			}
-		}
-
-		const accepted = input.activeStore.recordStagePendingPrompt(input.runId, stageId, prompt);
-		if (!accepted) {
-			stageSnapshot.skippedReason = "prompt-unavailable";
-			await finalizePromptStage("skipped");
-			return fallbackForPromptDescriptor(descriptor);
-		}
-
-		const waiter = input.activeStore.awaitStagePendingPrompt(input.runId, stageId, prompt.id);
-		try {
-			const response = await new Promise<unknown>((resolve, reject) => {
-				const onAbort = (): void => {
-					input.activeStore.resolveStagePendingPrompt(
-						input.runId,
-						stageId,
-						prompt.id,
-						fallbackForPromptDescriptor(descriptor),
-						{ recordAnswer: false },
-					);
-					reject(hilAbortError(input.signal));
-				};
-				if (input.signal.aborted) {
-					onAbort();
-					return;
-				}
-				input.signal.addEventListener("abort", onAbort, { once: true });
-				waiter.then(
-					(value) => {
-						input.signal.removeEventListener("abort", onAbort);
-						resolve(value);
-					},
-					(err: unknown) => {
-						input.signal.removeEventListener("abort", onAbort);
-						reject(err);
-					},
-				);
-			});
-			const normalizedResponse = requirePrimitivePromptAnswer(descriptor, response);
-			await waitForExplicitResume();
-			await finalizePromptStage("completed");
-			return normalizedResponse;
-		} catch (err) {
-			if (input.signal.aborted) {
-				input.preserveWorkflowExitSkippedReason(stageSnapshot, "run-aborted");
-				await finalizePromptStage("skipped");
-			} else {
-				applyFailureToStage(stageSnapshot, input.classifyExecutorFailure(err));
-				await finalizePromptStage("failed");
-			}
-			throw err;
-		}
-	};
-
-	return {
-		async replayDurable(request: DurableUiReplayRequest): Promise<void> {
-			await withPromptCallerStack(request.callerStack, async () => {
-				if (request.kind === "input") {
-					await ask({ kind: "input", message: request.promptText }, request);
-				} else if (request.kind === "confirm") {
-					await ask({ kind: "confirm", message: request.message }, request);
-				} else if (request.kind === "select") {
-					await ask({ kind: "select", message: request.message, choices: request.options }, request);
-				} else if (request.kind === "editor") {
-					await ask({ kind: "editor", message: "Edit and save to continue.", initial: request.initial }, request);
-				} else {
-					await ask(customPromptDescriptor(request.factory, request.options), request);
-				}
-			});
-		},
-		async input(promptText: string): Promise<string> {
-			return (await ask({ kind: "input", message: promptText })) as string;
-		},
-		async confirm(message: string): Promise<boolean> {
-			return (await ask({ kind: "confirm", message })) as boolean;
-		},
-		async select<T extends string>(message: string, options: readonly T[]): Promise<T> {
-			if (options.length === 0) throw new Error("atomic-workflows: ctx.ui.select requires at least one option");
-			return (await ask({ kind: "select", message, choices: options })) as T;
-		},
-		async editor(initial?: string): Promise<string> {
-			return (await ask({ kind: "editor", message: "Edit and save to continue.", initial })) as string;
-		},
-		async custom<T>(factory: WorkflowCustomUiFactory<T>, options?: WorkflowCustomUiOptions): Promise<T> {
-			const response = await ask(customPromptDescriptor(factory, options));
-			return response as T;
-		},
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/executor-queued-user-message.ts

@@ -1,75 +0,0 @@
-import type { StageSessionEvent } from "./stage-runner-types.js";
-
-interface QueueSnapshot {
-	readonly steering: readonly string[];
-	readonly followUp: readonly string[];
-}
-
-function removedMessages(before: readonly string[], after: readonly string[]): string[] {
-	const remaining = [...after];
-	const removed: string[] = [];
-	for (const message of before) {
-		const index = remaining.indexOf(message);
-		if (index === -1) removed.push(message);
-		else remaining.splice(index, 1);
-	}
-	return removed;
-}
-
-function userMessageText(event: StageSessionEvent): string | undefined {
-	if (event.type !== "message_start" || event.message.role !== "user") return undefined;
-	const { content } = event.message;
-	if (typeof content === "string") return content;
-	return content
-		.filter((block) => block.type === "text")
-		.map((block) => block.text)
-		.join("");
-}
-
-/**
- * Arms only when a user message is consumed inside an SDK agent run. The
- * prompt that starts a run is its first user message; later user messages are
- * steering/follow-up deliveries. Queue-removal correlation also recognizes a
- * queued message consumed as the first user message of a follow-on
- * `agent.continue()` run.
- *
- * Queue additions and clears never arm by themselves. Candidate removals are
- * retained across intervening events but discarded at run boundaries, which
- * avoids both extension-event ordering races and stale matches in later idle
- * prompts.
- */
-export function createQueuedUserMessageConsumptionWatcher(
-	armContinuation: () => void,
-): (event: StageSessionEvent) => void {
-	let snapshot: QueueSnapshot = { steering: [], followUp: [] };
-	let consumptionCandidates: string[] = [];
-	let userMessageSeenInAgentRun = false;
-
-	return (event): void => {
-		if (event.type === "queue_update") {
-			consumptionCandidates.push(
-				...removedMessages(snapshot.steering, event.steering),
-				...removedMessages(snapshot.followUp, event.followUp),
-			);
-			snapshot = { steering: [...event.steering], followUp: [...event.followUp] };
-			return;
-		}
-		if (event.type === "agent_start") {
-			consumptionCandidates = [];
-			userMessageSeenInAgentRun = false;
-			return;
-		}
-		if (event.type === "agent_end") {
-			consumptionCandidates = [];
-			userMessageSeenInAgentRun = false;
-			return;
-		}
-
-		const text = userMessageText(event);
-		if (text === undefined) return;
-		const candidateIndex = consumptionCandidates.indexOf(text);
-		if (userMessageSeenInAgentRun || candidateIndex !== -1) armContinuation();
-		if (candidateIndex !== -1) consumptionCandidates.splice(candidateIndex, 1);
-		userMessageSeenInAgentRun = true;
-	};
-}