@bastani/atomic 0.9.27 → 0.9.28-alpha.2

package/dist/builtin/workflows/builtin/{chunk-9bhs02gm.js → chunk-p3xmajmj.js}

@@ -5075,12 +5075,6 @@ var require_lib2 = __commonJS(function(exports, module) {
     }
   });
 });
-
-// dist/builtin/workflows/src/shared/workflow-artifacts.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir2, readdir as readdir2, rm as rm2, stat } from "node:fs/promises";
-import { dirname as dirname4, join as join5 } from "node:path";
-import { getAgentDir, getEnvValue } from "@bastani/atomic";
 // dist/builtin/workflows/src/durable/backend-process-owner.ts
 var DURABLE_BACKEND_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/durable-backend-process-owner@1");
 function emptyOwner() {
@@ -5105,6 +5099,16 @@ function getDurableBackendProcessOwner() {
   bag[DURABLE_BACKEND_PROCESS_OWNER_KEY] = created;
   return created;
 }
+
+// dist/builtin/workflows/src/shared/pending-stage-retention.ts
+var PENDING_STAGE_SETTLED_MESSAGE_LIMIT = 50;
+async function retainPendingStageMessages(messages, archive) {
+  const settled = messages.filter((entry) => entry.status === "delivered" || entry.status === "undeliverable" && entry.undeliverableNotifiedAt !== undefined);
+  const expired = new Set(settled.slice(0, Math.max(0, settled.length - PENDING_STAGE_SETTLED_MESSAGE_LIMIT)));
+  for (const entry of expired)
+    await archive(entry);
+  return expired.size === 0 ? messages : messages.filter((entry) => !expired.has(entry));
+}
 // dist/builtin/workflows/src/durable/dbos-admission.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -8496,14 +8500,22 @@ function dbosLifecycleState() {
 function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
-function getDurableBackend() {
-  const owner = getDurableBackendProcessOwner();
-  const memoized = owner.initializedBackend !== undefined && isMemoizedBackendUsable(owner.initializedBackend) ? owner.initializedBackend : undefined;
-  const backend = owner.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+function getDurableBackend2() {
+  const backend = getAvailableDurableBackend2();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
 }
+function getAvailableDurableBackend2() {
+  const owner = getDurableBackendProcessOwner();
+  const memoized = owner.initializedBackend !== undefined && isMemoizedBackendUsable(owner.initializedBackend) ? owner.initializedBackend : undefined;
+  return owner.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+}
+// dist/builtin/workflows/src/shared/workflow-artifacts.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir2, readdir as readdir2, rm as rm2, stat } from "node:fs/promises";
+import { dirname as dirname4, join as join5 } from "node:path";
+import { getAgentDir, getEnvValue } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/shared/pending-stage-delivery.ts
 var PENDING_STAGE_MESSAGE_LIMIT = 50;
@@ -8638,11 +8650,29 @@ function recordPendingStageMessageDeliveries(messages, runId, messageId, records
   if (additions.length === 0)
     return messages;
   const deliveries = [...entry.deliveries ?? [], ...additions];
-  const next = { ...entry, deliveries, deliveryCount: deliveries.length };
+  const next = {
+    ...entry,
+    deliveries,
+    deliveryCount: (entry.deliveryCount ?? entry.deliveries?.length ?? 0) + additions.length
+  };
   const result = [...messages];
   result[index] = next;
   return result;
 }
+function compactStickyStageMessageDeliveries(messages, runs) {
+  const finished = new Set(runs.flatMap((run) => run.stages.filter((stage) => stage.status === "completed" || stage.status === "skipped").map((stage) => JSON.stringify([run.id, stage.id]))));
+  let changed = false;
+  const next = messages.map((entry) => {
+    if (entry.sticky !== true || entry.deliveries === undefined)
+      return entry;
+    const deliveries = entry.deliveries.filter((delivery) => !finished.has(JSON.stringify([delivery.runId, delivery.stageId])));
+    if (deliveries.length === entry.deliveries.length)
+      return entry;
+    changed = true;
+    return { ...entry, deliveries, deliveryCount: entry.deliveryCount ?? entry.deliveries.length };
+  });
+  return changed ? next : messages;
+}
 function settleStickyPendingStageMessageDelivered(messages, runId, messageId, settledAt) {
   const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued" && (entry.deliveryCount ?? 0) > 0);
   if (index < 0)
@@ -8782,7 +8812,7 @@ function createSessionScopedSingleton(key, createLocal) {
     const target = sessionScopedExtensionState(scope, key, () => {
       targetCreated = true;
       if (shared.localClaimed)
-        return createLocal();
+        return (options?.create ?? createLocal)();
       shared.localClaimed = true;
       return shared.local;
     });
@@ -9179,6 +9209,44 @@ function deepFreezeGraphValue(value) {
 // dist/builtin/workflows/src/shared/workflow-observation-runtime.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
+// dist/builtin/workflows/src/shared/workflow-run-ownership.ts
+function authoritativeWorkflowChildRunId(stage) {
+  if (stage === undefined || stage.status === "failed" || stage.status === "skipped") {
+    return;
+  }
+  if (stage.status === "completed") {
+    return stage.workflowChild?.runId ?? stage.workflowChildRun?.runId;
+  }
+  return stage.workflowChildRun?.runId;
+}
+function reciprocalWorkflowRootRunId(runById, runId) {
+  const visited = new Set;
+  const declaredRoots = [];
+  let current = runById.get(runId);
+  while (current !== undefined) {
+    const currentId = current.id;
+    if (visited.has(currentId))
+      return;
+    visited.add(currentId);
+    if (current.rootRunId !== undefined)
+      declaredRoots.push(current.rootRunId);
+    const parentRunId = current.parentRunId;
+    const parentStageId = current.parentStageId;
+    if (parentRunId === undefined !== (parentStageId === undefined))
+      return;
+    if (parentRunId === undefined || parentStageId === undefined) {
+      return declaredRoots.every((declared) => declared === currentId) ? currentId : undefined;
+    }
+    const parent = runById.get(parentRunId);
+    const boundary = parent?.stages.find((stage) => stage.id === parentStageId);
+    if (parent === undefined || authoritativeWorkflowChildRunId(boundary) !== currentId) {
+      return;
+    }
+    current = parent;
+  }
+  return;
+}
+
 // dist/builtin/workflows/src/shared/workflow-activity.ts
 function workflowActivityNodeKey(runId, nodeId) {
   return `${runId}:${nodeId}`;
@@ -9538,6 +9606,252 @@ function createStoreContext(state = createStoreState()) {
   };
 }
 
+// dist/builtin/workflows/src/durable/prompt-reservations.ts
+function durablePromptScope(backend, workflowId) {
+  return backend.promptReservationScope(workflowId);
+}
+function claimDurablePromptToken(backend, workflowId, reservationId) {
+  return backend.pendingPromptToken(workflowId, reservationId);
+}
+function reserveDurablePrompt(backend, workflowId, reservationId) {
+  return backend.reservePendingPrompt(workflowId, reservationId);
+}
+function releaseDurablePrompt(backend, workflowId, reservationId, token) {
+  backend.releasePendingPrompt(workflowId, reservationId, token);
+}
+
+// dist/builtin/workflows/src/durable/scoped-backend.ts
+class ScopedDurableBackend {
+  persistent;
+  inner;
+  scope;
+  constructor(inner, scope) {
+    this.inner = inner;
+    this.scope = scope;
+    this.persistent = inner.persistent;
+  }
+  async archivePendingStageMessage(_workflowId, entry) {
+    await this.inner.archivePendingStageMessage?.(this.scope.rootWorkflowId, entry);
+  }
+  async readSettledPendingStageMessage(workflowId, messageId, logicalRunId = workflowId) {
+    return this.inner.readSettledPendingStageMessage?.(this.scope.rootWorkflowId, messageId, logicalRunId);
+  }
+  getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
+    return this.inner.getPendingStageMessageDeliveryCount?.(this.scope.rootWorkflowId, messageId, logicalRunId) ?? 0;
+  }
+  async readPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
+    return this.inner.readPendingStageMessageDeliveryCount === undefined ? this.getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId) : await this.inner.readPendingStageMessageDeliveryCount(this.scope.rootWorkflowId, messageId, logicalRunId);
+  }
+  async archivePendingStageDeliveryReceipt(_workflowId, messageId, delivery, accounting) {
+    await this.inner.archivePendingStageDeliveryReceipt?.(this.scope.rootWorkflowId, messageId, delivery, accounting);
+  }
+  hasCachedPendingStageDeliveryReceipt(workflowId, messageId, delivery, anySession = false, logicalRunId = workflowId) {
+    return this.inner.hasCachedPendingStageDeliveryReceipt?.(this.scope.rootWorkflowId, messageId, delivery, anySession, logicalRunId) ?? false;
+  }
+  async hasPendingStageDeliveryReceipt(workflowId, messageId, delivery, logicalRunId = workflowId) {
+    return await this.inner.hasPendingStageDeliveryReceipt?.(this.scope.rootWorkflowId, messageId, delivery, logicalRunId) ?? false;
+  }
+  registerWorkflow(_handle) {}
+  persistPendingStageMessages(workflowId, messages, logicalRunId = workflowId) {
+    return this.inner.persistPendingStageMessages(this.scope.rootWorkflowId, messages, logicalRunId);
+  }
+  recordCheckpoint(checkpoint) {
+    this.inner.recordCheckpoint(this.remap(checkpoint));
+  }
+  async recordCheckpointAsync(checkpoint, options) {
+    await this.inner.recordCheckpointAsync(this.remap(checkpoint), options);
+  }
+  async recordAdditiveCheckpointBestEffort(checkpoint) {
+    return await this.inner.recordAdditiveCheckpointBestEffort(this.remap(checkpoint));
+  }
+  flush(workflowId) {
+    return workflowId === undefined ? this.inner.flush() : this.inner.flush(this.scope.rootWorkflowId);
+  }
+  getToolOutput(_workflowId, argsHash) {
+    return this.inner.getToolOutput(this.scope.rootWorkflowId, this.scopeKey(argsHash));
+  }
+  getToolCheckpoint(_workflowId, argsHash) {
+    return this.inner.getToolCheckpoint(this.scope.rootWorkflowId, this.scopeKey(argsHash));
+  }
+  getUiResponse(_workflowId, promptHash) {
+    return this.inner.getUiResponse(this.scope.rootWorkflowId, this.scopeKey(promptHash));
+  }
+  getStageOutput(_workflowId, replayKey) {
+    return this.inner.getStageOutput(this.scope.rootWorkflowId, this.scopeKey(replayKey));
+  }
+  getStageSession(_workflowId, replayKey) {
+    return this.inner.getStageSession(this.scope.rootWorkflowId, this.scopeKey(replayKey));
+  }
+  listCheckpoints(workflowId) {
+    const prefix = `${this.scope.scopePrefix}:`;
+    return this.inner.listCheckpoints(this.scope.rootWorkflowId).filter((checkpoint) => checkpointHasPrefix(checkpoint, prefix)).map((checkpoint) => localCheckpoint(checkpoint, workflowId, prefix));
+  }
+  getWorkflow(_workflowId) {
+    return;
+  }
+  getLoadableWorkflow(_workflowId) {
+    return;
+  }
+  setWorkflowStatus(_workflowId, _status, _pendingPrompts, _resumable) {}
+  async transitionWorkflowStatus(_workflowId, _expectedStatuses, _status, _pendingPrompts, _resumable) {
+    return false;
+  }
+  adjustPendingPrompts(_workflowId, delta) {
+    this.inner.adjustPendingPrompts(this.scope.rootWorkflowId, delta);
+  }
+  promptReservationScope(_workflowId) {
+    return this.effectivePromptScope();
+  }
+  pendingPromptToken(_workflowId, reservationId) {
+    return claimDurablePromptToken(this.inner, this.scope.rootWorkflowId, reservationId);
+  }
+  reservePendingPrompt(_workflowId, reservationId) {
+    return reserveDurablePrompt(this.inner, this.scope.rootWorkflowId, reservationId);
+  }
+  releasePendingPrompt(_workflowId, reservationId, token) {
+    releaseDurablePrompt(this.inner, this.scope.rootWorkflowId, reservationId, token);
+  }
+  listResumableWorkflows() {
+    return [];
+  }
+  listCompletedWorkflows() {
+    return [];
+  }
+  async prepareWorkflowCatalog() {
+    return { resumable: [], completed: [] };
+  }
+  toMetadata(_workflowId) {
+    return;
+  }
+  async deleteWorkflow(_workflowId) {}
+  async deleteWorkflowIfInactive(_workflowId) {
+    return { ok: false, reason: "not_found" };
+  }
+  isWorkflowLoadable(_workflowId) {
+    return false;
+  }
+  reset() {}
+  hydrateWorkflow(_workflowId) {
+    return Promise.resolve();
+  }
+  hydrateWorkflowForInspection(_workflowId) {
+    return Promise.resolve({ kind: "absent" });
+  }
+  hydrateResumableWorkflows() {
+    return Promise.resolve();
+  }
+  effectivePromptScope() {
+    const parent = durablePromptScope(this.inner, this.scope.rootWorkflowId);
+    const scope = parent.scope === "root" ? this.scope.scopePrefix : `${parent.scope}:${this.scope.scopePrefix}`;
+    return {
+      rootWorkflowId: parent.rootWorkflowId,
+      scope
+    };
+  }
+  scopeKey(key) {
+    return `${this.scope.scopePrefix}:${key}`;
+  }
+  remap(checkpoint) {
+    const workflowId = this.scope.rootWorkflowId;
+    if (checkpoint.kind === "tool") {
+      return {
+        ...checkpoint,
+        workflowId,
+        checkpointId: this.scopeKey(checkpoint.checkpointId),
+        argsHash: this.scopeKey(checkpoint.argsHash)
+      };
+    }
+    if (checkpoint.kind === "ui") {
+      return {
+        ...checkpoint,
+        workflowId,
+        checkpointId: this.scopeKey(checkpoint.checkpointId),
+        promptHash: this.scopeKey(checkpoint.promptHash)
+      };
+    }
+    return {
+      ...checkpoint,
+      workflowId,
+      checkpointId: this.scopeKey(checkpoint.checkpointId),
+      replayKey: this.scopeKey(checkpoint.replayKey),
+      ...remappedBoundaryScope(checkpoint, this.scopeKey(checkpoint.topology?.boundary?.replayScope ?? ""))
+    };
+  }
+}
+function checkpointHasPrefix(checkpoint, prefix) {
+  if (!checkpoint.checkpointId.startsWith(prefix))
+    return false;
+  if (checkpoint.kind === "tool")
+    return checkpoint.argsHash.startsWith(prefix);
+  if (checkpoint.kind === "ui")
+    return checkpoint.promptHash.startsWith(prefix);
+  return checkpoint.replayKey.startsWith(prefix);
+}
+function localCheckpoint(checkpoint, workflowId, prefix) {
+  const checkpointId = checkpoint.checkpointId.slice(prefix.length);
+  if (checkpoint.kind === "tool") {
+    return { ...checkpoint, workflowId, checkpointId, argsHash: checkpoint.argsHash.slice(prefix.length) };
+  }
+  if (checkpoint.kind === "ui") {
+    return { ...checkpoint, workflowId, checkpointId, promptHash: checkpoint.promptHash.slice(prefix.length) };
+  }
+  const replayKey = checkpoint.replayKey.slice(prefix.length);
+  const replayScope = stripOnePrefix(checkpoint.topology?.boundary?.replayScope, prefix);
+  return {
+    ...checkpoint,
+    workflowId,
+    checkpointId,
+    replayKey,
+    ...remappedBoundaryScope(checkpoint, replayScope)
+  };
+}
+function remappedBoundaryScope(checkpoint, replayScope) {
+  const topology = checkpoint.topology;
+  if (topology?.boundary === undefined || replayScope === undefined)
+    return {};
+  return {
+    topology: {
+      ...topology,
+      boundary: { ...topology.boundary, replayScope }
+    }
+  };
+}
+function stripOnePrefix(value, prefix) {
+  if (value === undefined || !value.startsWith(prefix))
+    return value;
+  return value.slice(prefix.length);
+}
+
+// dist/builtin/workflows/src/durable/run-owner-backend.ts
+function durableRootRunIdForRun(runs, runId) {
+  return reciprocalWorkflowRootRunId(new Map(runs.map((run) => [run.id, run])), runId);
+}
+function durableBackendForRun(backend, runs, runId) {
+  const rootRunId = durableRootRunIdForRun(runs, runId);
+  if (rootRunId === undefined)
+    return;
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  if (rootRunId === runId)
+    return backend;
+  const scopes = [];
+  let current = runById.get(runId);
+  while (current !== undefined && current.id !== rootRunId) {
+    const parent = current.parentRunId === undefined ? undefined : runById.get(current.parentRunId);
+    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
+    if (parent === undefined || boundary?.replayKey === undefined)
+      return;
+    scopes.push(boundary.replayKey);
+    current = parent;
+  }
+  if (current?.id !== rootRunId)
+    return;
+  let view = backend;
+  for (const scopePrefix of scopes.reverse()) {
+    view = new ScopedDurableBackend(view, { rootWorkflowId: rootRunId, scopePrefix });
+  }
+  return view;
+}
+
 // dist/builtin/workflows/src/shared/store-pending-stage-delivery-methods.ts
 function createPendingStageDeliveryStoreMethods(context) {
   const transitions = new Map;
@@ -9565,13 +9879,14 @@ function createPendingStageDeliveryStoreMethods(context) {
         if (run === undefined)
           return;
         const stageIdentity = resolvePendingStageIdentity(run, input.stageKey);
-        const result = queueStageMessage(run.pendingStageMessages ?? [], input, senderGroup, runGroup, stageIdentity);
+        const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
+        const result = queueStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup, stageIdentity);
         if (result.ok && !result.deduplicated) {
-          await persistTransition(backend, input.runId, result.messages);
-          run.pendingStageMessages = [...result.messages];
+          const messages = await persistTransition(backend, input.runId, result.messages, context);
+          run.pendingStageMessages = [...messages];
           context.bumpAndNotify();
         }
-        return result;
+        return result.ok ? { ...result, messages: run.pendingStageMessages ?? [] } : result;
       });
     },
     async validateLiveStageMessage(input) {
@@ -9579,7 +9894,11 @@ function createPendingStageDeliveryStoreMethods(context) {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
-        const result = queueStageMessage(run.pendingStageMessages ?? [], input, undefined, undefined, resolvePendingStageIdentity(run, input.stageKey));
+        const { getAvailableDurableBackend } = await import("./chunk-p6jagvyf.js");
+        const availableBackend = getAvailableDurableBackend();
+        const backend = availableBackend === undefined ? undefined : durableBackendForRun(availableBackend, context.state.runs, input.runId);
+        const receipt = await backend?.readSettledPendingStageMessage?.(input.runId, input.message.id);
+        const result = queueStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], 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" };
         }
@@ -9609,8 +9928,8 @@ function createPendingStageDeliveryStoreMethods(context) {
         const next = markPendingStageMessageDelivered(current, runId, stageKey, messageId, deliveredAt, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        await persistTransition(backend, runId, next);
-        run.pendingStageMessages = [...next];
+        const messages = await persistTransition(backend, runId, next, context);
+        run.pendingStageMessages = [...messages];
         context.bumpAndNotify();
         return true;
       });
@@ -9624,8 +9943,8 @@ function createPendingStageDeliveryStoreMethods(context) {
         const next = markPendingStageMessageUndeliverable(current, runId, stageKey, messageId, reason, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        await persistTransition(backend, runId, next);
-        run.pendingStageMessages = [...next];
+        const messages = await persistTransition(backend, runId, next, context);
+        run.pendingStageMessages = [...messages];
         context.bumpAndNotify();
         return true;
       });
@@ -9639,8 +9958,8 @@ function createPendingStageDeliveryStoreMethods(context) {
         const next = markPendingStageMessageUndeliverableNotified(current, runId, stageKey, messageId, notificationId, notifiedAt);
         if (next === current)
           return false;
-        await persistTransition(backend, runId, next);
-        run.pendingStageMessages = [...next];
+        const messages = await persistTransition(backend, runId, next, context);
+        run.pendingStageMessages = [...messages];
         context.bumpAndNotify();
         return true;
       });
@@ -9650,13 +9969,14 @@ function createPendingStageDeliveryStoreMethods(context) {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
-        const result = queueStickyStageMessage(run.pendingStageMessages ?? [], input, senderGroup, runGroup);
+        const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
+        const result = queueStickyStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup);
         if (result.ok && !result.deduplicated) {
-          await persistTransition(backend, input.runId, result.messages);
-          run.pendingStageMessages = [...result.messages];
+          const messages = await persistTransition(backend, input.runId, result.messages, context);
+          run.pendingStageMessages = [...messages];
           context.bumpAndNotify();
         }
-        return result;
+        return result.ok ? { ...result, messages: run.pendingStageMessages ?? [] } : result;
       });
     },
     async recordPendingStageMessageDeliveries(runId, messageId, records, deliveredAt, backend) {
@@ -9664,12 +9984,26 @@ function createPendingStageDeliveryStoreMethods(context) {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
-        const next = recordPendingStageMessageDeliveries(current, runId, messageId, records, deliveredAt);
+        if (records.length === 0)
+          await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
+        let current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
+        const unconfirmedRecords = [];
+        for (const record of records) {
+          const contextReceipt = record.admission === "transport" ? { ...record, admission: "context" } : undefined;
+          if (!await backend.hasPendingStageDeliveryReceipt?.(runId, messageId, record) && (contextReceipt === undefined || !current.find((entry) => entry.id === messageId)?.deliveries?.some((delivery) => delivery.runId === record.runId && delivery.stageId === record.stageId && delivery.sessionId === record.sessionId && delivery.admission === "context") && !await backend.hasPendingStageDeliveryReceipt?.(runId, messageId, contextReceipt))) {
+            unconfirmedRecords.push(record);
+          }
+        }
+        current = reconcileDeliveryCounts(backend, runId, current);
+        if (current !== run.pendingStageMessages) {
+          run.pendingStageMessages = [...current];
+          context.bumpAndNotify();
+        }
+        const next = recordPendingStageMessageDeliveries(current, runId, messageId, unconfirmedRecords, deliveredAt);
         if (next === current)
           return false;
-        await persistTransition(backend, runId, next);
-        run.pendingStageMessages = [...next];
+        const messages = await persistTransition(backend, runId, next, context);
+        run.pendingStageMessages = [...messages];
         context.bumpAndNotify();
         return true;
       });
@@ -9679,12 +10013,13 @@ function createPendingStageDeliveryStoreMethods(context) {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
+        const current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
         const next = settleStickyPendingStageMessageDelivered(current, runId, messageId, settledAt);
         if (next === current)
           return false;
-        await persistTransition(backend, runId, next);
-        run.pendingStageMessages = [...next];
+        const messages = await persistTransition(backend, runId, next, context);
+        run.pendingStageMessages = [...messages];
         context.bumpAndNotify();
         return true;
       });
@@ -9703,11 +10038,75 @@ function resolvePendingStageIdentity(run, stageKey) {
     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`);
+async function persistTransition(backend, runId, messages, context) {
+  let retained = reconcileDeliveryCounts(backend, runId, messages);
+  try {
+    if (backend.archivePendingStageDeliveryReceipt !== undefined && backend.hasPendingStageDeliveryReceipt !== undefined) {
+      const compacted = [];
+      for (const entry of retained) {
+        if (entry.sticky !== true || entry.deliveries === undefined) {
+          compacted.push(entry);
+          continue;
+        }
+        const latest = new Map;
+        entry.deliveries.forEach((delivery, index) => {
+          latest.set(JSON.stringify([delivery.runId, delivery.stageId, delivery.admission]), index);
+        });
+        const deliveries = [];
+        let archivedThrough = -1;
+        for (let index = 0;index < entry.deliveries.length; index++) {
+          const delivery = entry.deliveries[index];
+          const stage = context.state.runs.find((run) => run.id === delivery.runId)?.stages.find((stage) => stage.id === delivery.stageId);
+          if (entry.status !== "queued" || stage?.status === "completed" || stage?.status === "skipped" || stage?.status === "failed" || latest.get(JSON.stringify([delivery.runId, delivery.stageId, delivery.admission])) !== index && delivery.sessionId !== undefined) {
+            while (archivedThrough < index) {
+              const prefixIndex = archivedThrough + 1;
+              await backend.archivePendingStageDeliveryReceipt(runId, entry.id, entry.deliveries[prefixIndex], {
+                messageRunId: entry.runId,
+                deliveryCount: (entry.deliveryCount ?? entry.deliveries.length) - entry.deliveries.length + prefixIndex + 1
+              });
+              archivedThrough = prefixIndex;
+            }
+          } else {
+            deliveries.push(delivery);
+          }
+        }
+        compacted.push(deliveries.length === entry.deliveries.length ? entry : { ...entry, deliveries });
+      }
+      retained = compacted;
+    }
+    retained = compactStickyStageMessageDeliveries(retained, context.state.runs);
+    if (backend.archivePendingStageMessage !== undefined && backend.readSettledPendingStageMessage !== undefined) {
+      retained = await retainPendingStageMessages(retained, (entry) => backend.archivePendingStageMessage(runId, entry));
+    }
+    if (!await backend.persistPendingStageMessages(runId, retained)) {
+      throw new Error(`atomic-workflows: durable workflow ${runId} is unavailable for pending-stage persistence`);
+    }
+    return retained;
+  } finally {
+    const run = context.findRun(runId);
+    if (run !== undefined) {
+      const current = run.pendingStageMessages ?? [];
+      const recovered = reconcileDeliveryCounts(backend, runId, current);
+      if (recovered !== current) {
+        run.pendingStageMessages = [...recovered];
+        context.bumpAndNotify();
+      }
+    }
   }
 }
+function reconcileDeliveryCounts(backend, runId, messages) {
+  let changed = false;
+  const recovered = messages.map((entry) => {
+    if (entry.sticky !== true)
+      return entry;
+    const count = backend.getPendingStageMessageDeliveryCount?.(runId, entry.id, entry.runId) ?? 0;
+    if (count <= (entry.deliveryCount ?? entry.deliveries?.length ?? 0))
+      return entry;
+    changed = true;
+    return { ...entry, deliveryCount: count };
+  });
+  return changed ? recovered : messages;
+}
 
 // dist/builtin/workflows/src/shared/store-prompt-methods.ts
 function createPromptStoreMethods(context) {
@@ -10728,7 +11127,7 @@ function createWorkflowArtifactRunStateResolver() {
   let backend;
   let backendReady = true;
   try {
-    backend = getDurableBackend();
+    backend = getDurableBackend2();
   } catch {
     backendReady = false;
   }
@@ -10759,7 +11158,7 @@ function createWorkflowArtifactRunStateResolver() {
 async function deleteTerminalDurableEntry(runId) {
   let backend;
   try {
-    backend = getDurableBackend();
+    backend = getDurableBackend2();
   } catch {
     return false;
   }
@@ -11134,4 +11533,4 @@ async function reverify_consolidated_batch(ctx, input) {
   return apply_reverify_results(input.batch, audits);
 }
 
-export { workflowArtifactDirectoryPath, ensureWorkflowArtifactDirectory, createWorkflowArtifactDirectory, record_convergence, convergence_escalation_evidence, finalActionRemaining, stopReviewLoopContradictions, contradictedStopReviewLoopGap, consolidateFindingsBatch, parseFailureDiagnostics, reviewerFailureText, summarizeReviewConvergence, reverify_consolidated_batch };
+export { getDurableBackend2, getAvailableDurableBackend2, workflowArtifactDirectoryPath, ensureWorkflowArtifactDirectory, createWorkflowArtifactDirectory, record_convergence, convergence_escalation_evidence, finalActionRemaining, stopReviewLoopContradictions, contradictedStopReviewLoopGap, consolidateFindingsBatch, parseFailureDiagnostics, reviewerFailureText, summarizeReviewConvergence, reverify_consolidated_batch };

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

@@ -0,0 +1,8 @@
+import {
+  getDurableBackend2,
+  getAvailableDurableBackend2
+} from "./chunk-p3xmajmj.js";
+export {
+  getAvailableDurableBackend2 as getAvailableDurableBackend,
+  getDurableBackend2 as getDurableBackend
+};

package/dist/builtin/workflows/builtin/goal.js

@@ -1,7 +1,7 @@
 import {
   goal_default
-} from "./chunk-gw7rghda.js";
-import"./chunk-9bhs02gm.js";
+} from "./chunk-aqv8ny38.js";
+import"./chunk-p3xmajmj.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/index.js

@@ -14,11 +14,11 @@ import {
 import {
   generate_and_filter_default
 } from "./chunk-kb7s3gx2.js";
-import"./chunk-9bhs02gm.js";
-import"./chunk-z0d03ktm.js";
 import {
   goal_default
-} from "./chunk-gw7rghda.js";
+} from "./chunk-aqv8ny38.js";
+import"./chunk-p3xmajmj.js";
+import"./chunk-z0d03ktm.js";
 import {
   open_claude_design_default
 } from "./chunk-nkj4qhj6.js";
@@ -27,7 +27,7 @@ import {
 } from "./chunk-94f8zfz1.js";
 import {
   ralph_default
-} from "./chunk-gts8wgjr.js";
+} from "./chunk-br4ac9a3.js";
 import {
   tournament_default
 } from "./chunk-wf876n16.js";

package/dist/builtin/workflows/builtin/ralph.js

@@ -1,7 +1,7 @@
 import {
   ralph_default
-} from "./chunk-gts8wgjr.js";
-import"./chunk-9bhs02gm.js";
+} from "./chunk-br4ac9a3.js";
+import"./chunk-p3xmajmj.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";