@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-hdpj1dkw.js

@@ -0,0 +1,2447 @@
+import {
+  build_scoring_prompt,
+  scoring_prompt_reads
+} from "./chunk-7430zyas.js";
+import {
+  DEFAULT_FALL_DELTA,
+  DEFAULT_RISE_DELTA,
+  classify_trend
+} from "./chunk-6fqs7c01.js";
+import {
+  VERIFICATION_SCALE
+} from "./chunk-cg9tmks0.js";
+import {
+  sessionScopedExtensionState
+} from "./chunk-5n10x7j2.js";
+import {
+  getAgentDir,
+  getEnvValue
+} from "./chunk-x2ghn0je.js";
+
+// dist/builtin/workflows/src/shared/workflow-artifacts.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+// dist/builtin/workflows/src/shared/workflow-failures-contract.ts
+var WORKFLOW_FAILURE_KINDS = new Set([
+  "auth",
+  "rate_limit",
+  "provider",
+  "cancelled",
+  "unknown"
+]);
+
+// dist/builtin/workflows/src/shared/workflow-failures-decisions.ts
+var INVALID_API_KEY_CODES = new Set([
+  "401",
+  "invalid_api_key",
+  "incorrect_api_key",
+  "invalid_api_key_error",
+  "invalid_credentials",
+  "bad_credentials",
+  "authentication_error"
+]);
+var LOGIN_REQUIRED_CODES = new Set([
+  "auth",
+  "auth_required",
+  "authentication_required",
+  "login_required",
+  "not_logged_in"
+]);
+var MISSING_API_KEY_CODES = new Set(["missing_api_key", "api_key_missing", "no_api_key"]);
+var RATE_LIMIT_CODES = new Set(["429", "rate_limit", "rate_limited", "rate_limit_exceeded", "too_many_requests"]);
+var QUOTA_LIMIT_CODES = new Set([
+  "quota",
+  "quota_exceeded",
+  "insufficient_quota",
+  "usage_limit",
+  "usage_limit_exceeded"
+]);
+var CANCELLED_CODES = new Set(["aborterror", "aborted", "cancelled", "canceled"]);
+var PROVIDER_UNAVAILABLE_CODES = new Set([
+  "500",
+  "502",
+  "503",
+  "504",
+  "provider_error",
+  "service_unavailable",
+  "temporarily_unavailable",
+  "overloaded",
+  "timeout",
+  "network_error"
+]);
+var UNKNOWN_MODEL_CODES = new Set(["unknown_model", "model_not_found", "model_not_available", "unsupported_model"]);
+var FORBIDDEN_CONFIG_CODES = new Set([
+  "403",
+  "forbidden",
+  "permission_denied",
+  "access_denied",
+  "forbidden_config",
+  "invalid_model_config",
+  "model_access_denied"
+]);
+var INVALID_API_KEY_CONTEXT = new Set(["invalid", "incorrect"]);
+var AUTH_CONTEXT = new Set([
+  "token",
+  "credential",
+  "credentials",
+  "required",
+  "expired",
+  "invalid",
+  "missing",
+  "unauthorized",
+  "login",
+  "signin"
+]);
+var MODEL_PROVIDER_CONTEXT = new Set(["unavailable", "overloaded", "temporarily", "service"]);
+var PROVIDER_CONTEXT = new Set(["error", "failure", "failed", "overloaded", "unavailable", "temporarily", "service"]);
+var STATUS_MESSAGE_REFINEMENT_CODES = new Set([
+  "invalid_api_key",
+  "missing_api_key",
+  "unknown_model",
+  "forbidden_config"
+]);
+var BROAD_AUTH_MESSAGE_REFINEMENT_CODES = new Set([
+  "invalid_api_key",
+  "missing_api_key"
+]);
+var STATUS_RELATED_MESSAGE_REFINEMENT_CODES = new Set([
+  "invalid_api_key",
+  "missing_api_key",
+  "unknown_model",
+  "forbidden_config",
+  "rate_limited",
+  "quota_limited",
+  "cancelled"
+]);
+// dist/builtin/workflows/src/durable/dbos-process-owner.ts
+var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
+function emptyOwner() {
+  return {
+    version: 1,
+    state: "uninitialized",
+    configured: undefined,
+    active: undefined,
+    launchPromise: undefined,
+    shutdownPromise: undefined,
+    failure: undefined,
+    wrappers: undefined
+  };
+}
+function ownerBag() {
+  return globalThis;
+}
+function getDbosProcessOwner() {
+  const bag = ownerBag();
+  const existing = bag[DBOS_PROCESS_OWNER_KEY];
+  if (existing !== undefined && existing.version === 1)
+    return existing;
+  const created = emptyOwner();
+  bag[DBOS_PROCESS_OWNER_KEY] = created;
+  return created;
+}
+
+// dist/builtin/workflows/src/durable/dbos-sdk-handle.ts
+var ATOMIC_EXECUTOR_ID = `atomic-${process.pid.toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
+
+// dist/builtin/workflows/src/durable/dbos-embedded-postgres-root.ts
+var HASH_CHUNK_BYTES = 64 * 1024;
+
+// dist/builtin/workflows/src/durable/dbos-embedded-postgres.ts
+var EMBEDDED_HOST = "127.0.0.1";
+var EMBEDDED_PORT = 5439;
+var EMBEDDED_USER = "postgres";
+var EMBEDDED_PASSWORD = "atomic";
+var EMBEDDED_DBOS_SYSTEM_DATABASE_URL = `postgresql://${EMBEDDED_USER}:${EMBEDDED_PASSWORD}@${EMBEDDED_HOST}:${EMBEDDED_PORT}/atomic_workflows_dbos_sys?connect_timeout=10&sslmode=disable`;
+
+// dist/builtin/workflows/src/durable/dbos-lifecycle.ts
+class DbosDurabilityError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DbosDurabilityError";
+  }
+}
+
+class DbosNotReadyError extends DbosDurabilityError {
+  constructor() {
+    super("DBOS workflow durability is not ready. Await initializeDurableBackend() before accessing workflows.");
+    this.name = "DbosNotReadyError";
+  }
+}
+function owner() {
+  return getDbosProcessOwner();
+}
+function getReadyDbosBackendSync() {
+  const slot = owner();
+  return slot.state === "ready" ? slot.active?.backend : undefined;
+}
+function dbosLifecycleState() {
+  return owner().state;
+}
+
+// dist/builtin/workflows/src/durable/factory.ts
+var injectedBackend;
+var initializedBackend;
+function isMemoizedBackendUsable(backend) {
+  return !backend.persistent || dbosLifecycleState() === "ready";
+}
+function getDurableBackend() {
+  const memoized = initializedBackend !== undefined && isMemoizedBackendUsable(initializedBackend) ? initializedBackend : undefined;
+  const backend = injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  if (backend === undefined)
+    throw new DbosNotReadyError;
+  return backend;
+}
+
+// dist/builtin/workflows/src/shared/pending-stage-delivery.ts
+var PENDING_STAGE_MESSAGE_LIMIT = 50;
+var PENDING_STAGE_UNDELIVERABLE_NOTIFICATION_PREFIX = "atomic-pending-stage-undeliverable";
+function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity) {
+  if (normalizeDeliveryGroup(senderGroup) !== normalizeDeliveryGroup(runGroup)) {
+    return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.stageKey };
+  }
+  const messageId = input.message.id;
+  const queued = pendingStageMessagesFor(messages, input.runId, input.stageKey, stageIdentity);
+  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  if (existing !== undefined) {
+    if (pendingStageMessageSignature(existing, stageIdentity) !== pendingStageMessageSignature(input, stageIdentity)) {
+      return {
+        ok: false,
+        reason: "message_id_conflict",
+        runId: input.runId,
+        stageKey: input.stageKey,
+        messageId
+      };
+    }
+    const queuedPosition = queued.indexOf(existing);
+    return {
+      ok: true,
+      messages,
+      entry: existing,
+      ...queuedPosition >= 0 ? { position: queuedPosition + 1 } : {},
+      deduplicated: true
+    };
+  }
+  if (queued.length >= PENDING_STAGE_MESSAGE_LIMIT) {
+    return {
+      ok: false,
+      reason: "capacity",
+      limit: PENDING_STAGE_MESSAGE_LIMIT,
+      runId: input.runId,
+      stageKey: input.stageKey
+    };
+  }
+  const entry = {
+    ...input,
+    id: messageId,
+    ...stageIdentity !== undefined ? { stageId: stageIdentity.id } : {},
+    ...stageIdentity?.replayKey !== undefined ? { stageReplayKey: stageIdentity.replayKey } : {},
+    admissionOrder: nextAdmissionOrder(messages, input.runId),
+    status: "queued"
+  };
+  return {
+    ok: true,
+    messages: [...messages, entry],
+    entry,
+    position: queued.length + 1,
+    deduplicated: false
+  };
+}
+function pendingStageMessagesFor(messages, runId, stageKey, stageIdentity) {
+  return messages.map((entry, index) => ({ entry, index })).filter(({ entry }) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.status === "queued").sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
+}
+function markPendingStageMessageDelivered(messages, runId, stageKey, messageId, deliveredAt, stageIdentity) {
+  return updateQueuedPendingStageMessage(messages, runId, stageKey, messageId, stageIdentity, (entry) => ({
+    ...entry,
+    status: "delivered",
+    deliveredAt
+  }));
+}
+function markPendingStageMessageUndeliverable(messages, runId, stageKey, messageId, reason, stageIdentity) {
+  return updateQueuedPendingStageMessage(messages, runId, stageKey, messageId, stageIdentity, (entry) => ({
+    ...entry,
+    status: "undeliverable",
+    undeliverableReason: reason,
+    undeliverableNotificationId: pendingStageUndeliverableNotificationId(entry)
+  }));
+}
+function markPendingStageMessageUndeliverableNotified(messages, runId, stageKey, messageId, notificationId, notifiedAt) {
+  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
+  if (index < 0)
+    return messages;
+  const next = [...messages];
+  next[index] = { ...next[index], undeliverableNotifiedAt: notifiedAt };
+  return next;
+}
+function pendingStageUndeliverableNotificationId(entry) {
+  return [
+    PENDING_STAGE_UNDELIVERABLE_NOTIFICATION_PREFIX,
+    encodeURIComponent(entry.runId),
+    encodeURIComponent(entry.stageKey),
+    encodeURIComponent(entry.id)
+  ].join(":");
+}
+function updateQueuedPendingStageMessage(messages, runId, stageKey, messageId, stageIdentity, update) {
+  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.id === messageId && entry.status === "queued");
+  if (index < 0)
+    return messages;
+  const next = [...messages];
+  next[index] = update(next[index]);
+  return next;
+}
+function matchesPendingStage(entry, runId, stageKey, stageIdentity) {
+  if (entry.runId !== runId)
+    return false;
+  if (stageIdentity === undefined)
+    return entry.stageKey === stageKey;
+  return entry.stageId === stageIdentity.id || entry.stageReplayKey !== undefined && entry.stageReplayKey === stageIdentity.replayKey || entry.stageId === undefined && stageIdentity.aliases.includes(entry.stageKey);
+}
+function nextAdmissionOrder(messages, runId) {
+  let greatest = 0;
+  let legacyPosition = 0;
+  for (const entry of messages) {
+    if (entry.runId !== runId)
+      continue;
+    legacyPosition += 1;
+    greatest = Math.max(greatest, entry.admissionOrder ?? legacyPosition);
+  }
+  return greatest + 1;
+}
+function pendingStageMessageSignature(entry, stageIdentity) {
+  const storedTarget = "status" in entry ? entry.stageReplayKey ?? entry.stageId : undefined;
+  const { timestamp: transportTimestamp, ...logicalMessage } = entry.message;
+  return stableJson({
+    target: storedTarget ?? stageIdentity?.replayKey ?? stageIdentity?.id ?? entry.stageKey,
+    sender: entry.senderReturnAddress ?? entry.from.id,
+    message: {
+      ...logicalMessage,
+      expectsReply: logicalMessage.expectsReply ?? false,
+      content: {
+        ...logicalMessage.content,
+        attachments: logicalMessage.content.attachments ?? []
+      }
+    }
+  });
+}
+function stableJson(value) {
+  return JSON.stringify(sortJsonValue(value));
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortJsonValue);
+  if (typeof value !== "object" || value === null)
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([, nested]) => nested !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortJsonValue(nested)]));
+}
+function normalizeDeliveryGroup(value) {
+  if (typeof value !== "string")
+    return "default";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "default";
+}
+// dist/builtin/workflows/src/shared/session-scoped-singleton.ts
+var SHARED_STATES_KEY = Symbol.for("atomic-workflows/session-scoped-singleton-pre-adoption@1");
+function processBag() {
+  return globalThis;
+}
+function recordLocal(key, local) {
+  const bag = processBag();
+  let states = bag[SHARED_STATES_KEY];
+  if (states === undefined || states.version !== 1) {
+    states = { version: 1, byKey: new Map };
+    bag[SHARED_STATES_KEY] = states;
+  }
+  const existing = states.byKey.get(key);
+  if (existing !== undefined)
+    return existing;
+  const created = { local, instance: undefined, localClaimed: false };
+  states.byKey.set(key, created);
+  return created;
+}
+function createSessionScopedSingleton(key, createLocal) {
+  const local = createLocal();
+  const shared = recordLocal(key, local);
+  let instance = local;
+  const live = () => shared.instance ?? instance;
+  const current = () => live();
+  const adoptWithResult = (scope, options) => {
+    const current2 = live();
+    let targetCreated = false;
+    const target = sessionScopedExtensionState(scope, key, () => {
+      targetCreated = true;
+      if (shared.localClaimed)
+        return createLocal();
+      shared.localClaimed = true;
+      return shared.local;
+    });
+    const preservedCurrent = !targetCreated && target !== current2 && options?.preserveCurrentWhenTargetExists?.(current2, target) === true;
+    shared.instance = preservedCurrent ? current2 : target;
+    instance = shared.instance;
+    return { instance: shared.instance, preservedCurrent };
+  };
+  const adopt = (scope, options) => adoptWithResult(scope, options).instance;
+  const facade = new Proxy(local, {
+    get(_target, prop) {
+      const value = Reflect.get(live(), prop, live());
+      if (typeof value === "function") {
+        return value.bind(live());
+      }
+      return value;
+    },
+    has(_target, prop) {
+      return Reflect.has(live(), prop);
+    }
+  });
+  return { facade, adopt, adoptWithResult, current };
+}
+
+// dist/builtin/workflows/src/shared/flat-string.ts
+function flattenTruncatedString(value) {
+  return value.split("").join("");
+}
+
+// dist/builtin/workflows/src/shared/tool-payload-bounds.ts
+var TOOL_PAYLOAD_MAX_KEYS = 2048;
+var TOOL_PAYLOAD_VALUE_LIMIT = 16384;
+var TOOL_PAYLOAD_TRUNCATION_MARKER = "… [truncated]";
+var TOOL_PAYLOAD_CYCLE_PLACEHOLDER = "<cycle>";
+var TOOL_PAYLOAD_UNREADABLE_PLACEHOLDER = "<unreadable>";
+var TOOL_PAYLOAD_UNSERIALIZABLE_PLACEHOLDER = "<unserializable>";
+var TOOL_PAYLOAD_TRUNCATION_KEY = "…";
+var TOOL_PAYLOAD_MAX_DEPTH = 256;
+function isOmittedJsonValue(value) {
+  return value === undefined || typeof value === "function" || typeof value === "symbol";
+}
+function isToolPayloadObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isToolPayloadArray(value) {
+  return Array.isArray(value);
+}
+function isToolPayloadObjectLike(value) {
+  return value !== null && typeof value === "object";
+}
+function isToolPayloadCallable(value) {
+  return typeof value === "function";
+}
+function readToolPayloadProperty(value, key) {
+  try {
+    const property = Reflect.get(value, key);
+    return { ok: true, value: property };
+  } catch {
+    return { ok: false };
+  }
+}
+function safeProperty(value, key) {
+  const result = readToolPayloadProperty(value, key);
+  return result.ok ? result.value : TOOL_PAYLOAD_UNREADABLE_PLACEHOLDER;
+}
+function safeOwnKeys(value, consumeKey) {
+  let stopped = false;
+  function* enumerate() {
+    let keys;
+    try {
+      keys = Reflect.ownKeys(value);
+    } catch {
+      return;
+    }
+    for (const key of keys) {
+      if (!consumeKey()) {
+        stopped = true;
+        return;
+      }
+      if (typeof key !== "string")
+        continue;
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(value, key);
+      } catch {
+        continue;
+      }
+      if (descriptor?.enumerable === true)
+        yield key;
+    }
+  }
+  return { keys: enumerate(), stoppedByLimit: () => stopped };
+}
+function safeArrayLength(value) {
+  const result = readToolPayloadProperty(value, "length");
+  if (!result.ok || typeof result.value !== "number")
+    return 0;
+  return Number.isSafeInteger(result.value) && result.value > 0 ? result.value : 0;
+}
+function resolveJsonValue(value) {
+  if (!isToolPayloadObjectLike(value))
+    return value;
+  const toJson = readToolPayloadProperty(value, "toJSON");
+  if (!toJson.ok)
+    return TOOL_PAYLOAD_UNREADABLE_PLACEHOLDER;
+  if (!isToolPayloadCallable(toJson.value))
+    return value;
+  try {
+    return toJson.value.call(value);
+  } catch {
+    return TOOL_PAYLOAD_UNSERIALIZABLE_PLACEHOLDER;
+  }
+}
+var NULL_COST = 4;
+var NUMBER_COST = 8;
+var BOOLEAN_COST = 5;
+var CONTAINER_COST = 2;
+var SEPARATOR_COST = 1;
+function consumeKeyBudget(state) {
+  if (state.keysRemaining <= 0)
+    return false;
+  state.keysRemaining -= 1;
+  return true;
+}
+function addTruncationMarker(record) {
+  let key = TOOL_PAYLOAD_TRUNCATION_KEY;
+  let suffix = 1;
+  while (Object.hasOwn(record, key))
+    key = `${TOOL_PAYLOAD_TRUNCATION_KEY}${suffix++}`;
+  record[key] = TOOL_PAYLOAD_TRUNCATION_MARKER;
+}
+function cloneObjectLike(state, value) {
+  if (state.seen.has(value))
+    return TOOL_PAYLOAD_CYCLE_PLACEHOLDER;
+  if (state.depth >= TOOL_PAYLOAD_MAX_DEPTH)
+    return TOOL_PAYLOAD_TRUNCATION_MARKER;
+  state.seen.add(value);
+  state.depth += 1;
+  state.remaining -= CONTAINER_COST;
+  try {
+    if (isToolPayloadArray(value)) {
+      const items = [];
+      const length = safeArrayLength(value);
+      for (let index = 0;index < length; index++) {
+        if (state.remaining <= 0) {
+          items.push(TOOL_PAYLOAD_TRUNCATION_MARKER);
+          break;
+        }
+        state.remaining -= SEPARATOR_COST;
+        const item = safeProperty(value, index);
+        if (isOmittedJsonValue(item)) {
+          state.remaining -= NULL_COST;
+          items.push(null);
+          continue;
+        }
+        items.push(cloneValue(state, item));
+      }
+      return items;
+    }
+    const cloned = {};
+    const scan = safeOwnKeys(value, () => state.remaining > 0 && consumeKeyBudget(state));
+    for (const key of scan.keys) {
+      state.remaining -= key.length + SEPARATOR_COST;
+      const child = safeProperty(value, key);
+      if (isOmittedJsonValue(child))
+        continue;
+      cloned[key] = cloneValue(state, child);
+    }
+    if (scan.stoppedByLimit())
+      addTruncationMarker(cloned);
+    return cloned;
+  } finally {
+    state.depth -= 1;
+    state.seen.delete(value);
+  }
+}
+function cloneValue(state, value) {
+  const resolved = resolveJsonValue(value);
+  if (resolved === null) {
+    state.remaining -= NULL_COST;
+    return null;
+  }
+  switch (typeof resolved) {
+    case "string":
+      return cloneString(state, resolved);
+    case "number":
+      state.remaining -= NUMBER_COST;
+      return Number.isFinite(resolved) ? resolved : null;
+    case "boolean":
+      state.remaining -= BOOLEAN_COST;
+      return resolved;
+    case "object":
+      return cloneObjectLike(state, resolved);
+    case "bigint":
+      state.remaining -= NUMBER_COST;
+      return resolved;
+    default:
+      state.remaining -= TOOL_PAYLOAD_UNSERIALIZABLE_PLACEHOLDER.length;
+      return TOOL_PAYLOAD_UNSERIALIZABLE_PLACEHOLDER;
+  }
+}
+function boundedToolPayload(value, limit = TOOL_PAYLOAD_VALUE_LIMIT) {
+  return cloneValue({ remaining: Math.max(1, limit), depth: 0, keysRemaining: TOOL_PAYLOAD_MAX_KEYS, seen: new Set }, value);
+}
+function boundedToolPayloadRecord(value, limit = TOOL_PAYLOAD_VALUE_LIMIT) {
+  const record = {};
+  if (!isToolPayloadObject(value) && !isToolPayloadArray(value))
+    return record;
+  const state = {
+    remaining: Math.max(1, limit),
+    depth: 0,
+    keysRemaining: TOOL_PAYLOAD_MAX_KEYS,
+    seen: new Set([value])
+  };
+  const scan = safeOwnKeys(value, () => state.remaining > 0 && consumeKeyBudget(state));
+  for (const key of scan.keys) {
+    state.remaining -= key.length + SEPARATOR_COST;
+    const child = safeProperty(value, key);
+    if (isOmittedJsonValue(child))
+      continue;
+    record[key] = cloneValue(state, child);
+  }
+  if (scan.stoppedByLimit())
+    addTruncationMarker(record);
+  return record;
+}
+function cloneString(state, value) {
+  if (state.remaining <= 0)
+    return TOOL_PAYLOAD_TRUNCATION_MARKER;
+  if (value.length <= state.remaining) {
+    state.remaining -= value.length;
+    return value;
+  }
+  const keep = state.remaining;
+  state.remaining = 0;
+  return `${flattenTruncatedString(value.slice(0, keep))}${TOOL_PAYLOAD_TRUNCATION_MARKER}`;
+}
+function boundedToolText(value, limit = TOOL_PAYLOAD_VALUE_LIMIT) {
+  const cap = Math.max(TOOL_PAYLOAD_TRUNCATION_MARKER.length + 1, limit);
+  if (value.length <= cap)
+    return value;
+  const keep = Math.max(0, cap - TOOL_PAYLOAD_TRUNCATION_MARKER.length);
+  return `${flattenTruncatedString(value.slice(0, keep))}${TOOL_PAYLOAD_TRUNCATION_MARKER}`;
+}
+
+// dist/builtin/workflows/src/shared/graph-store-snapshot.ts
+var COMPACT_RESULT_FIELD_LIMIT = 1024;
+var COMPACT_EXIT_OUTPUT_LIMIT = COMPACT_RESULT_FIELD_LIMIT * 4;
+function compactResultField(value) {
+  if (typeof value !== "string")
+    return;
+  if (value.length <= COMPACT_RESULT_FIELD_LIMIT)
+    return value;
+  return flattenTruncatedString(value.slice(0, COMPACT_RESULT_FIELD_LIMIT));
+}
+function compactRunResult(result, preserveExitedOutputs = false) {
+  if (result === undefined)
+    return;
+  const status = compactResultField(result.status);
+  const summary = compactResultField(result.summary);
+  const remainingWork = compactResultField(result.remaining_work);
+  const resultText = compactResultField(result.result);
+  const budgetDimension = status === "budget_exceeded" && (result.dimension === "duration" || result.dimension === "tokens" || result.dimension === "cost") ? result.dimension : undefined;
+  const compact = {
+    ...status !== undefined ? { status } : {},
+    ...summary !== undefined ? { summary } : {},
+    ...remainingWork !== undefined ? { remaining_work: remainingWork } : {},
+    ...resultText !== undefined ? { result: resultText } : {},
+    ...budgetDimension !== undefined ? { dimension: budgetDimension } : {}
+  };
+  if (!preserveExitedOutputs)
+    return Object.keys(compact).length === 0 ? undefined : compact;
+  return compactExitedOutputs(result, compact);
+}
+function compactExitedOutputs(result, compact) {
+  try {
+    const serialized = JSON.stringify(result);
+    if (serialized !== undefined && serialized.length <= COMPACT_EXIT_OUTPUT_LIMIT) {
+      const parsed = JSON.parse(serialized);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return compactExitedObject(parsed);
+      }
+    }
+  } catch {}
+  return Object.keys(compact).length === 0 ? undefined : compact;
+}
+function compactExitedObject(result) {
+  const compacted = { ...result };
+  for (const key of ["status", "summary", "remaining_work", "result"]) {
+    const value = compacted[key];
+    if (typeof value === "string")
+      compacted[key] = compactResultField(value) ?? "";
+  }
+  return Object.keys(compacted).length === 0 ? undefined : compacted;
+}
+function clonePrompt(prompt) {
+  return {
+    ...prompt,
+    ...prompt.choices !== undefined ? { choices: [...prompt.choices] } : {}
+  };
+}
+function cloneInputRequest(request) {
+  return {
+    ...request,
+    questions: request.questions.map((question) => ({
+      ...question,
+      options: question.options.map((option) => ({ ...option }))
+    }))
+  };
+}
+function compactToolEvents(events) {
+  const event = events.at(-1);
+  return event === undefined ? [] : [{ name: event.name }];
+}
+function compactWorkflowChild(child) {
+  return {
+    ...child,
+    outputs: {},
+    outputCount: child.outputCount ?? Object.keys(child.outputs).length
+  };
+}
+function compactStage(stage) {
+  const {
+    toolEvents,
+    workflowChild,
+    workflowChildRun,
+    pendingPrompt,
+    promptFootprint,
+    inputRequest,
+    notices,
+    mcpScope: _mcpScope,
+    pendingStageDeliveryAvailable: _pendingStageDeliveryAvailable,
+    attemptedModels: _attemptedModels,
+    modelAttempts: _modelAttempts,
+    result: _result,
+    ...metadata
+  } = stage;
+  return {
+    ...metadata,
+    parentIds: [...stage.parentIds],
+    toolEvents: compactToolEvents(toolEvents),
+    ...workflowChild !== undefined ? { workflowChild: compactWorkflowChild(workflowChild) } : {},
+    ...workflowChildRun !== undefined ? { workflowChildRun: { ...workflowChildRun } } : {},
+    ...pendingPrompt !== undefined ? { pendingPrompt: clonePrompt(pendingPrompt) } : {},
+    ...promptFootprint !== undefined ? { promptFootprint: clonePrompt(promptFootprint) } : {},
+    ...inputRequest !== undefined ? { inputRequest: cloneInputRequest(inputRequest) } : {},
+    ...notices !== undefined ? { notices: notices.map((notice) => ({ ...notice })) } : {}
+  };
+}
+function compactToolNode(node) {
+  return {
+    ...node,
+    parentIds: [...node.parentIds],
+    ...node.args !== undefined ? { args: boundedToolPayloadRecord(node.args) } : {},
+    ...node.result !== undefined ? { result: boundedToolPayload(node.result) } : {},
+    ...node.source !== undefined ? { source: boundedToolText(node.source) } : {}
+  };
+}
+function compactRun(run) {
+  const { inputs: _inputs, result: sourceResult, stages, toolNodes, pendingPrompt, ...metadata } = run;
+  const result = compactRunResult(sourceResult, run.exited === true && run.status === "failed");
+  return {
+    ...metadata,
+    inputs: {},
+    stages: stages.map(compactStage),
+    ...toolNodes !== undefined ? { toolNodes: toolNodes.map(compactToolNode) } : {},
+    ...pendingPrompt !== undefined ? { pendingPrompt: clonePrompt(pendingPrompt) } : {},
+    ...result !== undefined ? { result } : {}
+  };
+}
+function createGraphStoreSnapshot(runs, notices, version) {
+  const snapshot = {
+    runs: runs.map(compactRun),
+    notices: notices.map((notice) => ({ ...notice })),
+    version
+  };
+  deepFreezeGraphValue(snapshot);
+  return snapshot;
+}
+function deepFreezeGraphValue(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value))
+    return;
+  Object.freeze(value);
+  if (Array.isArray(value)) {
+    for (const item of value)
+      deepFreezeGraphValue(item);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    deepFreezeGraphValue(value[key]);
+  }
+}
+
+// dist/builtin/workflows/src/shared/store-internal.ts
+var TERMINAL_STATUSES = new Set([
+  "completed",
+  "failed",
+  "killed",
+  "skipped",
+  "cancelled",
+  "blocked"
+]);
+function isTerminalStageStatus(status) {
+  return status === "completed" || status === "failed" || status === "skipped";
+}
+function cannotAwaitInput(status) {
+  return isTerminalStageStatus(status) || status === "paused" || status === "blocked";
+}
+function cannotBlock(status) {
+  return isTerminalStageStatus(status) || status === "paused";
+}
+function cannotPause(status) {
+  return isTerminalStageStatus(status) || status === "paused" || status === "blocked";
+}
+function clearRunFailureMetadata(run) {
+  delete run.error;
+  delete run.failureKind;
+  delete run.failureCode;
+  delete run.failureRecoverability;
+  delete run.failureDisposition;
+  delete run.failureMessage;
+  delete run.failedStageId;
+  delete run.failedToolNodeId;
+  delete run.resumable;
+  delete run.retryAfterMs;
+  delete run.blockedAt;
+  delete run.exited;
+  delete run.exitReason;
+}
+function clearStaleBlockedRunMetadata(run, metadata) {
+  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?.failedToolNodeId === undefined)
+    delete run.failedToolNodeId;
+  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;
+}
+function applyRunEndMetadata(run, metadata) {
+  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.failedToolNodeId !== undefined)
+    run.failedToolNodeId = metadata.failedToolNodeId;
+  if (metadata.resumable !== undefined)
+    run.resumable = metadata.resumable;
+  if (metadata.exited !== undefined)
+    run.exited = metadata.exited;
+  if (metadata.exitReason !== undefined)
+    run.exitReason = metadata.exitReason;
+}
+function createStoreState() {
+  return {
+    runs: [],
+    notices: [],
+    listeners: new Set,
+    invalidationListeners: new Set,
+    resolvers: new Map,
+    stagePromptAnswers: new Map,
+    stagePromptDrafts: new Map,
+    version: 0
+  };
+}
+function createStoreContext(state = createStoreState()) {
+  let cachedGraphVersion = -1;
+  let cachedGraphSnapshot;
+  function snapshot() {
+    return JSON.parse(JSON.stringify({ runs: state.runs, notices: state.notices, version: state.version }));
+  }
+  function graphSnapshot() {
+    if (cachedGraphSnapshot === undefined || cachedGraphVersion !== state.version) {
+      cachedGraphSnapshot = createGraphStoreSnapshot(state.runs, state.notices, state.version);
+      cachedGraphVersion = state.version;
+    }
+    return cachedGraphSnapshot;
+  }
+  function notify() {
+    for (const fn of state.invalidationListeners) {
+      try {
+        fn();
+      } catch {}
+    }
+    if (state.listeners.size > 0) {
+      const snap = snapshot();
+      for (const fn of state.listeners) {
+        try {
+          fn(snap);
+        } catch {}
+      }
+    }
+  }
+  function bumpAndNotify() {
+    state.version++;
+    notify();
+  }
+  function findRun(runId) {
+    return state.runs.find((r) => r.id === runId);
+  }
+  function findStage(run, stageId) {
+    return run.stages.find((s) => s.id === stageId);
+  }
+  function rejectPrompt(promptId, reason) {
+    const entry = state.resolvers.get(promptId);
+    if (!entry)
+      return;
+    state.resolvers.delete(promptId);
+    entry.reject(new Error(reason));
+  }
+  function stagePromptAnswerKey(runId, stageId) {
+    return JSON.stringify([runId, stageId]);
+  }
+  function stagePromptDraftKey(runId, stageId, promptId) {
+    return JSON.stringify([runId, stageId, promptId]);
+  }
+  function stageHasActiveTextPrompt(runId, stageId, promptId) {
+    const run = findRun(runId);
+    if (!run || TERMINAL_STATUSES.has(run.status))
+      return;
+    const stage = findStage(run, stageId);
+    if (!stage || isTerminalStageStatus(stage.status))
+      return;
+    const prompt = stage.pendingPrompt;
+    if (!prompt || prompt.id !== promptId)
+      return;
+    if (prompt.kind !== "input" && prompt.kind !== "editor")
+      return;
+    return { prompt };
+  }
+  function rejectStagePrompt(runId, stage, reason) {
+    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, run, reason) {
+    for (const stage of run.stages) {
+      rejectStagePrompt(runId, stage, reason);
+    }
+  }
+  return {
+    state,
+    snapshot,
+    graphSnapshot,
+    notify,
+    bumpAndNotify,
+    findRun,
+    findStage,
+    rejectPrompt,
+    rejectStagePrompt,
+    rejectAllStagePrompts,
+    stagePromptAnswerKey,
+    stagePromptDraftKey,
+    stageHasActiveTextPrompt
+  };
+}
+
+// dist/builtin/workflows/src/shared/store-pending-stage-delivery-methods.ts
+function createPendingStageDeliveryStoreMethods(context) {
+  const transitions = new Map;
+  const serialize = async (runId, transition) => {
+    const previous = transitions.get(runId) ?? Promise.resolve();
+    const result = previous.catch(() => {
+      return;
+    }).then(transition);
+    const settled = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    transitions.set(runId, settled);
+    settled.finally(() => {
+      if (transitions.get(runId) === settled)
+        transitions.delete(runId);
+    });
+    return await result;
+  };
+  return {
+    async queueStageMessage(input, senderGroup, runGroup, backend) {
+      return await serialize(input.runId, async () => {
+        const run = context.findRun(input.runId);
+        if (run === undefined)
+          return;
+        const stageIdentity = resolvePendingStageIdentity(run, input.stageKey);
+        const result = queueStageMessage(run.pendingStageMessages ?? [], input, senderGroup, runGroup, stageIdentity);
+        if (result.ok && !result.deduplicated) {
+          await persistTransition(backend, input.runId, result.messages);
+          run.pendingStageMessages = [...result.messages];
+          context.bumpAndNotify();
+        }
+        return result;
+      });
+    },
+    async validateLiveStageMessage(input) {
+      return await serialize(input.runId, async () => {
+        const run = context.findRun(input.runId);
+        if (run === undefined)
+          return;
+        const result = queueStageMessage(run.pendingStageMessages ?? [], input, undefined, undefined, resolvePendingStageIdentity(run, input.stageKey));
+        if (!result.ok) {
+          return result.reason === "message_id_conflict" ? { outcome: "message_id_conflict", messageId: result.messageId } : { outcome: "forward" };
+        }
+        if (!result.deduplicated)
+          return { outcome: "forward" };
+        if (result.entry.status === "delivered")
+          return { outcome: "delivered" };
+        if (result.entry.status === "undeliverable") {
+          return { outcome: "undeliverable", reason: result.entry.undeliverableReason };
+        }
+        if (result.position === undefined) {
+          throw new Error(`atomic-workflows: queued message ${input.message.id} has no active position`);
+        }
+        return { outcome: "queued", position: result.position };
+      });
+    },
+    pendingStageMessagesFor(runId, stageKey) {
+      const run = context.findRun(runId);
+      return pendingStageMessagesFor(run?.pendingStageMessages ?? [], runId, stageKey, run === undefined ? undefined : resolvePendingStageIdentity(run, stageKey));
+    },
+    async markPendingStageMessageDelivered(runId, stageKey, messageId, deliveredAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageDelivered(current, runId, stageKey, messageId, deliveredAt, resolvePendingStageIdentity(run, stageKey));
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async markPendingStageMessageUndeliverable(runId, stageKey, messageId, reason, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageUndeliverable(current, runId, stageKey, messageId, reason, resolvePendingStageIdentity(run, stageKey));
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async markPendingStageMessageUndeliverableNotified(runId, stageKey, messageId, notificationId, notifiedAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageUndeliverableNotified(current, runId, stageKey, messageId, notificationId, notifiedAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    }
+  };
+}
+function resolvePendingStageIdentity(run, stageKey) {
+  const exactIds = run.stages.filter((stage2) => stage2.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage2) => stage2.name === stageKey);
+  if (candidates.length !== 1)
+    return;
+  const stage = candidates[0];
+  return {
+    id: stage.id,
+    ...stage.replayKey !== undefined ? { replayKey: stage.replayKey } : {},
+    aliases: stage.id === stage.name ? [stage.id] : [stage.id, stage.name]
+  };
+}
+async function persistTransition(backend, runId, messages) {
+  if (!await backend.persistPendingStageMessages(runId, messages)) {
+    throw new Error(`atomic-workflows: durable workflow ${runId} is unavailable for pending-stage persistence`);
+  }
+}
+
+// dist/builtin/workflows/src/shared/store-prompt-methods.ts
+function createPromptStoreMethods(context) {
+  const { state } = context;
+  return {
+    recordPendingPrompt(runId, prompt) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      if (run.pendingPrompt !== undefined)
+        return false;
+      run.pendingPrompt = { ...prompt };
+      context.bumpAndNotify();
+      return true;
+    },
+    resolvePendingPrompt(runId, promptId, response) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const pending = run.pendingPrompt;
+      if (!pending || pending.id !== promptId)
+        return false;
+      run.pendingPrompt = undefined;
+      context.bumpAndNotify();
+      const entry = state.resolvers.get(promptId);
+      if (entry) {
+        state.resolvers.delete(promptId);
+        entry.resolve(response);
+      }
+      return true;
+    },
+    awaitPendingPrompt(runId, promptId) {
+      return new Promise((resolve, reject) => {
+        const run = context.findRun(runId);
+        if (!run) {
+          reject(new Error(`atomic-workflows: run "${runId}" not found`));
+          return;
+        }
+        const pending = run.pendingPrompt;
+        if (!pending || pending.id !== promptId) {
+          reject(new Error(`atomic-workflows: pending prompt "${promptId}" not registered on run "${runId}"`));
+          return;
+        }
+        state.resolvers.set(promptId, { promptId, resolve, reject });
+      });
+    },
+    recordStagePendingPrompt(runId, stageId, prompt) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (isTerminalStageStatus(stage.status))
+        return false;
+      if (stage.pendingPrompt !== undefined)
+        return false;
+      stage.pendingPrompt = { ...prompt };
+      stage.promptFootprint = { ...prompt };
+      stage.status = "awaiting_input";
+      stage.awaitingInputSince = prompt.createdAt;
+      context.bumpAndNotify();
+      return true;
+    },
+    resolveStagePendingPrompt(runId, stageId, promptId, response, options = {}) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      const pending = stage.pendingPrompt;
+      if (!pending || pending.id !== promptId)
+        return false;
+      state.stagePromptDrafts.delete(context.stagePromptDraftKey(runId, stageId, promptId));
+      if (options.recordAnswer !== false) {
+        state.stagePromptAnswers.set(context.stagePromptAnswerKey(runId, stageId), {
+          runId,
+          stageId,
+          promptId,
+          kind: pending.kind,
+          value: response,
+          answeredAt: Date.now(),
+          ...options.answerSource !== undefined ? { answerSource: options.answerSource } : {}
+        });
+        stage.promptAnswerState = "available";
+      } else {
+        state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stageId));
+        delete stage.promptAnswerState;
+      }
+      stage.pendingPrompt = undefined;
+      if (stage.status === "awaiting_input") {
+        stage.status = "running";
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      const entry = state.resolvers.get(promptId);
+      if (entry) {
+        state.resolvers.delete(promptId);
+        entry.resolve(response);
+      }
+      return true;
+    },
+    awaitStagePendingPrompt(runId, stageId, promptId) {
+      return new Promise((resolve, reject) => {
+        const run = context.findRun(runId);
+        if (!run) {
+          reject(new Error(`atomic-workflows: run "${runId}" not found`));
+          return;
+        }
+        const stage = context.findStage(run, stageId);
+        if (!stage) {
+          reject(new Error(`atomic-workflows: stage "${stageId}" not found on run "${runId}"`));
+          return;
+        }
+        const pending = stage.pendingPrompt;
+        if (!pending || pending.id !== promptId) {
+          reject(new Error(`atomic-workflows: pending prompt "${promptId}" not registered on stage "${stageId}" in run "${runId}"`));
+          return;
+        }
+        state.resolvers.set(promptId, { promptId, resolve, reject });
+      });
+    },
+    recordStagePromptAnswer(runId, stageId, prompt, response, options = {}) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (isTerminalStageStatus(stage.status))
+        return false;
+      state.stagePromptAnswers.set(context.stagePromptAnswerKey(runId, stageId), {
+        runId,
+        stageId,
+        promptId: prompt.id,
+        kind: prompt.kind,
+        value: response,
+        answeredAt: Date.now(),
+        ...options.answerSource !== undefined ? { answerSource: options.answerSource } : {}
+      });
+      if (stage.promptFootprint === undefined)
+        stage.promptFootprint = { ...prompt };
+      stage.promptAnswerState = "available";
+      if (stage.status === "awaiting_input") {
+        stage.status = "running";
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStagePromptDraft(runId, stageId, promptId, text) {
+      if (context.stageHasActiveTextPrompt(runId, stageId, promptId) === undefined)
+        return false;
+      state.stagePromptDrafts.set(context.stagePromptDraftKey(runId, stageId, promptId), text);
+      return true;
+    },
+    getStagePromptDraft(runId, stageId, promptId) {
+      if (context.stageHasActiveTextPrompt(runId, stageId, promptId) === undefined)
+        return;
+      return state.stagePromptDrafts.get(context.stagePromptDraftKey(runId, stageId, promptId));
+    },
+    clearStagePromptDraft(runId, stageId, promptId) {
+      return state.stagePromptDrafts.delete(context.stagePromptDraftKey(runId, stageId, promptId));
+    },
+    getStagePromptAnswer(runId, stageId) {
+      return state.stagePromptAnswers.get(context.stagePromptAnswerKey(runId, stageId));
+    },
+    clearStagePromptAnswer(runId, stageId) {
+      const removed = state.stagePromptAnswers.delete(context.stagePromptAnswerKey(runId, stageId));
+      const run = context.findRun(runId);
+      const stage = run ? context.findStage(run, stageId) : undefined;
+      const clearAvailabilityMarker = stage?.promptAnswerState === "available";
+      if (clearAvailabilityMarker) {
+        delete stage.promptAnswerState;
+      }
+      if (removed || clearAvailabilityMarker) {
+        context.bumpAndNotify();
+      }
+    }
+  };
+}
+
+// dist/builtin/workflows/src/shared/run-visibility.ts
+function isTopLevelWorkflowRun(run) {
+  return run.parentRunId === undefined;
+}
+
+// dist/builtin/workflows/src/shared/timing.ts
+function nonNegative(ms) {
+  return Math.max(0, ms);
+}
+function nextControlTimestamp(requestedAt, previousAt) {
+  const candidate = requestedAt ?? Date.now();
+  return previousAt === undefined || candidate > previousAt ? candidate : previousAt + 1;
+}
+function elapsedFromStart(startedAt, now, pausedDurationMs, pausedAt) {
+  const completedPausedSegment = pausedDurationMs ?? 0;
+  const activePausedSegment = pausedAt === undefined ? 0 : nonNegative(now - pausedAt);
+  return nonNegative(now - startedAt - completedPausedSegment - activePausedSegment);
+}
+function accumulatePausedDurationMs(pausedDurationMs, pausedAt, resumedAt) {
+  if (pausedAt === undefined)
+    return pausedDurationMs ?? 0;
+  return (pausedDurationMs ?? 0) + nonNegative(resumedAt - pausedAt);
+}
+function elapsedRunMs(run, now = Date.now()) {
+  if (run.durationMs !== undefined)
+    return nonNegative(run.durationMs);
+  const effectiveNow = run.endedAt ?? now;
+  return nonNegative(run.accumulatedDurationMs ?? 0) + elapsedFromStart(run.startedAt, effectiveNow, run.pausedDurationMs, run.pausedAt);
+}
+
+// dist/builtin/workflows/src/shared/store-run-methods.ts
+function createRunStoreMethods(context) {
+  const { state } = context;
+  return {
+    runs() {
+      return state.runs;
+    },
+    notices() {
+      return state.notices;
+    },
+    activeRunId() {
+      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;
+        }
+      }
+      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) {
+      state.runs.push(run);
+      context.bumpAndNotify();
+    },
+    reconcileRunParentStage(runId, expectedParentStageId, parentStageId) {
+      const run = context.findRun(runId);
+      if (run?.parentStageId !== expectedParentStageId || parentStageId === expectedParentStageId)
+        return false;
+      run.parentStageId = parentStageId;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordRunEnd(runId, status, result, error, metadata) {
+      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, error, metadata) {
+      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;
+    },
+    restoreActiveBlockedRun(source, error, metadata) {
+      const restored = {
+        ...source,
+        status: "running",
+        error,
+        resumable: metadata.resumable,
+        failureRecoverability: metadata.failureRecoverability,
+        failureDisposition: metadata.failureDisposition,
+        blockedAt: metadata.blockedAt ?? Date.now(),
+        stages: source.stages.map((stage) => ({ ...stage })),
+        toolNodes: source.toolNodes?.map((node) => ({ ...node }))
+      };
+      delete restored.endedAt;
+      delete restored.durationMs;
+      restored.failureKind = metadata.failureKind;
+      restored.failureCode = metadata.failureCode;
+      restored.failureMessage = metadata.failureMessage;
+      if (metadata.failedStageId === undefined)
+        delete restored.failedStageId;
+      else
+        restored.failedStageId = metadata.failedStageId;
+      if (metadata.retryAfterMs !== undefined)
+        restored.retryAfterMs = metadata.retryAfterMs;
+      if (metadata.result !== undefined)
+        restored.result = metadata.result;
+      if (metadata.budgetState !== undefined)
+        restored.budgetState = metadata.budgetState;
+      const index = state.runs.findIndex((candidate) => candidate.id === source.id);
+      if (index < 0)
+        state.runs.push(restored);
+      else
+        state.runs[index] = restored;
+      context.bumpAndNotify();
+      return true;
+    },
+    removeRun(runId) {
+      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) {
+      state.notices.push(notice);
+      context.bumpAndNotify();
+    },
+    ackNotice(id) {
+      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, pausedAt, metadata) {
+      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);
+      if (metadata?.actor !== undefined)
+        run.pauseActor = metadata.actor;
+      if (wasPaused && metadata === undefined)
+        return false;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordRunResumed(runId, resumedAt, metadata) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      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() {
+      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() {
+      return context.snapshot();
+    },
+    graphSnapshot() {
+      return context.graphSnapshot();
+    },
+    subscribe(fn) {
+      state.listeners.add(fn);
+      return () => {
+        state.listeners.delete(fn);
+      };
+    },
+    subscribeInvalidation(fn) {
+      state.invalidationListeners.add(fn);
+      return () => state.invalidationListeners.delete(fn);
+    }
+  };
+}
+function shouldStoreRunResult(status) {
+  return status === "completed" || status === "skipped" || status === "cancelled" || status === "blocked" || status === "failed";
+}
+
+// dist/builtin/workflows/src/shared/store-tool-node-methods.ts
+function nextExecutionOrder(run) {
+  const stageOrders = run.stages.map((stage) => stage.executionOrder ?? 0);
+  const toolOrders = (run.toolNodes ?? []).map((node) => node.executionOrder ?? 0);
+  return Math.max(0, ...stageOrders, ...toolOrders) + 1;
+}
+function createToolNodeStoreMethods(context) {
+  return {
+    recordToolNodeStart(runId, node) {
+      const run = context.findRun(runId);
+      if (run === undefined || TERMINAL_STATUSES.has(run.status))
+        return false;
+      const mutableRun = run;
+      if (mutableRun.toolNodes === undefined)
+        mutableRun.toolNodes = [];
+      const nodes = mutableRun.toolNodes;
+      if (nodes.some((candidate) => candidate.id === node.id))
+        return false;
+      if (node.executionOrder === undefined)
+        node.executionOrder = nextExecutionOrder(run);
+      nodes.push(node);
+      context.bumpAndNotify();
+      return true;
+    },
+    recordToolNodeRunning(runId, nodeId, startedAt) {
+      const node = context.findRun(runId)?.toolNodes?.find((candidate) => candidate.id === nodeId);
+      if (node === undefined || node.status !== "pending")
+        return false;
+      node.status = "running";
+      node.startedAt = startedAt;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordToolNodeEnd(runId, nodeId, update) {
+      const node = context.findRun(runId)?.toolNodes?.find((candidate) => candidate.id === nodeId);
+      if (node === undefined || node.status === "completed" || node.status === "failed" || node.status === "cached" || node.status === "cancelled")
+        return false;
+      node.status = update.status;
+      if (update.endedAt !== undefined)
+        node.endedAt = update.endedAt;
+      if (update.durationMs !== undefined)
+        node.durationMs = update.durationMs;
+      if (update.result !== undefined)
+        node.result = boundedToolPayload(update.result);
+      if (update.resultSummary !== undefined)
+        node.resultSummary = update.resultSummary;
+      if (update.error !== undefined)
+        node.error = update.error;
+      context.bumpAndNotify();
+      return true;
+    }
+  };
+}
+
+// dist/builtin/workflows/src/shared/store-stage-methods.ts
+function createStageStoreMethods(context) {
+  return {
+    recordStageStart(runId, stage) {
+      const run = context.findRun(runId);
+      if (!run)
+        return;
+      if (stage.executionOrder === undefined)
+        stage.executionOrder = nextExecutionOrder(run);
+      if (!run.stages.some((s) => s.id === stage.id)) {
+        run.stages.push(stage);
+      }
+      context.bumpAndNotify();
+    },
+    recordStageWorkflowChildRun(runId, stageId, ref) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (stage.workflowChildRun?.runId === ref.runId && stage.workflowChildRun.alias === ref.alias && stage.workflowChildRun.workflow === ref.workflow)
+        return false;
+      stage.workflowChildRun = { ...ref };
+      context.bumpAndNotify();
+      return true;
+    },
+    recordToolStart(runId, stageId, evt) {
+      const run = context.findRun(runId);
+      if (!run)
+        return;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return;
+      const exists = stage.toolEvents.some((e) => e.name === evt.name && e.startedAt === evt.startedAt);
+      if (!exists) {
+        stage.toolEvents.push(evt);
+      }
+      context.bumpAndNotify();
+    },
+    recordToolEnd(runId, stageId, evt) {
+      const run = context.findRun(runId);
+      if (!run)
+        return;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return;
+      const existing = stage.toolEvents.find((e) => e.name === evt.name && e.startedAt === evt.startedAt);
+      if (existing) {
+        existing.endedAt = evt.endedAt;
+        existing.output = evt.output;
+      }
+      context.bumpAndNotify();
+    },
+    recordStageEnd(runId, stage) {
+      const run = context.findRun(runId);
+      if (!run)
+        return;
+      const existing = context.findStage(run, stage.id);
+      if (!existing)
+        return;
+      existing.status = stage.status;
+      existing.endedAt = stage.endedAt;
+      if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
+        existing.pausedDurationMs = accumulatePausedDurationMs(existing.pausedDurationMs, existing.pausedAt, existing.endedAt);
+        existing.pausedAt = undefined;
+      }
+      existing.durationMs = stage.durationMs;
+      existing.result = stage.result;
+      existing.error = stage.error;
+      if (stage.sessionId !== undefined)
+        existing.sessionId = stage.sessionId;
+      if (stage.sessionFile !== undefined)
+        existing.sessionFile = stage.sessionFile;
+      if (stage.modelAttempts !== undefined)
+        existing.modelAttempts = stage.modelAttempts;
+      existing.failureKind = stage.failureKind;
+      existing.failureCode = stage.failureCode;
+      existing.failureRecoverability = stage.failureRecoverability;
+      existing.failureDisposition = stage.failureDisposition;
+      existing.retryAfterMs = stage.retryAfterMs;
+      existing.failureMessage = stage.failureMessage;
+      existing.skippedReason = stage.skippedReason;
+      if (stage.replayKey !== undefined)
+        existing.replayKey = stage.replayKey;
+      if (stage.promptAnswerState !== undefined)
+        existing.promptAnswerState = stage.promptAnswerState;
+      if (stage.replayedFromStageId !== undefined)
+        existing.replayedFromStageId = stage.replayedFromStageId;
+      if (stage.replayed !== undefined)
+        existing.replayed = stage.replayed;
+      if (stage.status === "completed") {
+        if (stage.workflowChildRun !== undefined)
+          existing.workflowChildRun = { ...stage.workflowChildRun };
+        if (stage.workflowChild !== undefined)
+          existing.workflowChild = structuredClone(stage.workflowChild);
+      } else {
+        delete existing.workflowChildRun;
+        delete existing.workflowChild;
+      }
+      delete existing.awaitingInputSince;
+      delete existing.inputRequest;
+      context.rejectStagePrompt(runId, existing, `atomic-workflows: stage ${stage.id} ended before prompt resolved`);
+      context.bumpAndNotify();
+    },
+    recordStageSession(runId, stageId, session) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      let changed = false;
+      if (session.sessionId !== undefined && stage.sessionId !== session.sessionId) {
+        stage.sessionId = session.sessionId;
+        changed = true;
+      }
+      if (session.sessionFile !== undefined && stage.sessionFile !== session.sessionFile) {
+        stage.sessionFile = session.sessionFile;
+        changed = true;
+      }
+      if (!changed)
+        return false;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageAttachable(runId, stageId, attachable) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      const next = attachable === true ? true : undefined;
+      if (stage.attachable === next)
+        return false;
+      if (next === undefined) {
+        delete stage.attachable;
+      } else {
+        stage.attachable = next;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageAttached(runId, stageId, attached) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      const next = attached === true ? true : undefined;
+      if (stage.attached === next)
+        return false;
+      if (next === undefined) {
+        delete stage.attached;
+      } else {
+        stage.attached = next;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageAwaitingInput(runId, stageId, awaiting, ts) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (cannotAwaitInput(stage.status))
+        return false;
+      if (awaiting) {
+        if (stage.status === "awaiting_input")
+          return false;
+        stage.status = "awaiting_input";
+        stage.awaitingInputSince = ts ?? Date.now();
+      } else {
+        if (stage.pendingPrompt !== undefined)
+          return false;
+        if (stage.status !== "awaiting_input")
+          return false;
+        stage.status = "running";
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageInputRequest(runId, stageId, request) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (isTerminalStageStatus(stage.status))
+        return false;
+      if (stage.inputRequest?.id === request.id)
+        return false;
+      stage.inputRequest = { ...request };
+      context.bumpAndNotify();
+      return true;
+    },
+    clearStageInputRequest(runId, stageId) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage || stage.inputRequest === undefined)
+        return false;
+      delete stage.inputRequest;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageBlocked(runId, stageId, blockedBy) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (cannotBlock(stage.status))
+        return false;
+      if (stage.status === "blocked") {
+        if (stage.blockedByStageId === blockedBy)
+          return false;
+        stage.blockedByStageId = blockedBy;
+      } else {
+        stage.status = "blocked";
+        stage.blockedByStageId = blockedBy;
+        delete stage.awaitingInputSince;
+      }
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageUnblocked(runId, stageId) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (stage?.status !== "blocked")
+        return false;
+      stage.status = "pending";
+      delete stage.blockedByStageId;
+      delete stage.awaitingInputSince;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageNotice(runId, stageId, notice) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (!stage.notices)
+        stage.notices = [];
+      stage.notices.push(notice);
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStagePaused(runId, stageId, pausedAt, metadata) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (cannotPause(stage.status)) {
+        if (stage.status !== "paused" || metadata?.actor === undefined)
+          return false;
+        if (stage.pauseActor === metadata.actor)
+          return false;
+        stage.pauseActor = metadata.actor;
+        context.bumpAndNotify();
+        return false;
+      }
+      stage.status = "paused";
+      stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
+      stage.resumedAt = undefined;
+      delete stage.awaitingInputSince;
+      delete stage.resumeActor;
+      if (metadata?.actor === undefined)
+        delete stage.pauseActor;
+      else
+        stage.pauseActor = metadata.actor;
+      context.bumpAndNotify();
+      return true;
+    },
+    recordStageResumed(runId, stageId, resumedAt, metadata) {
+      const run = context.findRun(runId);
+      if (!run)
+        return false;
+      if (TERMINAL_STATUSES.has(run.status))
+        return false;
+      const stage = context.findStage(run, stageId);
+      if (!stage)
+        return false;
+      if (stage.status !== "paused" && stage.status !== "blocked") {
+        if (stage.status !== "running" || stage.resumedAt === undefined || metadata?.actor === undefined) {
+          return false;
+        }
+        if (stage.resumeActor === metadata.actor)
+          return false;
+        stage.resumeActor = metadata.actor;
+        context.bumpAndNotify();
+        return false;
+      }
+      const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
+      stage.status = "running";
+      if (stage.startedAt !== undefined) {
+        stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
+      }
+      stage.resumedAt = resumedTs;
+      stage.pausedAt = undefined;
+      delete stage.blockedByStageId;
+      delete stage.awaitingInputSince;
+      delete stage.pauseActor;
+      if (metadata?.actor === undefined)
+        delete stage.resumeActor;
+      else
+        stage.resumeActor = metadata.actor;
+      context.bumpAndNotify();
+      return true;
+    }
+  };
+}
+
+// dist/builtin/workflows/src/shared/store-factory.ts
+function createStore() {
+  const context = createStoreContext();
+  return {
+    ...createRunStoreMethods(context),
+    ...createPendingStageDeliveryStoreMethods(context),
+    ...createStageStoreMethods(context),
+    ...createToolNodeStoreMethods(context),
+    ...createPromptStoreMethods(context)
+  };
+}
+var SESSION_KEY = "workflows:store:v1";
+var singleton = createSessionScopedSingleton(SESSION_KEY, createStore);
+var store = singleton.facade;
+// dist/builtin/workflows/src/shared/workflow-artifact-env.ts
+var WORKFLOW_ARTIFACT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+var ENV_WORKFLOW_ARTIFACT_DIR = "ATOMIC_WORKFLOW_ARTIFACT_DIR";
+
+// dist/builtin/workflows/src/shared/workflow-artifacts.ts
+var ARTIFACT_PRUNE_RECHECK_MS = 60 * 60 * 1000;
+var lastArtifactPruneAt = new Map;
+var pendingArtifactPrunes = new Map;
+function workflowArtifactRoot() {
+  const override = getEnvValue(ENV_WORKFLOW_ARTIFACT_DIR);
+  if (override !== undefined && override.length > 0)
+    return override;
+  return join(dirname(getAgentDir()), "workflows");
+}
+function workflowArtifactRunsRoot() {
+  return join(workflowArtifactRoot(), "runs");
+}
+function safeRunId(runId) {
+  const safe = runId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return safe.length > 0 ? safe : "run";
+}
+function workflowArtifactRunPath(runId) {
+  return join(workflowArtifactRunsRoot(), safeRunId(runId));
+}
+function storeRunState(run) {
+  const hasPendingInput = run.pendingPrompt !== undefined || run.stages.some((stage) => stage.status === "awaiting_input" || stage.status === "paused" || stage.status === "blocked");
+  if (hasPendingInput || run.status === "pending" || run.status === "running" || run.status === "paused" || run.status === "blocked" || run.exitReason === "quit") {
+    return "protected";
+  }
+  return "terminal";
+}
+function durableRunState(backend, runId) {
+  const handle = backend.getLoadableWorkflow(runId);
+  if (handle === undefined)
+    return;
+  if (handle.status === "running" || handle.status === "paused" || handle.status === "blocked" || handle.pendingPrompts > 0) {
+    return "protected";
+  }
+  return "terminal";
+}
+function createWorkflowArtifactRunStateResolver() {
+  const localRuns = new Map(store.runs().map((run) => [run.id, run]));
+  const findLocalRun = (runId) => localRuns.get(runId) ?? [...localRuns.values()].find((run) => safeRunId(run.id) === runId);
+  const protectedOwners = new Set;
+  for (const run of localRuns.values()) {
+    if (storeRunState(run) !== "protected")
+      continue;
+    let cursor = run;
+    const visited = new Set;
+    while (cursor !== undefined && !visited.has(cursor.id)) {
+      visited.add(cursor.id);
+      protectedOwners.add(safeRunId(cursor.id));
+      const sourceId = cursor.resumedFromRunId;
+      if (sourceId === undefined)
+        break;
+      protectedOwners.add(safeRunId(sourceId));
+      cursor = findLocalRun(sourceId);
+    }
+  }
+  let backend;
+  let backendReady = true;
+  try {
+    backend = getDurableBackend();
+  } catch {
+    backendReady = false;
+  }
+  return (runId) => {
+    if (protectedOwners.has(runId))
+      return "protected";
+    const local = findLocalRun(runId);
+    const localState = local === undefined ? undefined : storeRunState(local);
+    if (!backendReady) {
+      return localState === "protected" ? "protected" : undefined;
+    }
+    let durable;
+    if (backend !== undefined) {
+      try {
+        durable = durableRunState(backend, runId);
+      } catch {
+        backendReady = false;
+        return localState === "protected" ? "protected" : undefined;
+      }
+    }
+    if (durable === "protected" || localState === "protected")
+      return "protected";
+    if (durable === "terminal" || localState === "terminal")
+      return "terminal";
+    return "orphan";
+  };
+}
+async function deleteTerminalDurableEntry(runId) {
+  let backend;
+  try {
+    backend = getDurableBackend();
+  } catch {
+    return false;
+  }
+  try {
+    const result = await backend.deleteWorkflowIfInactive(runId);
+    return result.ok || result.reason === "not_found";
+  } catch {
+    return false;
+  }
+}
+async function pruneWorkflowArtifactRuns(root = workflowArtifactRunsRoot(), now = Date.now(), stateResolver) {
+  try {
+    const entries = await readdir(root, { withFileTypes: true, encoding: "utf8" });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const entryPath = join(root, entry.name);
+      let metadata;
+      try {
+        metadata = await stat(entryPath);
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+          continue;
+        throw error;
+      }
+      if (now - metadata.mtimeMs <= WORKFLOW_ARTIFACT_RETENTION_MS)
+        continue;
+      if (stateResolver === undefined)
+        continue;
+      const state = stateResolver(entry.name);
+      if (state !== "terminal" && state !== "orphan")
+        continue;
+      if (state === "terminal" && !await deleteTerminalDurableEntry(entry.name))
+        continue;
+      await rm(entryPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function pruneArtifactRootIfDue(root, now) {
+  const pending = pendingArtifactPrunes.get(root);
+  if (pending !== undefined) {
+    try {
+      await pending;
+    } catch {}
+    return;
+  }
+  const previous = lastArtifactPruneAt.get(root);
+  if (previous !== undefined && now - previous < ARTIFACT_PRUNE_RECHECK_MS)
+    return;
+  const operation = pruneWorkflowArtifactRuns(root, now, createWorkflowArtifactRunStateResolver());
+  pendingArtifactPrunes.set(root, operation);
+  try {
+    await operation;
+  } catch {} finally {
+    lastArtifactPruneAt.set(root, now);
+    pendingArtifactPrunes.delete(root);
+  }
+}
+function workflowArtifactDirectoryPath(runId) {
+  const effectiveRunId = runId ?? randomUUID();
+  return join(workflowArtifactRunPath(effectiveRunId), `artifact-${randomUUID()}`);
+}
+async function ensureWorkflowArtifactDirectory(directory) {
+  await pruneArtifactRootIfDue(workflowArtifactRunsRoot(), Date.now());
+  await mkdir(directory, { recursive: true });
+  return directory;
+}
+async function createWorkflowArtifactDirectory(runId) {
+  return ensureWorkflowArtifactDirectory(workflowArtifactDirectoryPath(runId));
+}
+
+// dist/builtin/workflows/builtin/goal-convergence.ts
+var FRACTION_TREND_RISE_DELTA = DEFAULT_RISE_DELTA / (VERIFICATION_SCALE.max - VERIFICATION_SCALE.min);
+var FRACTION_TREND_FALL_DELTA = DEFAULT_FALL_DELTA / (VERIFICATION_SCALE.max - VERIFICATION_SCALE.min);
+function record_convergence(round) {
+  return {
+    unresolvedBlockingCount: round.unresolvedBlockingCount,
+    meanFindingConfidence: round.meanFindingConfidence,
+    fractionProven: round.fractionProven,
+    demotions: round.demotions,
+    usage: round.usage
+  };
+}
+function classify_convergence(entries) {
+  return {
+    blocking: classify_trend(entries.map((entry) => entry.unresolvedBlockingCount)),
+    proven: classify_trend(entries.map((entry) => entry.fractionProven), {
+      riseDelta: FRACTION_TREND_RISE_DELTA,
+      fallDelta: FRACTION_TREND_FALL_DELTA
+    })
+  };
+}
+function convergence_escalation_evidence(entries) {
+  if (entries.length === 0)
+    return [];
+  const { blocking, proven } = classify_convergence(entries);
+  if (blocking.trend === "regressing" || proven.trend === "rising" && blocking.trend !== "rising")
+    return [];
+  const latest = entries[entries.length - 1]?.meanFindingConfidence;
+  return [
+    `${entries.length} round${entries.length === 1 ? "" : "s"} recorded; no observed convergence: the blocking-count trend is ${blocking.trend}.`,
+    `Blocking-count trend: ${blocking.trend}; raw series: ${JSON.stringify(blocking.evidence.series)}.`,
+    `Fraction-proven trend: ${proven.trend}; raw series: ${JSON.stringify(proven.evidence.series)}.`,
+    latest === null ? "Latest mean finding confidence: no findings were filed." : `Latest mean finding confidence: ${latest}.`,
+    "This is escalation EVIDENCE only; it never approves or terminates anything."
+  ];
+}
+
+// dist/builtin/workflows/builtin/review-convergence.ts
+var FINAL_ACTION_PATTERN = /\b(?:pr|pull[- ]request|merge[- ]request|review request|github pr|create pr)\b/iu;
+function isFinalActionTraceability(entry) {
+  return FINAL_ACTION_PATTERN.test(`${entry.requirement}
+${entry.evidence}`);
+}
+function finalActionRemaining(traceability) {
+  return traceability.some((entry) => entry.status !== "proven" && isFinalActionTraceability(entry));
+}
+var MAX_BLOCKING_PRIORITY = 2;
+function findingBlocksClosure(finding) {
+  const alignment = finding.objective_alignment;
+  if (alignment === "beyond_objective" || alignment === "contradicts_objective") {
+    return false;
+  }
+  if (alignment === "required_by_objective")
+    return true;
+  if (alignment !== "consistent_with_objective")
+    return true;
+  const priority = finding.priority;
+  if (priority === undefined || priority === null)
+    return true;
+  return priority <= MAX_BLOCKING_PRIORITY;
+}
+function findingConsolidationKey(finding) {
+  const normalizedTitle = finding.title.replace(/^\s*\[P[0-3]\]\s*/iu, "").toLowerCase().replace(/\s+/gu, " ").trim();
+  return `${finding.code_location?.absolute_file_path ?? ""}::${normalizedTitle}`;
+}
+function consolidateFindingsBatch(reviews) {
+  const byKey = new Map;
+  for (const review of reviews) {
+    for (const finding of review.findings) {
+      const key = findingConsolidationKey(finding);
+      const existing = byKey.get(key);
+      if (existing === undefined) {
+        byKey.set(key, {
+          finding,
+          reviewers: [review.reviewer],
+          blocking: findingBlocksClosure(finding)
+        });
+        continue;
+      }
+      if (!existing.reviewers.includes(review.reviewer)) {
+        existing.reviewers.push(review.reviewer);
+      }
+      existing.blocking = existing.blocking || findingBlocksClosure(finding);
+    }
+  }
+  return [...byKey.values()].sort((a, b) => Number(b.blocking) - Number(a.blocking));
+}
+var PREVIEW_LIMIT = 500;
+function rawTextPreview(rawText) {
+  const trimmed = rawText.trim();
+  if (trimmed.length === 0)
+    return;
+  return trimmed.slice(0, PREVIEW_LIMIT);
+}
+function parseFailureDiagnostics(reviewer, rawText) {
+  const preview = rawTextPreview(rawText);
+  const base = `Structured reviewer decision parse failed for ${reviewer}: no schema-valid JSON decision was returned.`;
+  return preview === undefined ? [base] : [base, `Raw reviewer output preview: ${preview}`];
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function reviewerFailureText(error) {
+  const messages = [errorMessage2(error)];
+  if (error instanceof AggregateError) {
+    for (const nested of error.errors) {
+      messages.push(errorMessage2(nested));
+    }
+  }
+  return [...new Set(messages.map((message) => message.trim()).filter(Boolean))].join(`
+`);
+}
+function summarizeReviewConvergence(args) {
+  return {
+    parsed: args.parsed,
+    approved: args.approved,
+    stopReviewLoop: args.stopReviewLoop,
+    nextAction: args.nextAction,
+    finalActionRemaining: args.finalActionRemaining ?? args.nextAction === "pull-request",
+    diagnostics: args.diagnostics
+  };
+}
+
+// dist/builtin/workflows/builtin/goal-reverify.ts
+import { Type } from "typebox";
+var DEFAULT_REVERIFY_THRESHOLD = 0.7;
+var STANDARD_CONFIRM_THRESHOLD = 10;
+var REQUIRED_CONFIRM_THRESHOLD = 6;
+var DEFAULT_REPEATS = 3;
+var REVERIFY_QUESTION = "Assess this specific finding against the code it cites: is it a real, objective-relevant, currently-unresolved blocker?";
+var reverifySchema = Type.Object({
+  score: VERIFICATION_SCALE.schema,
+  evidence: Type.Array(Type.String())
+}, { additionalProperties: false });
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function parseReport(result) {
+  if (!isRecord(result.structured))
+    return;
+  const score = result.structured.score;
+  if (typeof score !== "number" || !Number.isInteger(score) || score < VERIFICATION_SCALE.min || score > VERIFICATION_SCALE.max) {
+    return;
+  }
+  const evidence = result.structured.evidence;
+  return {
+    score,
+    evidence: isStringArray(evidence) ? evidence : []
+  };
+}
+function requiredByObjective(finding) {
+  return finding.finding.objective_alignment === "required_by_objective";
+}
+function is_reverifiable(finding, threshold = DEFAULT_REVERIFY_THRESHOLD) {
+  const confidence = finding.finding.confidence_score;
+  return finding.blocking && finding.reviewers.length === 1 && typeof confidence === "number" && Number.isFinite(confidence) && confidence < threshold && finding.finding.objective_alignment !== "beyond_objective" && finding.finding.objective_alignment !== "contradicts_objective";
+}
+function readPaths(finding, candidateRefs) {
+  const codePath = finding.finding.code_location?.absolute_file_path;
+  return [
+    ...codePath === undefined ? [] : [codePath],
+    ...candidateRefs
+  ];
+}
+function promptFor(finding, context) {
+  const codePath = finding.finding.code_location?.absolute_file_path;
+  const candidate = {
+    ...codePath === undefined ? {} : { path: codePath },
+    body: [
+      `Title: ${finding.finding.title}`,
+      `Body: ${finding.finding.body ?? ""}`,
+      `Code location: ${codePath ?? "not supplied"}`
+    ].join(`
+`)
+  };
+  const head = {
+    task: `${REVERIFY_QUESTION}
+
+Objective:
+${context.objective}`,
+    groundTruthNote: `The objective is the contract. Verify the finding against observed code, not reviewer narration.`,
+    candidates: [candidate],
+    outputFormat: "Call structured_output with score (an integer from 1 to 20) and evidence (an array of observed, concise reasons)."
+  };
+  const prompt = build_scoring_prompt(head, {
+    id: "finding_reverification",
+    name: "Finding re-verification",
+    description: REVERIFY_QUESTION
+  });
+  return {
+    prompt,
+    reads: [
+      ...readPaths(finding, context.candidateRefs),
+      ...scoring_prompt_reads(head)
+    ]
+  };
+}
+async function runRepeat(ctx, finding, context, stageName) {
+  try {
+    const rendered = promptFor(finding, context);
+    const options = {
+      prompt: rendered.prompt,
+      context: "fresh",
+      reads: rendered.reads,
+      schema: reverifySchema
+    };
+    return parseReport(await ctx.task(stageName, options));
+  } catch {
+    return;
+  }
+}
+async function reverify_finding(ctx, input) {
+  if (!is_reverifiable(input.finding, input.threshold)) {
+    throw new Error("Cannot re-verify an ineligible finding.");
+  }
+  const repeatCount = Number.isFinite(input.repeats) && input.repeats !== undefined ? Math.max(0, Math.floor(input.repeats)) : DEFAULT_REPEATS;
+  const perRepeat = [];
+  const evidence = [];
+  const validScores = [];
+  for (let repeat = 1;repeat <= repeatCount; repeat += 1) {
+    let report = await runRepeat(ctx, input.finding, input.context, `reverify-${repeat}`);
+    if (report === undefined) {
+      report = await runRepeat(ctx, input.finding, input.context, `reverify-${repeat}-reask`);
+    }
+    if (report === undefined) {
+      perRepeat.push(null);
+      evidence.push(`Re-verification repeat ${repeat} was invalid after one re-ask; doubt defaults to confirmed.`);
+      continue;
+    }
+    perRepeat.push(report.score);
+    validScores.push(report.score);
+    if (report.evidence.length === 0) {
+      evidence.push(`Re-verification repeat ${repeat} scored ${report.score}/20.`);
+    } else {
+      evidence.push(...report.evidence);
+    }
+  }
+  const meanScore = validScores.length === 0 ? 0 : validScores.reduce((total, score) => total + score, 0) / validScores.length;
+  const validCount = validScores.length;
+  const requiredQuorum = Math.ceil(repeatCount / 2);
+  const demoted = requiredByObjective(input.finding) ? repeatCount > 0 && validCount === repeatCount && meanScore < REQUIRED_CONFIRM_THRESHOLD : validCount > 0 && validCount >= requiredQuorum && meanScore < STANDARD_CONFIRM_THRESHOLD;
+  return {
+    verdict: demoted ? "demoted" : "confirmed",
+    meanScore,
+    perRepeat,
+    evidence
+  };
+}
+function auditKey(finding) {
+  return JSON.stringify([
+    finding.finding.code_location?.absolute_file_path ?? "",
+    finding.finding.title,
+    finding.reviewers
+  ]);
+}
+function apply_reverify_results(batch, audits) {
+  const demoted = new Set(audits.filter((audit) => audit.verdict === "demoted").map((audit) => auditKey(audit.finding)));
+  return {
+    batch: batch.map((entry) => demoted.has(auditKey(entry)) ? { ...entry, blocking: false } : entry),
+    audits
+  };
+}
+async function reverify_consolidated_batch(ctx, input) {
+  const audits = [];
+  for (const entry of input.batch) {
+    if (!is_reverifiable(entry, input.threshold))
+      continue;
+    const result = await reverify_finding(ctx, {
+      finding: entry,
+      context: input.context,
+      repeats: input.repeats,
+      threshold: input.threshold
+    });
+    audits.push({ finding: entry, ...result });
+  }
+  return apply_reverify_results(input.batch, audits);
+}
+
+export { workflowArtifactDirectoryPath, ensureWorkflowArtifactDirectory, createWorkflowArtifactDirectory, record_convergence, convergence_escalation_evidence, finalActionRemaining, consolidateFindingsBatch, parseFailureDiagnostics, reviewerFailureText, summarizeReviewConvergence, reverify_consolidated_batch };