@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -1,3 +1,10 @@
+import {
+  _buildStageSnapshots,
+  findRunBlockedMetadata,
+  findRunStartMetadata,
+  restoreTerminalRuns,
+  serializableObjectOrEmpty,
+} from "./persistence-restore-helpers.js";
 /**
  * Restore: scan session entries for in-flight runs on session_start.
  * Detects run.start entries without matching run.end and marks crashed or
@@ -7,24 +14,8 @@
  */
 
 import type { Store } from "./store.js";
-import type {
-  RunSnapshot,
-  RunStatus,
-  StageSnapshot,
-  StageStatus,
-  WorkflowFailureCode,
-  WorkflowFailureDisposition,
-  WorkflowFailureKind,
-} from "./store-types.js";
-import type { WorkflowExitStatus, WorkflowInputValues, WorkflowOutputValues } from "./types.js";
-import { workflowSerializableObjectSchema } from "./serializable.js";
-import { Value } from "typebox/value";
-import {
-  isWorkflowFailureCode,
-  isWorkflowFailureDisposition,
-  isWorkflowFailureKind,
-  isWorkflowFailureRecoverability,
-} from "./workflow-failures.js";
+import type { RunSnapshot } from "./store-types.js";
+import type { WorkflowInputValues } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Config option
@@ -64,19 +55,6 @@ export interface InFlightRun {
   readonly stageIds: readonly string[];
 }
 
-interface RestoredRunBlockedMetadata {
-  readonly failedStageId: string;
-  readonly error: string;
-  readonly failureKind: WorkflowFailureKind;
-  readonly failureCode?: WorkflowFailureCode;
-  readonly failureRecoverability: "recoverable";
-  readonly failureDisposition?: WorkflowFailureDisposition;
-  readonly failureMessage?: string;
-  readonly retryAfterMs?: number;
-  readonly resumable: true;
-  readonly ts: number;
-}
-
 // ---------------------------------------------------------------------------
 // Scan logic
 // ---------------------------------------------------------------------------
@@ -273,403 +251,3 @@ export function restoreOnSessionStart(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/** Rebuild partial StageSnapshot array from session entries for a given run. */
-function _buildStageSnapshots(
-  entries: readonly SessionEntry[],
-  runId: string,
-  blockedMeta?: RestoredRunBlockedMetadata,
-): StageSnapshot[] {
-  const stageMap = new Map<string, StageSnapshot>();
-  const endedStages = new Set<string>();
-
-  for (const entry of entries) {
-    if (entry.payload["runId"] !== runId) continue;
-
-    if (entry.type === "workflow.stage.start") {
-      const stageId = entry.payload["stageId"];
-      const name = entry.payload["name"];
-      const parentIds = entry.payload["parentIds"];
-      const ts = entry.payload["ts"];
-      if (typeof stageId !== "string" || typeof name !== "string") continue;
-      if (!stageMap.has(stageId)) {
-        stageMap.set(stageId, {
-          id: stageId,
-          name,
-          status: "running",
-          parentIds: Array.isArray(parentIds) ? (parentIds as string[]) : [],
-          startedAt: typeof ts === "number" ? ts : undefined,
-          ...replayMetadata(entry.payload),
-          toolEvents: [],
-        });
-      }
-    }
-
-    if (entry.type === "workflow.stage.end") {
-      const stageId = entry.payload["stageId"];
-      const status = entry.payload["status"];
-      const durationMs = entry.payload["durationMs"];
-      const summary = entry.payload["summary"];
-      const error = entry.payload["error"];
-      const failureKind = entry.payload["failureKind"];
-      const failureCode = entry.payload["failureCode"];
-      const failureRecoverability = entry.payload["failureRecoverability"];
-      const failureDisposition = entry.payload["failureDisposition"];
-      const retryAfterMs = entry.payload["retryAfterMs"];
-      const failureMessage = entry.payload["failureMessage"];
-      const skippedReason = entry.payload["skippedReason"];
-      const sessionId = entry.payload["sessionId"];
-      const sessionFile = entry.payload["sessionFile"];
-      if (typeof stageId !== "string") continue;
-      endedStages.add(stageId);
-      const snap = stageMap.get(stageId);
-      if (snap) {
-        snap.status = restoreStageStatus(status);
-        if (typeof durationMs === "number") snap.durationMs = durationMs;
-        if (typeof summary === "string") snap.result = summary;
-        if (typeof error === "string") snap.error = error;
-        if (typeof failureKind === "string" && isWorkflowFailureKind(failureKind)) snap.failureKind = failureKind;
-        if (typeof failureCode === "string" && isWorkflowFailureCode(failureCode)) snap.failureCode = failureCode;
-        if (typeof failureRecoverability === "string" && isWorkflowFailureRecoverability(failureRecoverability)) snap.failureRecoverability = failureRecoverability;
-        if (typeof failureDisposition === "string" && isWorkflowFailureDisposition(failureDisposition)) snap.failureDisposition = failureDisposition;
-        if (typeof retryAfterMs === "number") snap.retryAfterMs = retryAfterMs;
-        if (typeof failureMessage === "string") snap.failureMessage = failureMessage;
-        if (typeof skippedReason === "string") snap.skippedReason = skippedReason;
-        if (typeof sessionId === "string") snap.sessionId = sessionId;
-        if (typeof sessionFile === "string") snap.sessionFile = sessionFile;
-        Object.assign(snap, replayMetadata(entry.payload), workflowChildMetadata(entry.payload));
-      }
-    }
-  }
-
-  if (blockedMeta !== undefined) {
-    restoreBlockedStageState(stageMap, endedStages, blockedMeta);
-  } else {
-    // Mark any stage that didn't get an end entry as crashed.
-    for (const [stageId, snap] of stageMap) {
-      if (endedStages.has(stageId)) continue;
-      snap.status = "failed";
-      snap.error = "Stage did not complete — process was interrupted.";
-    }
-  }
-
-  return [...stageMap.values()];
-}
-
-function hasRestoredAncestor(
-  stageMap: ReadonlyMap<string, StageSnapshot>,
-  stage: StageSnapshot,
-  ancestorId: string,
-): boolean {
-  const queue = [...stage.parentIds];
-  const seen = new Set<string>();
-
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (next === undefined || seen.has(next)) continue;
-    if (next === ancestorId) return true;
-    seen.add(next);
-    queue.push(...(stageMap.get(next)?.parentIds ?? []));
-  }
-
-  return false;
-}
-
-function markRestoredBlockedFailureStage(
-  snap: StageSnapshot,
-  blockedMeta: RestoredRunBlockedMetadata,
-): void {
-  snap.status = "failed";
-  snap.error = blockedMeta.error;
-  snap.failureKind = blockedMeta.failureKind;
-  snap.failureCode = blockedMeta.failureCode;
-  snap.failureRecoverability = blockedMeta.failureRecoverability;
-  snap.failureDisposition = blockedMeta.failureDisposition;
-  snap.failureMessage = blockedMeta.failureMessage;
-  snap.retryAfterMs = blockedMeta.retryAfterMs;
-}
-
-function restoreBlockedStageState(
-  stageMap: Map<string, StageSnapshot>,
-  endedStages: ReadonlySet<string>,
-  blockedMeta: RestoredRunBlockedMetadata,
-): void {
-  for (const [stageId, snap] of stageMap) {
-    if (endedStages.has(stageId)) continue;
-    if (stageId === blockedMeta.failedStageId) {
-      markRestoredBlockedFailureStage(snap, blockedMeta);
-      continue;
-    }
-    if (hasRestoredAncestor(stageMap, snap, blockedMeta.failedStageId)) {
-      snap.status = "blocked";
-      snap.blockedByStageId = blockedMeta.failedStageId;
-    }
-  }
-}
-
-function replayMetadata(payload: Record<string, unknown>): Pick<StageSnapshot, "replayKey" | "replayedFromStageId" | "replayed"> {
-  const replayKey = payload["replayKey"];
-  const replayedFromStageId = payload["replayedFromStageId"];
-  const replayed = payload["replayed"];
-  return {
-    ...(typeof replayKey === "string" ? { replayKey } : {}),
-    ...(typeof replayedFromStageId === "string" ? { replayedFromStageId } : {}),
-    ...(typeof replayed === "boolean" ? { replayed } : {}),
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function serializableObject(value: unknown): WorkflowOutputValues | undefined {
-  return Value.Check(workflowSerializableObjectSchema, value)
-    ? (value as WorkflowOutputValues)
-    : undefined;
-}
-
-function serializableObjectOrEmpty(value: unknown): WorkflowOutputValues {
-  return serializableObject(value) ?? {};
-}
-
-function isWorkflowChildReplayStatus(status: unknown): status is WorkflowExitStatus {
-  return status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked";
-}
-
-function workflowChildMetadata(payload: Record<string, unknown>): Pick<StageSnapshot, "workflowChild"> {
-  if (payload["status"] !== "completed") return {};
-  const workflowChild = payload["workflowChild"];
-  if (!isRecord(workflowChild)) return {};
-  const alias = workflowChild["alias"];
-  const workflow = workflowChild["workflow"];
-  const childRunId = workflowChild["runId"];
-  const status = workflowChild["status"];
-  const outputs = workflowChild["outputs"];
-  const exited = workflowChild["exited"];
-  const exitReason = workflowChild["exitReason"];
-  if (
-    typeof alias !== "string" ||
-    typeof workflow !== "string" ||
-    typeof childRunId !== "string" ||
-    !isWorkflowChildReplayStatus(status) ||
-    !isRecord(outputs)
-  ) {
-    return {};
-  }
-
-  // `structuredClone` detaches the restored snapshot from the parsed JSONL
-  // payload with a guaranteed deep copy, independent of the TypeBox
-  // serializable check. Declared `outputs` are the child contract, so a
-  // non-serializable value bails the whole child snapshot.
-  let clonedOutputs: WorkflowOutputValues;
-  try {
-    const serializableOutputs = serializableObject(outputs);
-    if (serializableOutputs === undefined) return {};
-    clonedOutputs = structuredClone(serializableOutputs);
-  } catch {
-    return {};
-  }
-
-  return {
-    workflowChild: {
-      alias,
-      workflow,
-      runId: childRunId,
-      status,
-      ...(typeof exited === "boolean" ? { exited } : status !== "completed" || typeof exitReason === "string" ? { exited: true } : {}),
-      outputs: clonedOutputs,
-      ...(typeof exitReason === "string" ? { exitReason } : {}),
-    },
-  };
-}
-
-function restoreStageStatus(status: unknown): StageStatus {
-  switch (status) {
-    case "completed":
-    case "failed":
-    case "skipped":
-    case "blocked":
-      return status;
-    default:
-      return "failed";
-  }
-}
-
-function numericRetryAfterMs(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-
-function findRunBlockedMetadata(
-  entries: readonly SessionEntry[],
-  runId: string,
-): RestoredRunBlockedMetadata | undefined {
-  let latest: RestoredRunBlockedMetadata | undefined;
-  for (const entry of entries) {
-    if (entry.type !== "workflow.run.blocked" || entry.payload["runId"] !== runId) continue;
-    const failedStageId = entry.payload["failedStageId"];
-    const error = entry.payload["error"];
-    const failureKind = entry.payload["failureKind"];
-    const failureCode = entry.payload["failureCode"];
-    const failureRecoverability = entry.payload["failureRecoverability"];
-    const failureDisposition = entry.payload["failureDisposition"];
-    const failureMessage = entry.payload["failureMessage"];
-    const retryAfterMs = numericRetryAfterMs(entry.payload["retryAfterMs"]);
-    const resumable = entry.payload["resumable"];
-    const ts = entry.payload["ts"];
-    if (
-      typeof failedStageId !== "string" ||
-      typeof error !== "string" ||
-      typeof failureKind !== "string" ||
-      !isWorkflowFailureKind(failureKind) ||
-      failureRecoverability !== "recoverable" ||
-      resumable !== true ||
-      typeof ts !== "number"
-    ) {
-      continue;
-    }
-    latest = {
-      failedStageId,
-      error,
-      failureKind,
-      ...(typeof failureCode === "string" && isWorkflowFailureCode(failureCode) ? { failureCode } : {}),
-      failureRecoverability: "recoverable",
-      ...(typeof failureDisposition === "string" && isWorkflowFailureDisposition(failureDisposition) ? { failureDisposition } : {}),
-      ...(typeof failureMessage === "string" ? { failureMessage } : {}),
-      ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
-      resumable: true,
-      ts,
-    };
-  }
-  return latest;
-}
-
-function restoreTerminalRuns(entries: readonly SessionEntry[], store: Store): void {
-  const started = new Map<string, { readonly name: string; readonly inputs: Readonly<WorkflowInputValues>; readonly startTs: number }>();
-  const ended = new Map<string, Record<string, unknown>>();
-
-  for (const entry of entries) {
-    if (entry.type === "workflow.run.start") {
-      const runId = entry.payload["runId"];
-      const name = entry.payload["name"];
-      const inputs = entry.payload["inputs"];
-      const ts = entry.payload["ts"];
-      if (typeof runId === "string" && typeof name === "string" && typeof ts === "number") {
-        started.set(runId, {
-          name,
-          inputs: serializableObjectOrEmpty(inputs),
-          startTs: ts,
-        });
-      }
-    }
-    if (entry.type === "workflow.run.end") {
-      const runId = entry.payload["runId"];
-      if (typeof runId === "string") ended.set(runId, entry.payload);
-    }
-  }
-
-  for (const [runId, start] of started) {
-    if (store.runs().some((run) => run.id === runId)) continue;
-    const end = ended.get(runId);
-    const status = restoreTerminalRunStatus(end?.["status"]);
-    if (end === undefined || status === undefined) continue;
-
-    const runMeta = findRunStartMetadata(entries, runId);
-    const stages = _buildStageSnapshots(entries, runId);
-    const exited = end["exited"];
-    const exitReason = end["exitReason"];
-    const resumable = end["resumable"];
-    const restoredAuthorExit = isWorkflowExitTerminalStatus(status) &&
-      (exited === true || status !== "completed" || typeof exitReason === "string" || resumable === false);
-    if (status === "completed" && !restoredAuthorExit && stages.some((stage) => stage.status !== "completed")) continue;
-    store.recordRunStart({
-      id: runId,
-      name: start.name,
-      inputs: start.inputs,
-      status: "running",
-      stages,
-      startedAt: start.startTs,
-      ...(runMeta.parentRunId !== undefined ? { parentRunId: runMeta.parentRunId } : {}),
-      ...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
-      ...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
-      ...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
-      ...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
-    });
-
-    const error = end["error"];
-    const result = serializableObject(end["result"]);
-    const failureKind = end["failureKind"];
-    const failureCode = end["failureCode"];
-    const failureRecoverability = end["failureRecoverability"];
-    const failureDisposition = end["failureDisposition"];
-    const retryAfterMs = numericRetryAfterMs(end["retryAfterMs"]);
-    const failureMessage = end["failureMessage"];
-    const failedStageId = end["failedStageId"];
-    store.recordRunEnd(
-      runId,
-      status,
-      result,
-      typeof error === "string" ? error : undefined,
-      {
-        ...(typeof failureKind === "string" && isWorkflowFailureKind(failureKind) ? { failureKind } : {}),
-        ...(typeof failureCode === "string" && isWorkflowFailureCode(failureCode) ? { failureCode } : {}),
-        ...(typeof failureRecoverability === "string" && isWorkflowFailureRecoverability(failureRecoverability) ? { failureRecoverability } : {}),
-        ...(typeof failureDisposition === "string" && isWorkflowFailureDisposition(failureDisposition) ? { failureDisposition } : {}),
-        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
-        ...(typeof failureMessage === "string" ? { failureMessage } : {}),
-        ...(typeof failedStageId === "string" ? { failedStageId } : {}),
-        ...(typeof resumable === "boolean" ? { resumable } : isWorkflowExitTerminalStatus(status) && restoredAuthorExit ? { resumable: false } : {}),
-        ...(restoredAuthorExit && isWorkflowExitTerminalStatus(status) ? { exited: true } : {}),
-        ...(typeof exitReason === "string" ? { exitReason } : {}),
-      },
-    );
-  }
-}
-
-function isWorkflowExitTerminalStatus(status: RunStatus): status is WorkflowExitStatus {
-  return status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked";
-}
-
-function restoreTerminalRunStatus(status: unknown): RunStatus | undefined {
-  switch (status) {
-    case "completed":
-    case "skipped":
-    case "cancelled":
-    case "blocked":
-    case "failed":
-    case "killed":
-      return status;
-    default:
-      return undefined;
-  }
-}
-
-function findRunStartMetadata(
-  entries: readonly SessionEntry[],
-  runId: string,
-): {
-  readonly parentRunId?: string;
-  readonly parentStageId?: string;
-  readonly rootRunId?: string;
-  readonly resumedFromRunId?: string;
-  readonly resumeFromStageId?: string;
-} {
-  for (const entry of entries) {
-    if (entry.type !== "workflow.run.start" || entry.payload["runId"] !== runId) continue;
-    const parentRunId = entry.payload["parentRunId"];
-    const parentStageId = entry.payload["parentStageId"];
-    const rootRunId = entry.payload["rootRunId"];
-    const resumedFromRunId = entry.payload["resumedFromRunId"];
-    const resumeFromStageId = entry.payload["resumeFromStageId"];
-    return {
-      ...(typeof parentRunId === "string" ? { parentRunId } : {}),
-      ...(typeof parentStageId === "string" ? { parentStageId } : {}),
-      ...(typeof rootRunId === "string" ? { rootRunId } : {}),
-      ...(typeof resumedFromRunId === "string" ? { resumedFromRunId } : {}),
-      ...(typeof resumeFromStageId === "string" ? { resumeFromStageId } : {}),
-    };
-  }
-  return {};
-}

package/dist/builtin/workflows/src/shared/store-factory.ts

@@ -0,0 +1,16 @@
+import type { Store } from "./store-public-types.js";
+import { createStoreContext } from "./store-internal.js";
+import { createPromptStoreMethods } from "./store-prompt-methods.js";
+import { createRunStoreMethods } from "./store-run-methods.js";
+import { createStageStoreMethods } from "./store-stage-methods.js";
+
+export function createStore(): Store {
+  const context = createStoreContext();
+  return {
+    ...createRunStoreMethods(context),
+    ...createStageStoreMethods(context),
+    ...createPromptStoreMethods(context),
+  };
+}
+
+export const store: Store = createStore();

package/dist/builtin/workflows/src/shared/store-internal.ts

@@ -0,0 +1,219 @@
+import type { PromptAnswerRecord, RunEndMetadata } from "./store-public-types.js";
+import type {
+  PendingPrompt,
+  RunSnapshot,
+  RunStatus,
+  StageSnapshot,
+  StageStatus,
+  StoreSnapshot,
+  WorkflowNotice,
+} from "./store-types.js";
+
+/**
+ * Statuses that represent a terminal run state — cannot be overwritten.
+ *
+ * Note on `"blocked"`: here it is an author-selected `ctx.exit({ status: "blocked" })`
+ * outcome — terminal and non-resumable. This is deliberately distinct from retry-blocking,
+ * which does NOT use this run status: `recordRunBlocked()` keeps `run.status = "running"`
+ * and records the block via `blockedAt` / `failureDisposition: "active_blocked"` (resumable).
+ * The two never collide despite the shared word.
+ */
+export const TERMINAL_STATUSES: ReadonlySet<RunStatus> = new Set([
+  "completed",
+  "failed",
+  "killed",
+  "skipped",
+  "cancelled",
+  "blocked",
+]);
+
+export interface ResolverEntry {
+  readonly promptId: string;
+  readonly resolve: (response: unknown) => void;
+  readonly reject: (reason: unknown) => void;
+}
+
+export interface StoreState {
+  readonly runs: RunSnapshot[];
+  readonly notices: WorkflowNotice[];
+  readonly listeners: Set<(snap: StoreSnapshot) => void>;
+  readonly resolvers: Map<string, ResolverEntry>;
+  readonly stagePromptAnswers: Map<string, PromptAnswerRecord>;
+  readonly stagePromptDrafts: Map<string, string>;
+  version: number;
+}
+
+export interface StoreContext {
+  readonly state: StoreState;
+  snapshot(): StoreSnapshot;
+  notify(): void;
+  bumpAndNotify(): void;
+  findRun(runId: string): RunSnapshot | undefined;
+  findStage(run: RunSnapshot, stageId: string): StageSnapshot | undefined;
+  rejectPrompt(promptId: string, reason: string): void;
+  rejectStagePrompt(runId: string, stage: StageSnapshot, reason: string): void;
+  rejectAllStagePrompts(runId: string, run: RunSnapshot, reason: string): void;
+  stagePromptAnswerKey(runId: string, stageId: string): string;
+  stagePromptDraftKey(runId: string, stageId: string, promptId: string): string;
+  stageHasActiveTextPrompt(
+    runId: string,
+    stageId: string,
+    promptId: string,
+  ): { prompt: PendingPrompt } | undefined;
+}
+
+export function isTerminalStageStatus(status: StageStatus): boolean {
+  return status === "completed" || status === "failed" || status === "skipped";
+}
+
+export function cannotAwaitInput(status: StageStatus): boolean {
+  return isTerminalStageStatus(status) || status === "paused" || status === "blocked";
+}
+
+export function cannotBlock(status: StageStatus): boolean {
+  return isTerminalStageStatus(status) || status === "paused";
+}
+
+export function cannotPause(status: StageStatus): boolean {
+  return isTerminalStageStatus(status) || status === "paused" || status === "blocked";
+}
+
+export function clearRunFailureMetadata(run: RunSnapshot): void {
+  delete run.error;
+  delete run.failureKind;
+  delete run.failureCode;
+  delete run.failureRecoverability;
+  delete run.failureDisposition;
+  delete run.failureMessage;
+  delete run.failedStageId;
+  delete run.resumable;
+  delete run.retryAfterMs;
+  delete run.blockedAt;
+  delete run.exited;
+  delete run.exitReason;
+}
+
+export function clearStaleBlockedRunMetadata(run: RunSnapshot, metadata: RunEndMetadata | undefined): void {
+  if (metadata?.failureKind === undefined) delete run.failureKind;
+  if (metadata?.failureCode === undefined) delete run.failureCode;
+  if (metadata?.failureRecoverability === undefined) delete run.failureRecoverability;
+  if (metadata?.failureDisposition === undefined) delete run.failureDisposition;
+  if (metadata?.failureMessage === undefined) delete run.failureMessage;
+  if (metadata?.failedStageId === undefined) delete run.failedStageId;
+  if (metadata?.resumable === undefined) delete run.resumable;
+  if (metadata?.retryAfterMs === undefined) delete run.retryAfterMs;
+  if (metadata?.exited === undefined) delete run.exited;
+  if (metadata?.exitReason === undefined) delete run.exitReason;
+}
+
+export function applyRunEndMetadata(run: RunSnapshot, metadata: RunEndMetadata): void {
+  if (metadata.failureKind !== undefined) run.failureKind = metadata.failureKind;
+  if (metadata.failureCode !== undefined) run.failureCode = metadata.failureCode;
+  if (metadata.failureRecoverability !== undefined) run.failureRecoverability = metadata.failureRecoverability;
+  if (metadata.failureDisposition !== undefined) run.failureDisposition = metadata.failureDisposition;
+  if (metadata.retryAfterMs !== undefined) run.retryAfterMs = metadata.retryAfterMs;
+  if (metadata.failureMessage !== undefined) run.failureMessage = metadata.failureMessage;
+  if (metadata.failedStageId !== undefined) run.failedStageId = metadata.failedStageId;
+  if (metadata.resumable !== undefined) run.resumable = metadata.resumable;
+  if (metadata.exited !== undefined) run.exited = metadata.exited;
+  if (metadata.exitReason !== undefined) run.exitReason = metadata.exitReason;
+}
+
+export function createStoreState(): StoreState {
+  return {
+    runs: [],
+    notices: [],
+    listeners: new Set(),
+    resolvers: new Map(),
+    stagePromptAnswers: new Map(),
+    stagePromptDrafts: new Map(),
+    version: 0,
+  };
+}
+
+export function createStoreContext(state: StoreState = createStoreState()): StoreContext {
+  function snapshot(): StoreSnapshot {
+    return JSON.parse(
+      JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }),
+    ) as StoreSnapshot;
+  }
+
+  function notify(): void {
+    const snap = snapshot();
+    for (const fn of state.listeners) {
+      fn(snap);
+    }
+  }
+
+  function bumpAndNotify(): void {
+    state.version++;
+    notify();
+  }
+
+  function findRun(runId: string): RunSnapshot | undefined {
+    return state.runs.find((r) => r.id === runId);
+  }
+
+  function findStage(run: RunSnapshot, stageId: string): StageSnapshot | undefined {
+    return run.stages.find((s) => s.id === stageId);
+  }
+
+  function rejectPrompt(promptId: string, reason: string): void {
+    const entry = state.resolvers.get(promptId);
+    if (!entry) return;
+    state.resolvers.delete(promptId);
+    entry.reject(new Error(reason));
+  }
+
+  function stagePromptAnswerKey(runId: string, stageId: string): string {
+    return JSON.stringify([runId, stageId]);
+  }
+
+  function stagePromptDraftKey(runId: string, stageId: string, promptId: string): string {
+    return JSON.stringify([runId, stageId, promptId]);
+  }
+
+  function stageHasActiveTextPrompt(
+    runId: string,
+    stageId: string,
+    promptId: string,
+  ): { prompt: PendingPrompt } | undefined {
+    const run = findRun(runId);
+    if (!run || TERMINAL_STATUSES.has(run.status)) return undefined;
+    const stage = findStage(run, stageId);
+    if (!stage || isTerminalStageStatus(stage.status)) return undefined;
+    const prompt = stage.pendingPrompt;
+    if (!prompt || prompt.id !== promptId) return undefined;
+    if (prompt.kind !== "input" && prompt.kind !== "editor") return undefined;
+    return { prompt };
+  }
+
+  function rejectStagePrompt(runId: string, stage: StageSnapshot, reason: string): void {
+    const prompt = stage.pendingPrompt;
+    if (!prompt) return;
+    stage.pendingPrompt = undefined;
+    state.stagePromptDrafts.delete(stagePromptDraftKey(runId, stage.id, prompt.id));
+    rejectPrompt(prompt.id, reason);
+  }
+
+  function rejectAllStagePrompts(runId: string, run: RunSnapshot, reason: string): void {
+    for (const stage of run.stages) {
+      rejectStagePrompt(runId, stage, reason);
+    }
+  }
+
+  return {
+    state,
+    snapshot,
+    notify,
+    bumpAndNotify,
+    findRun,
+    findStage,
+    rejectPrompt,
+    rejectStagePrompt,
+    rejectAllStagePrompts,
+    stagePromptAnswerKey,
+    stagePromptDraftKey,
+    stageHasActiveTextPrompt,
+  };
+}