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

package/dist/builtin/workflows/src/shared/store-public-types.ts

@@ -1,282 +0,0 @@
-import type {
-	PendingPrompt,
-	PromptKind,
-	RunResumeSource,
-	RunSnapshot,
-	RunStatus,
-	StageInputRequest,
-	StageNotice,
-	StageSnapshot,
-	StoreSnapshot,
-	ToolEvent,
-	ToolNodeSnapshot,
-	WorkflowActor,
-	WorkflowChildRunRef,
-	WorkflowFailureCode,
-	WorkflowFailureDisposition,
-	WorkflowFailureKind,
-	WorkflowFailureRecoverability,
-	WorkflowNotice,
-} from "./store-types.js";
-import type { WorkflowOutputValues } from "./types.js";
-
-export interface RunEndMetadata {
-	readonly failureKind?: WorkflowFailureKind;
-	readonly failureCode?: WorkflowFailureCode;
-	readonly failureRecoverability?: WorkflowFailureRecoverability;
-	readonly failureDisposition?: WorkflowFailureDisposition;
-	readonly failureMessage?: string;
-	readonly failedStageId?: string;
-	/** Tool node whose rejection supplied the selected terminal failure. */
-	readonly failedToolNodeId?: string;
-	readonly resumable?: boolean;
-	readonly retryAfterMs?: number;
-	readonly exited?: boolean;
-	readonly exitReason?: string;
-}
-
-export type { RunResumeSource, WorkflowActor } from "./store-types.js";
-
-export interface RunPauseMetadata {
-	readonly resumable?: boolean;
-	readonly exitReason?: string;
-	/** Who paused or quit this run. Omitted for internal engine pauses. */
-	readonly actor?: WorkflowActor;
-}
-
-export interface RunResumeMetadata {
-	/** Who resumed this run. Omitted for internal engine resumes. */
-	readonly actor?: WorkflowActor;
-	/**
-	 * Required so a new call site cannot silently start notifying: every caller
-	 * states its own path, and only `run_control` is user-visible.
-	 */
-	readonly source: RunResumeSource;
-}
-
-/** Attribution for a stage-scoped pause or resume. */
-export interface StageControlMetadata {
-	readonly actor?: WorkflowActor;
-}
-
-export interface RunBlockedMetadata extends RunEndMetadata {
-	readonly failureRecoverability: "recoverable";
-	readonly failedStageId?: string;
-	readonly resumable: true;
-	readonly blockedAt?: number;
-	readonly endedAt?: number;
-	readonly result?: WorkflowOutputValues;
-	readonly budgetState?: import("./store-types.js").RunBudgetState;
-}
-
-export type StagePromptAnswerSource = "workflow_ui" | "workflow_tool";
-
-export interface PromptAnswerRecord {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly promptId: string;
-	readonly kind: PromptKind;
-	readonly value: unknown;
-	readonly answeredAt: number;
-	readonly answerSource?: StagePromptAnswerSource;
-}
-
-export interface ResolveStagePendingPromptOptions {
-	/**
-	 * Whether to retain the response in the live-only prompt answer ledger for
-	 * continuation replay. Abort/default resolutions should set this to false.
-	 */
-	readonly recordAnswer?: boolean;
-	/** Identifies who answered the prompt so notification code can avoid echoing workflow-tool answers. */
-	readonly answerSource?: StagePromptAnswerSource;
-}
-
-export interface RecordStagePromptAnswerOptions {
-	/** Identifies who answered the prompt so notification code can avoid echoing workflow-tool answers. */
-	readonly answerSource?: StagePromptAnswerSource;
-}
-
-export interface Store {
-	runs(): readonly RunSnapshot[];
-	notices(): readonly WorkflowNotice[];
-	activeRunId(): string | null;
-	recordRunStart(run: RunSnapshot): void;
-	/** Compare-and-swap a cached child run's owning boundary during durable replay. */
-	reconcileRunParentStage(runId: string, expectedParentStageId: string, parentStageId: string): boolean;
-	recordStageStart(runId: string, stage: StageSnapshot): void;
-	recordToolNodeStart(runId: string, node: ToolNodeSnapshot): boolean;
-	recordToolNodeRunning(runId: string, nodeId: string, startedAt: number): boolean;
-	recordToolNodeEnd(
-		runId: string,
-		nodeId: string,
-		update: Pick<ToolNodeSnapshot, "status"> &
-			Partial<Pick<ToolNodeSnapshot, "endedAt" | "durationMs" | "result" | "resultSummary" | "error">>,
-	): boolean;
-	/** Link a workflow boundary stage to its live child run before that child completes. */
-	recordStageWorkflowChildRun(runId: string, stageId: string, ref: WorkflowChildRunRef): boolean;
-	recordToolStart(runId: string, stageId: string, evt: ToolEvent): void;
-	recordToolEnd(runId: string, stageId: string, evt: ToolEvent): void;
-	recordStageEnd(runId: string, stage: StageSnapshot): void;
-	/**
-	 * Records the end of a run.
-	 * Returns `true` if state changed, `false` if the run was not found or
-	 * already in a terminal state (completed | failed | killed | skipped | cancelled | blocked).
-	 * `result` is applied for intentional success/exit statuses (completed | skipped | cancelled | blocked | failed)
-	 * and for workflows that intentionally return a failed status with structured outputs.
-	 * `error` is applied for status "failed" | "killed" | "blocked".
-	 */
-	recordRunEnd(
-		runId: string,
-		status: RunStatus,
-		result?: WorkflowOutputValues,
-		error?: string,
-		metadata?: RunEndMetadata,
-	): boolean;
-	/**
-	 * Record an active, recoverable workflow failure without ending the run.
-	 * The run remains resumable/running and carries failure metadata for status,
-	 * persistence restore, and continuation decisions.
-	 */
-	recordRunBlocked(runId: string, error: string, metadata: RunBlockedMetadata): boolean;
-	/**
-	 * Remove a run from live workflow history/status. Any pending HIL prompt
-	 * waiter is rejected because the workflow will not resume through that path.
-	 * Returns `true` when a run was removed, `false` when the id is unknown.
-	 */
-	removeRun(runId: string): boolean;
-	recordNotice(notice: WorkflowNotice): void;
-	/**
-	 * Acknowledges a notice by id.
-	 * Returns `true` if notice was found and not yet acked, `false` otherwise.
-	 */
-	ackNotice(id: string): boolean;
-	/**
-	 * Record a pending HIL prompt for a run. The run must exist; if it's
-	 * already in a terminal state or already has a pending prompt, the call
-	 * is rejected (`false`). On success, store subscribers fire.
-	 *
-	 * Resolution lives on `awaitPendingPrompt` / `resolvePendingPrompt`.
-	 */
-	recordPendingPrompt(runId: string, prompt: PendingPrompt): boolean;
-	/**
-	 * Resolve the pending prompt on a run with a user-provided response.
-	 * Returns `true` when the run had a matching pending prompt (the prompt
-	 * is cleared and any waiter rejected with the response). `false` for
-	 * unknown runId, missing prompt, or id mismatch.
-	 *
-	 * `response` is forwarded verbatim to the awaiter; callers shape it to
-	 * match the prompt's kind (string for input/editor, boolean for confirm,
-	 * one of `choices` for select).
-	 */
-	resolvePendingPrompt(runId: string, promptId: string, response: unknown): boolean;
-	/**
-	 * Wait for a previously recorded pending prompt to resolve. Returns the
-	 * response value passed to `resolvePendingPrompt`. Rejects if the run is
-	 * terminated (cancelled / killed) before the user responds.
-	 *
-	 * Used by the background UI adapter to bridge `ctx.ui.*` calls to the
-	 * overlay-driven response. Foreground runs never call this.
-	 */
-	awaitPendingPrompt(runId: string, promptId: string): Promise<unknown>;
-	/** Record a pending HIL prompt for a specific workflow stage/node. */
-	recordStagePendingPrompt(runId: string, stageId: string, prompt: PendingPrompt): boolean;
-	/** Resolve a pending HIL prompt on a specific workflow stage/node. */
-	resolveStagePendingPrompt(
-		runId: string,
-		stageId: string,
-		promptId: string,
-		response: unknown,
-		options?: ResolveStagePendingPromptOptions,
-	): boolean;
-	/** Wait for a stage/node-scoped HIL prompt to resolve. */
-	awaitStagePendingPrompt(runId: string, stageId: string, promptId: string): Promise<unknown>;
-	/**
-	 * Record a live-only prompt answer for prompt-node UIs that do not use
-	 * `stage.pendingPrompt` (notably arbitrary `ctx.ui.custom<T>` widgets).
-	 * The raw value stays in the private answer ledger and is never serialized
-	 * into snapshots or persistence.
-	 */
-	recordStagePromptAnswer(
-		runId: string,
-		stageId: string,
-		prompt: PendingPrompt,
-		response: unknown,
-		options?: RecordStagePromptAnswerOptions,
-	): boolean;
-	/**
-	 * Record a live-only draft for an active stage-local input/editor prompt.
-	 * Draft text may contain secrets and must never be copied into snapshots,
-	 * status output, logs, notifications, or persisted metadata.
-	 */
-	recordStagePromptDraft(runId: string, stageId: string, promptId: string, text: string): boolean;
-	/** Return a live-only draft for an active stage-local input/editor prompt, if present. */
-	getStagePromptDraft(runId: string, stageId: string, promptId: string): string | undefined;
-	/** Clear a live-only draft for a stage-local prompt. */
-	clearStagePromptDraft(runId: string, stageId: string, promptId: string): boolean;
-	/**
-	 * Return the live-only prompt answer record for a completed prompt stage, if
-	 * still available. The returned value may contain secrets and must never be
-	 * logged, serialized, or copied into snapshots/persistence. Answers remain
-	 * resident in memory until explicitly cleared, the run is removed, or the
-	 * store is cleared.
-	 */
-	getStagePromptAnswer(runId: string, stageId: string): PromptAnswerRecord | undefined;
-	/** Clear the live-only prompt answer record for a stage. Primarily used by tests/cleanup. */
-	clearStagePromptAnswer(runId: string, stageId: string): void;
-	/**
-	 * Record Pi/pi SDK session metadata for a stage after lazy attach. The
-	 * serializable snapshot tracks this so post-mortem reopen via
-	 * `SessionManager.open(sessionFile)` is possible without storing live
-	 * handles in the store. Returns `true` when state changed.
-	 */
-	recordStageSession(runId: string, stageId: string, session: { sessionId?: string; sessionFile?: string }): boolean;
-	/** Toggle the `attachable` flag on a stage. */
-	recordStageAttachable(runId: string, stageId: string, attachable: boolean): boolean;
-	/** Toggle the `attached` flag on a stage. Snapshot-only. */
-	recordStageAttached(runId: string, stageId: string, attached: boolean): boolean;
-	/** Mark a live stage as awaiting a user response, or restore it to running. */
-	recordStageAwaitingInput(runId: string, stageId: string, awaiting: boolean, ts?: number): boolean;
-	/** Record the serializable descriptor of a brokered structured prompt awaiting an answer. */
-	recordStageInputRequest(runId: string, stageId: string, request: StageInputRequest): boolean;
-	/** Clear a stage's brokered structured-prompt descriptor. */
-	clearStageInputRequest(runId: string, stageId: string): boolean;
-	/**
-	 * Mark a stage as `paused` and record `pausedAt`. Metadata on an already-paused
-	 * stage records attribution alone, so a control path can claim a pause the
-	 * engine already published.
-	 */
-	recordStagePaused(runId: string, stageId: string, pausedAt?: number, metadata?: StageControlMetadata): boolean;
-	/**
-	 * Clear `paused`/`blocked` state on a stage and record `resumedAt`. Metadata on
-	 * an already-running stage records attribution alone.
-	 */
-	recordStageResumed(runId: string, stageId: string, resumedAt?: number, metadata?: StageControlMetadata): boolean;
-	recordStageBlocked(runId: string, stageId: string, blockedBy: string): boolean;
-	recordStageUnblocked(runId: string, stageId: string): boolean;
-	recordStageNotice(runId: string, stageId: string, notice: StageNotice): boolean;
-	/** Mark a run as `paused`. Optional metadata can annotate resumable quit/detach state and attribution. */
-	recordRunPaused(runId: string, pausedAt?: number, metadata?: RunPauseMetadata): boolean;
-	/**
-	 * Restore a run from `paused` back to `running`.
-	 *
-	 * Metadata states which path resumed the run. A run-control resume records its
-	 * attribution even when an inner engine path already flipped the status, which
-	 * is the normal order: stage control and the acknowledgement pass both resume
-	 * the run before public run control returns.
-	 */
-	recordRunResumed(runId: string, resumedAt?: number, metadata?: RunResumeMetadata): boolean;
-	/** Drop every run and notice. */
-	clear(): void;
-	snapshot(): StoreSnapshot;
-	/**
-	 * Return one immutable payload-bounded graph projection per store version.
-	 * Authored failed-exit results may retain bounded JSON output values; all
-	 * other run payloads stay omitted or compacted to bounded diagnostic fields.
-	 * Graph-visible state may change only through a version-bumping store method;
-	 * direct mutation of values returned by `runs()` would leave this cache stale.
-	 */
-	graphSnapshot(): StoreSnapshot;
-	subscribe(fn: (snap: StoreSnapshot) => void): () => void;
-	/** Subscribe synchronously to store invalidation without constructing a full snapshot. */
-	subscribeInvalidation(fn: () => void): () => void;
-}

package/dist/builtin/workflows/src/shared/store-run-methods.ts

@@ -1,305 +0,0 @@
-import { isTopLevelWorkflowRun } from "./run-visibility.js";
-import {
-	applyRunEndMetadata,
-	clearRunFailureMetadata,
-	clearStaleBlockedRunMetadata,
-	type StoreContext,
-	TERMINAL_STATUSES,
-} from "./store-internal.js";
-import type {
-	RunBlockedMetadata,
-	RunEndMetadata,
-	RunPauseMetadata,
-	RunResumeMetadata,
-	Store,
-} from "./store-public-types.js";
-import type { RunSnapshot, RunStatus, StoreSnapshot, WorkflowNotice } from "./store-types.js";
-import { accumulatePausedDurationMs, elapsedRunMs, nextControlTimestamp } from "./timing.js";
-import type { WorkflowOutputValues } from "./types.js";
-
-type RunStoreMethods = Pick<
-	Store,
-	| "runs"
-	| "notices"
-	| "activeRunId"
-	| "recordRunStart"
-	| "reconcileRunParentStage"
-	| "recordRunEnd"
-	| "recordRunBlocked"
-	| "removeRun"
-	| "recordNotice"
-	| "ackNotice"
-	| "recordRunPaused"
-	| "recordRunResumed"
-	| "clear"
-	| "snapshot"
-	| "graphSnapshot"
-	| "subscribe"
-	| "subscribeInvalidation"
->;
-
-export function createRunStoreMethods(context: StoreContext): RunStoreMethods {
-	const { state } = context;
-
-	return {
-		runs(): readonly RunSnapshot[] {
-			return state.runs;
-		},
-
-		notices(): readonly WorkflowNotice[] {
-			return state.notices;
-		},
-
-		activeRunId(): string | null {
-			// Most recently started top-level run that hasn't ended. Nested workflow runs stay in the
-			// store for live control/expanded graph rendering, but should not steal the active slot.
-			for (let i = state.runs.length - 1; i >= 0; i--) {
-				const run = state.runs[i];
-				if (run && isTopLevelWorkflowRun(run) && run.endedAt === undefined) {
-					return run.id;
-				}
-			}
-			// Degraded fallback: a child run is in flight but no top-level run is.
-			for (let i = state.runs.length - 1; i >= 0; i--) {
-				const run = state.runs[i];
-				if (run && run.endedAt === undefined) {
-					return run.id;
-				}
-			}
-			return null;
-		},
-
-		recordRunStart(run: RunSnapshot): void {
-			state.runs.push(run);
-			context.bumpAndNotify();
-		},
-
-		reconcileRunParentStage(runId: string, expectedParentStageId: string, parentStageId: string): boolean {
-			const run = context.findRun(runId);
-			if (run?.parentStageId !== expectedParentStageId || parentStageId === expectedParentStageId) return false;
-			run.parentStageId = parentStageId;
-			context.bumpAndNotify();
-			return true;
-		},
-
-		recordRunEnd(
-			runId: string,
-			status: RunStatus,
-			result?: WorkflowOutputValues,
-			error?: string,
-			metadata?: RunEndMetadata,
-		): boolean {
-			const run = context.findRun(runId);
-			if (!run) return false;
-			if (TERMINAL_STATUSES.has(run.status)) return false;
-			run.status = status;
-			run.endedAt = Date.now();
-			if (run.pausedAt !== undefined) {
-				run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, run.endedAt);
-				run.pausedAt = undefined;
-			}
-			run.durationMs = elapsedRunMs(run, run.endedAt);
-			if (result !== undefined && shouldStoreRunResult(status)) run.result = result;
-			const wasBlocked = run.blockedAt !== undefined || run.failureDisposition === "active_blocked";
-			delete run.blockedAt;
-			if (status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked") {
-				clearRunFailureMetadata(run);
-				if (status === "blocked" && error !== undefined) run.error = error;
-				if (metadata !== undefined) applyRunEndMetadata(run, metadata);
-			} else {
-				if (wasBlocked && error === undefined) delete run.error;
-				if ((status === "failed" || status === "killed") && error !== undefined) {
-					run.error = error;
-				}
-				if (wasBlocked) clearStaleBlockedRunMetadata(run, metadata);
-				if (metadata !== undefined) applyRunEndMetadata(run, metadata);
-				if (run.failureDisposition === "active_blocked") delete run.failureDisposition;
-				if (status === "killed") {
-					run.failureRecoverability = "non_recoverable";
-					run.failureDisposition = "terminal_killed";
-					run.resumable = false;
-				}
-			}
-			const pending = run.pendingPrompt;
-			if (pending) {
-				run.pendingPrompt = undefined;
-				context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
-			}
-			context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} ended before prompt resolved`);
-			context.bumpAndNotify();
-			return true;
-		},
-
-		recordRunBlocked(runId: string, error: string, metadata: RunBlockedMetadata): boolean {
-			const run = context.findRun(runId);
-			if (!run) return false;
-			if (TERMINAL_STATUSES.has(run.status)) return false;
-			run.status = "running";
-			run.error = error;
-			run.failureKind = metadata.failureKind;
-			run.failureCode = metadata.failureCode;
-			run.failureRecoverability = metadata.failureRecoverability;
-			run.failureDisposition = metadata.failureDisposition;
-			run.failureMessage = metadata.failureMessage;
-			if (metadata.failedStageId === undefined) delete run.failedStageId;
-			else run.failedStageId = metadata.failedStageId;
-			run.resumable = metadata.resumable;
-			run.blockedAt = metadata.blockedAt ?? Date.now();
-			if (metadata.endedAt !== undefined) {
-				run.endedAt = metadata.endedAt;
-				run.durationMs = elapsedRunMs(run, metadata.endedAt);
-			}
-			if (metadata.retryAfterMs !== undefined) run.retryAfterMs = metadata.retryAfterMs;
-			if (metadata.result !== undefined) run.result = metadata.result;
-			if (metadata.budgetState !== undefined) run.budgetState = metadata.budgetState;
-			context.bumpAndNotify();
-			return true;
-		},
-
-		removeRun(runId: string): boolean {
-			const index = state.runs.findIndex((r) => r.id === runId);
-			if (index < 0) return false;
-			const run = state.runs[index]!;
-			const pending = run.pendingPrompt;
-			if (pending) {
-				context.rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
-			}
-			context.rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
-			for (const stage of run.stages) {
-				state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stage.id));
-			}
-			state.runs.splice(index, 1);
-			for (let i = state.notices.length - 1; i >= 0; i--) {
-				if (state.notices[i]?.runId === runId) state.notices.splice(i, 1);
-			}
-			context.bumpAndNotify();
-			return true;
-		},
-
-		recordNotice(notice: WorkflowNotice): void {
-			state.notices.push(notice);
-			context.bumpAndNotify();
-		},
-
-		ackNotice(id: string): boolean {
-			const notice = state.notices.find((n) => n.id === id);
-			if (!notice || notice.ackedAt !== undefined) return false;
-			notice.ackedAt = Date.now();
-			context.bumpAndNotify();
-			return true;
-		},
-
-		recordRunPaused(runId: string, pausedAt?: number, metadata?: RunPauseMetadata): boolean {
-			const run = context.findRun(runId);
-			if (!run) return false;
-			if (TERMINAL_STATUSES.has(run.status)) return false;
-			const wasPaused = run.status === "paused";
-			if (!wasPaused) {
-				run.status = "paused";
-				run.pausedAt = nextControlTimestamp(pausedAt, run.resumedAt);
-				run.resumedAt = undefined;
-				delete run.pauseActor;
-				delete run.resumeActor;
-				delete run.resumeSource;
-			}
-			if (metadata?.resumable !== undefined) run.resumable = metadata.resumable;
-			if (metadata?.exitReason !== undefined) run.exitReason = metadata.exitReason;
-			if (metadata?.exitReason === "quit" && run.quitAt === undefined)
-				run.quitAt = nextControlTimestamp(undefined, run.pausedAt);
-			// A control path claims the stop it just performed, even when the engine
-			// already published the paused state on its way there.
-			if (metadata?.actor !== undefined) run.pauseActor = metadata.actor;
-			if (wasPaused && metadata === undefined) return false;
-			context.bumpAndNotify();
-			return true;
-		},
-
-		recordRunResumed(runId: string, resumedAt?: number, metadata?: RunResumeMetadata): boolean {
-			const run = context.findRun(runId);
-			if (!run) return false;
-			if (TERMINAL_STATUSES.has(run.status)) return false;
-			// Run control is the last step of a resume, by which point stage control
-			// or the acknowledgement pass has usually flipped the status already.
-			// Recording its attribution anyway is what distinguishes a deliberate
-			// resume from the engine continuing work on its own.
-			const claimsRunControl = metadata?.source === "run_control";
-			if (run.status !== "paused") {
-				if (!claimsRunControl || run.status !== "running" || run.resumedAt === undefined) return false;
-				if (run.resumeSource === "run_control" && run.resumeActor === metadata?.actor) return false;
-				run.resumeSource = "run_control";
-				if (metadata?.actor === undefined) delete run.resumeActor;
-				else run.resumeActor = metadata.actor;
-				context.bumpAndNotify();
-				return false;
-			}
-			const resumedTs = nextControlTimestamp(resumedAt, run.pausedAt);
-			run.status = "running";
-			run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, resumedTs);
-			run.resumedAt = resumedTs;
-			run.pausedAt = undefined;
-			delete run.quitAt;
-			delete run.exitReason;
-			delete run.pauseActor;
-			if (metadata === undefined) {
-				delete run.resumeActor;
-				delete run.resumeSource;
-			} else {
-				run.resumeSource = metadata.source;
-				if (metadata.actor === undefined) delete run.resumeActor;
-				else run.resumeActor = metadata.actor;
-			}
-			context.bumpAndNotify();
-			return true;
-		},
-
-		clear(): void {
-			if (
-				state.runs.length === 0 &&
-				state.notices.length === 0 &&
-				state.resolvers.size === 0 &&
-				state.stagePromptAnswers.size === 0 &&
-				state.stagePromptDrafts.size === 0
-			)
-				return;
-			state.runs.length = 0;
-			state.notices.length = 0;
-			for (const entry of state.resolvers.values()) {
-				entry.reject(new Error("atomic-workflows: store cleared"));
-			}
-			state.resolvers.clear();
-			state.stagePromptAnswers.clear();
-			state.stagePromptDrafts.clear();
-			context.bumpAndNotify();
-		},
-
-		snapshot(): StoreSnapshot {
-			return context.snapshot();
-		},
-
-		graphSnapshot(): StoreSnapshot {
-			return context.graphSnapshot();
-		},
-
-		subscribe(fn: (snap: StoreSnapshot) => void): () => void {
-			state.listeners.add(fn);
-			return () => {
-				state.listeners.delete(fn);
-			};
-		},
-
-		subscribeInvalidation(fn: () => void): () => void {
-			state.invalidationListeners.add(fn);
-			return () => state.invalidationListeners.delete(fn);
-		},
-	};
-}
-
-function shouldStoreRunResult(status: RunStatus): boolean {
-	return (
-		status === "completed" ||
-		status === "skipped" ||
-		status === "cancelled" ||
-		status === "blocked" ||
-		status === "failed"
-	);
-}