@bastani/atomic 0.9.44-alpha.5 → 0.9.44-alpha.6

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -274,6 +274,12 @@ class ScopedDurableBackend {
   getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
     return this.inner.getPendingStageMessageDeliveryCount?.(this.scope.rootWorkflowId, messageId, logicalRunId) ?? 0;
   }
+  pendingStageDeliveryReceiptChanges(_workflowId, cursor) {
+    return this.inner.pendingStageDeliveryReceiptChanges?.(this.scope.rootWorkflowId, cursor);
+  }
+  pendingStageDeliveryCountVersion(_workflowId) {
+    return this.inner.pendingStageDeliveryCountVersion?.(this.scope.rootWorkflowId);
+  }
   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);
   }
@@ -3136,8 +3142,11 @@ var init_pending_stage_delivery = __esm(() => {
 });
 
 // dist/builtin/workflows/src/shared/pending-stage-retention.ts
+function isSettledPendingStageMessage(entry) {
+  return entry.status === "delivered" || entry.status === "undeliverable" && entry.undeliverableNotifiedAt !== undefined;
+}
 async function retainPendingStageMessages(messages, archive) {
-  const settled = messages.filter((entry) => entry.status === "delivered" || entry.status === "undeliverable" && entry.undeliverableNotifiedAt !== undefined);
+  const settled = messages.filter(isSettledPendingStageMessage);
   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);
@@ -3145,53 +3154,210 @@ async function retainPendingStageMessages(messages, archive) {
 }
 var PENDING_STAGE_SETTLED_MESSAGE_LIMIT = 50;
 
+// dist/builtin/workflows/src/shared/pending-stage-transition-ledger.ts
+class PendingStageTransitionLedger {
+  compacted = [];
+  settled = 0;
+  stages = new Map;
+  fixed = new WeakSet;
+  reconciled = [];
+  reconciledVersion;
+  reconcile(backend, runId, messages) {
+    if (backend.getPendingStageMessageDeliveryCount === undefined)
+      return messages;
+    const version = backend.pendingStageDeliveryCountVersion?.(runId);
+    const base = version !== undefined && version === this.reconciledVersion ? this.reconciled : undefined;
+    let recovered;
+    for (let index = 0;index < messages.length; index++) {
+      const entry = messages[index];
+      if (entry.sticky !== true || base !== undefined && base[index] === entry)
+        continue;
+      const count = backend.getPendingStageMessageDeliveryCount(runId, entry.id, entry.runId);
+      if (count <= (entry.deliveryCount ?? entry.deliveries?.length ?? 0))
+        continue;
+      recovered ??= [...messages];
+      recovered[index] = { ...entry, deliveryCount: count };
+    }
+    const result = recovered ?? messages;
+    this.reconciled = result;
+    this.reconciledVersion = version;
+    return result;
+  }
+  async compact(backend, runId, messages, runs, archiveSettled) {
+    const stageStatus = createStageStatusLookup(runs);
+    const endedStages = [];
+    const dirty = new Set;
+    for (const [deliveryRunId, byStage] of this.stages) {
+      for (const [stageId, entries] of byStage) {
+        if (!isEndedStageStatus(stageStatus(deliveryRunId, stageId)))
+          continue;
+        endedStages.push([deliveryRunId, stageId]);
+        for (const entry of entries)
+          dirty.add(entry);
+      }
+    }
+    const base = this.compacted;
+    const output = [];
+    const removed = [];
+    const added = [];
+    let settled = this.settled;
+    const length = Math.max(base.length, messages.length);
+    for (let index = 0;index < length; index++) {
+      const previous = base[index];
+      const entry = messages[index];
+      if (previous === entry && !dirty.has(entry)) {
+        output.push(entry);
+        continue;
+      }
+      if (previous !== undefined) {
+        removed.push(previous);
+        if (isSettledPendingStageMessage(previous))
+          settled--;
+      }
+      if (entry === undefined)
+        continue;
+      if (isSettledPendingStageMessage(entry))
+        settled++;
+      const next = this.fixed.has(entry) && !dirty.has(entry) ? entry : await compactEntryDeliveries(backend, runId, entry, stageStatus);
+      output.push(next);
+      added.push(next);
+    }
+    let retained = output;
+    if (archiveSettled !== undefined && settled > PENDING_STAGE_SETTLED_MESSAGE_LIMIT) {
+      retained = await retainPendingStageMessages(output, archiveSettled);
+      settled = PENDING_STAGE_SETTLED_MESSAGE_LIMIT;
+    }
+    return {
+      messages: retained,
+      commit: () => {
+        for (const [deliveryRunId, stageId] of endedStages) {
+          const byStage = this.stages.get(deliveryRunId);
+          byStage?.delete(stageId);
+          if (byStage?.size === 0)
+            this.stages.delete(deliveryRunId);
+        }
+        for (const entry of dirty)
+          this.fixed.delete(entry);
+        for (const entry of removed)
+          this.unindex(entry);
+        for (const entry of added)
+          this.index(entry);
+        this.compacted = retained;
+        this.settled = settled;
+      }
+    };
+  }
+  index(entry) {
+    this.fixed.add(entry);
+    for (const delivery of entry.deliveries ?? []) {
+      let byStage = this.stages.get(delivery.runId);
+      if (byStage === undefined) {
+        byStage = new Map;
+        this.stages.set(delivery.runId, byStage);
+      }
+      let entries = byStage.get(delivery.stageId);
+      if (entries === undefined) {
+        entries = new Set;
+        byStage.set(delivery.stageId, entries);
+      }
+      entries.add(entry);
+    }
+  }
+  unindex(entry) {
+    this.fixed.delete(entry);
+    for (const delivery of entry.deliveries ?? []) {
+      const byStage = this.stages.get(delivery.runId);
+      const entries = byStage?.get(delivery.stageId);
+      if (entries === undefined)
+        continue;
+      entries.delete(entry);
+      if (entries.size > 0)
+        continue;
+      byStage.delete(delivery.stageId);
+      if (byStage.size === 0)
+        this.stages.delete(delivery.runId);
+    }
+  }
+}
+function isCompactingBackend(backend) {
+  return backend.archivePendingStageDeliveryReceipt !== undefined && backend.hasPendingStageDeliveryReceipt !== undefined;
+}
+function createStageStatusLookup(runs) {
+  let runById;
+  return (runId, stageId) => {
+    if (runById === undefined) {
+      runById = new Map;
+      for (const run of runs)
+        if (!runById.has(run.id))
+          runById.set(run.id, run);
+    }
+    return runById.get(runId)?.stages.find((stage) => stage.id === stageId)?.status;
+  };
+}
+function isEndedStageStatus(status) {
+  return status === "completed" || status === "skipped" || status === "failed";
+}
+async function compactEntryDeliveries(backend, runId, entry, stageStatus) {
+  if (entry.sticky !== true || entry.deliveries === undefined)
+    return entry;
+  const latest = new Map;
+  entry.deliveries.forEach((delivery, index) => {
+    latest.set(deliverySlot(delivery), index);
+  });
+  const deliveries = [];
+  let archivedThrough = -1;
+  for (let index = 0;index < entry.deliveries.length; index++) {
+    const delivery = entry.deliveries[index];
+    if (entry.status !== "queued" || isEndedStageStatus(stageStatus(delivery.runId, delivery.stageId)) || latest.get(deliverySlot(delivery)) !== index && delivery.sessionId !== undefined) {
+      while (archivedThrough < index) {
+        const prefixIndex = archivedThrough + 1;
+        const receipt = entry.deliveries[prefixIndex];
+        if (!await backend.hasPendingStageDeliveryReceipt(runId, entry.id, receipt, entry.runId))
+          await backend.archivePendingStageDeliveryReceipt(runId, entry.id, receipt, {
+            messageRunId: entry.runId,
+            deliveryCount: (entry.deliveryCount ?? entry.deliveries.length) - entry.deliveries.length + prefixIndex + 1
+          });
+        archivedThrough = prefixIndex;
+      }
+    } else {
+      deliveries.push(delivery);
+    }
+  }
+  return deliveries.length === entry.deliveries.length ? entry : { ...entry, deliveries };
+}
+function deliverySlot(delivery) {
+  return `${delivery.runId.length}:${delivery.runId}${delivery.stageId.length}:${delivery.stageId}${delivery.admission === undefined ? "-" : `+${delivery.admission}`}`;
+}
+var init_pending_stage_transition_ledger = () => {};
+
 // 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;
-  };
+  const ledgers = new PendingStageLedgers;
+  const batches = new PendingStageTransitionBatches(context, ledgers);
   return {
     async queueStageMessage(input, senderGroup, runGroup, backend) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, backend, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const stageIdentity = resolvePendingStageIdentity(run, input.stageKey);
         const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
-        const result = queueStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup, stageIdentity);
+        const result = queueStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), receipt], input, senderGroup, runGroup, stageIdentity);
         if (result.ok && !result.deduplicated) {
-          const messages = await persistTransition(backend, input.runId, result.messages, context);
-          const live = context.findRun(input.runId) ?? run;
-          live.pendingStageMessages = [...messages];
-          context.bumpAndNotify();
+          await batch.apply(backend, input.runId, result.messages);
         }
-        return result.ok ? { ...result, messages: (context.findRun(input.runId) ?? run).pendingStageMessages ?? [] } : result;
+        return result.ok ? { ...result, messages: batch.messages(context.findRun(input.runId) ?? run) } : result;
       });
     },
     async validateLiveStageMessage(input) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, undefined, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const availableBackend = availableRunDurableBackend(context.state.runs, input.runId) ?? context.backend;
         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));
+        const result = queueStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), 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" };
         }
@@ -3213,77 +3379,65 @@ function createPendingStageDeliveryStoreMethods(context) {
       return pendingStageMessagesFor(run?.pendingStageMessages ?? [], runId, stageKey, run === undefined ? undefined : resolvePendingStageIdentity(run, stageKey));
     },
     async markPendingStageMessageDelivered(runId, stageKey, messageId, deliveredAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageDelivered(current, runId, stageKey, messageId, deliveredAt, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async markPendingStageMessageUndeliverable(runId, stageKey, messageId, reason, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageUndeliverable(current, runId, stageKey, messageId, reason, resolvePendingStageIdentity(run, stageKey));
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async markPendingStageMessageUndeliverableNotified(runId, stageKey, messageId, notificationId, notifiedAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
-        const current = run.pendingStageMessages ?? [];
+        const current = batch.messages(run);
         const next = markPendingStageMessageUndeliverableNotified(current, runId, stageKey, messageId, notificationId, notifiedAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async queueStickyStageMessage(input, senderGroup, runGroup, backend) {
-      return await serialize(input.runId, async () => {
+      return await batches.run(input.runId, backend, async (batch) => {
         const run = context.findRun(input.runId);
         if (run === undefined)
           return;
         const receipt = await backend.readSettledPendingStageMessage?.(input.runId, input.message.id);
-        const result = queueStickyStageMessage(receipt === undefined ? run.pendingStageMessages ?? [] : [...run.pendingStageMessages ?? [], receipt], input, senderGroup, runGroup);
+        const result = queueStickyStageMessage(receipt === undefined ? batch.messages(run) : [...batch.messages(run), receipt], input, senderGroup, runGroup);
         if (result.ok && !result.deduplicated) {
-          const messages = await persistTransition(backend, input.runId, result.messages, context);
-          const live = context.findRun(input.runId) ?? run;
-          live.pendingStageMessages = [...messages];
-          context.bumpAndNotify();
+          await batch.apply(backend, input.runId, result.messages);
         }
-        return result.ok ? { ...result, messages: (context.findRun(input.runId) ?? run).pendingStageMessages ?? [] } : result;
+        return result.ok ? { ...result, messages: batch.messages(context.findRun(input.runId) ?? run) } : result;
       });
     },
     async recordPendingStageMessageDeliveries(runId, messageId, records, deliveredAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
         if (records.length === 0)
           await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
-        let current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
+        let current = ledgers.for(run).reconcile(backend, runId, batch.messages(run));
         const unconfirmedRecords = [];
         for (const record of records) {
           const contextReceipt = record.admission === "transport" ? { ...record, admission: "context" } : undefined;
@@ -3291,35 +3445,26 @@ function createPendingStageDeliveryStoreMethods(context) {
             unconfirmedRecords.push(record);
           }
         }
-        current = reconcileDeliveryCounts(backend, runId, current);
-        if (current !== run.pendingStageMessages) {
-          run.pendingStageMessages = [...current];
-          context.bumpAndNotify();
-        }
+        current = ledgers.for(run).reconcile(backend, runId, current);
+        batch.reconciled(run, current);
         const next = recordPendingStageMessageDeliveries(current, runId, messageId, unconfirmedRecords, deliveredAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     },
     async settleStickyPendingStageMessageDelivered(runId, messageId, settledAt, backend) {
-      return await serialize(runId, async () => {
+      return await batches.run(runId, backend, async (batch) => {
         const run = context.findRun(runId);
         if (run === undefined)
           return false;
         await backend.readPendingStageMessageDeliveryCount?.(runId, messageId, runId);
-        const current = reconcileDeliveryCounts(backend, runId, run.pendingStageMessages ?? []);
+        const current = ledgers.for(run).reconcile(backend, runId, batch.messages(run));
         const next = settleStickyPendingStageMessageDelivered(current, runId, messageId, settledAt);
         if (next === current)
           return false;
-        const messages = await persistTransition(backend, runId, next, context);
-        const live = context.findRun(runId) ?? run;
-        live.pendingStageMessages = [...messages];
-        context.bumpAndNotify();
+        await batch.apply(backend, runId, next);
         return true;
       });
     }
@@ -3337,78 +3482,186 @@ function resolvePendingStageIdentity(run, stageKey) {
     aliases: stage.id === stage.name ? [stage.id] : [stage.id, stage.name]
   };
 }
-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 });
+
+class PendingStageTransitionBatches {
+  queues = new Map;
+  context;
+  ledgers;
+  constructor(context, ledgers) {
+    this.context = context;
+    this.ledgers = ledgers;
+  }
+  run(runId, backend, step) {
+    return new Promise((resolve, reject) => {
+      const transition = {
+        backend,
+        step,
+        resolve: (value2) => resolve(value2),
+        reject
+      };
+      const queue = this.queues.get(runId);
+      if (queue !== undefined) {
+        queue.push(transition);
+        return;
+      }
+      const created = [transition];
+      this.queues.set(runId, created);
+      Promise.resolve().then(() => this.drain(runId, created));
+    });
+  }
+  async drain(runId, queue) {
+    while (queue.length > 0)
+      await this.runBatch(runId, takeBatch(queue));
+    this.queues.delete(runId);
+  }
+  async runBatch(runId, transitions) {
+    const batch = new PendingStageTransitionBatch(this.context, this.ledgers, runId);
+    const outcomes = [];
+    for (const transition of transitions) {
+      const changedBefore = batch.changed;
+      try {
+        const value2 = await transition.step(batch);
+        outcomes.push({ ok: true, value: value2, uncommitted: changedBefore || batch.changed });
+      } catch (error) {
+        outcomes.push({ ok: false, error });
       }
-      retained = compacted;
     }
-    retained = compactStickyStageMessageDeliveries(retained, context.state.runs);
-    if (backend.archivePendingStageMessage !== undefined && backend.readSettledPendingStageMessage !== undefined) {
-      retained = await retainPendingStageMessages(retained, (entry) => backend.archivePendingStageMessage(runId, entry));
+    let failure;
+    try {
+      await batch.persist();
+    } catch (error) {
+      failure = { error };
+    }
+    transitions.forEach((transition, index) => {
+      const outcome = outcomes[index];
+      if (!outcome.ok)
+        transition.reject(outcome.error);
+      else if (failure !== undefined && outcome.uncommitted)
+        transition.reject(failure.error);
+      else
+        transition.resolve(outcome.value);
+    });
+  }
+}
+function takeBatch(queue) {
+  let count = 1;
+  let backend = queue[0].backend;
+  while (count < queue.length && count < PENDING_STAGE_TRANSITION_BATCH_LIMIT) {
+    const next = queue[count].backend;
+    if (next !== undefined && backend !== undefined && next !== backend)
+      break;
+    backend ??= next;
+    count++;
+  }
+  return queue.splice(0, count);
+}
+
+class PendingStageTransitionBatch {
+  changed = false;
+  list;
+  pending;
+  context;
+  ledgers;
+  runId;
+  constructor(context, ledgers, runId) {
+    this.context = context;
+    this.ledgers = ledgers;
+    this.runId = runId;
+  }
+  messages(run) {
+    return this.list ?? run.pendingStageMessages ?? [];
+  }
+  reconciled(run, messages) {
+    if (this.changed) {
+      this.list = messages;
+      return;
+    }
+    if (messages !== run.pendingStageMessages) {
+      run.pendingStageMessages = [...messages];
+      this.context.bumpAndNotify();
     }
-    if (!await backend.persistPendingStageMessages(runId, retained)) {
-      throw new Error(`atomic-workflows: durable workflow ${runId} is unavailable for pending-stage persistence`);
+  }
+  async apply(backend, runId, messages) {
+    const run = this.context.findRun(runId);
+    try {
+      const compacted = await compactTransition(backend, runId, messages, this.context, this.ledgers, run);
+      this.list = compacted.messages;
+      this.changed = true;
+      this.pending = { backend, messages: compacted.messages, commit: compacted.commit, run };
+      return compacted.messages;
+    } catch (error) {
+      if (this.changed && this.list !== undefined) {
+        const ledger = run === undefined ? new PendingStageTransitionLedger : this.ledgers.for(run);
+        this.list = ledger.reconcile(backend, runId, this.list);
+      } else
+        reconcileLive(backend, runId, this.context, this.ledgers);
+      throw error;
     }
-    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();
+  }
+  async persist() {
+    if (this.pending === undefined)
+      return;
+    const { backend, messages, commit, run } = this.pending;
+    const published = this.list ?? messages;
+    try {
+      if (!await backend.persistPendingStageMessages(this.runId, messages)) {
+        throw new Error(`atomic-workflows: durable workflow ${this.runId} is unavailable for pending-stage persistence`);
       }
-    }
+      commit?.();
+    } finally {
+      reconcileLive(backend, this.runId, this.context, this.ledgers);
+    }
+    const live = this.context.findRun(this.runId) ?? run;
+    if (live !== undefined)
+      live.pendingStageMessages = [...published];
+    this.context.bumpAndNotify();
+  }
+}
+async function compactTransition(backend, runId, messages, context, ledgers, run) {
+  const ledger = run === undefined ? new PendingStageTransitionLedger : ledgers.for(run);
+  const reconciled = ledger.reconcile(backend, runId, messages);
+  const archiveSettled = backend.archivePendingStageMessage !== undefined && backend.readSettledPendingStageMessage !== undefined ? (entry) => backend.archivePendingStageMessage(runId, entry) : undefined;
+  if (isCompactingBackend(backend)) {
+    return await ledger.compact(backend, runId, reconciled, context.state.runs, archiveSettled);
+  }
+  let retained = compactStickyStageMessageDeliveries(reconciled, context.state.runs);
+  if (archiveSettled !== undefined)
+    retained = await retainPendingStageMessages(retained, archiveSettled);
+  if (run !== undefined)
+    ledgers.reset(run);
+  return { messages: retained };
+}
+function reconcileLive(backend, runId, context, ledgers) {
+  const current = context.findRun(runId);
+  if (current === undefined)
+    return;
+  const messages = current.pendingStageMessages ?? [];
+  const recovered = ledgers.for(current).reconcile(backend, runId, messages);
+  if (recovered !== messages) {
+    current.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;
+
+class PendingStageLedgers {
+  ledgers = new WeakMap;
+  for(run) {
+    let ledger = this.ledgers.get(run);
+    if (ledger === undefined) {
+      ledger = new PendingStageTransitionLedger;
+      this.ledgers.set(run, ledger);
+    }
+    return ledger;
+  }
+  reset(run) {
+    this.ledgers.delete(run);
+  }
 }
+var PENDING_STAGE_TRANSITION_BATCH_LIMIT = 256;
 var init_store_pending_stage_delivery_methods = __esm(() => {
   init_run_owner_backend();
   init_pending_stage_delivery();
+  init_pending_stage_transition_ledger();
 });
 
 // dist/builtin/workflows/src/shared/store-prompt-methods.ts
@@ -4998,6 +5251,204 @@ var init_resume_eligibility = () => {};
 // dist/builtin/workflows/src/durable/types.ts
 var DURABLE_TOOL_TOPOLOGY_VERSION = 1, DURABLE_STAGE_TOPOLOGY_VERSION = 1, DURABLE_BOUNDARY_TOPOLOGY_VERSION = 1;
 
+// dist/builtin/workflows/src/durable/stage-topology-validation.ts
+function immutableStageGroupError(stages) {
+  const occurrenceError = promptOccurrenceIdentityError(stages);
+  if (occurrenceError !== undefined)
+    return occurrenceError;
+  const byReplayKey = groupByDurableStageKey(stages);
+  for (const group of byReplayKey.values()) {
+    const firstName = group[0]?.name;
+    if (group.some((stage) => stage.name !== firstName))
+      return "stage name drift within one replay-key group";
+    const topologies = group.flatMap((stage) => stage.topology === undefined ? [] : [stage.topology]);
+    const first = topologies[0];
+    if (first === undefined)
+      continue;
+    if (topologies.some((topology) => topology.version !== DURABLE_STAGE_TOPOLOGY_VERSION || topology.stageId !== first.stageId || !sameStrings(topology.parentIds, first.parentIds) || topology.sourceOrder !== first.sourceOrder || !sameOptionalRun(topology.run, first.run))) {
+      return "immutable stage identity drift within one replay-key group";
+    }
+  }
+  return;
+}
+function directChildTopologyError(stages, replayScope, expectedRun, allowedNodeIds = new Set) {
+  return directChildTopologyErrorFromRecords({
+    claiming: stages.filter((stage) => stage.topology?.run?.runId === expectedRun.runId),
+    direct: (claiming) => {
+      const directKeys = new Set(claiming.map((stage) => durableStageGroupKey(stage)));
+      return stages.filter((stage) => directKeys.has(durableStageGroupKey(stage)));
+    }
+  }, replayScope, expectedRun, allowedNodeIds);
+}
+function directChildTopologyErrorFromRecords(records, replayScope, expectedRun, allowedNodeIds = new Set) {
+  const prefix = `${replayScope}:`;
+  const claiming = records.claiming;
+  if (claiming.some((stage) => !stage.replayKey.startsWith(prefix))) {
+    return "child run topology exists outside its durable invocation scope";
+  }
+  if (claiming.some((stage) => !sameRun(stage.topology?.run, expectedRun))) {
+    return "child checkpoint ownership is not reciprocal";
+  }
+  const direct = records.direct(claiming);
+  const immutableError = immutableStageGroupError(direct);
+  if (immutableError !== undefined)
+    return immutableError;
+  const merged = [];
+  for (const group of groupByDurableStageKey(direct).values()) {
+    const topology = group.find((stage) => stage.topology?.run?.runId === expectedRun.runId)?.topology;
+    if (topology === undefined)
+      return "direct child stage group lacks owning-run topology";
+    if (topology.version !== DURABLE_STAGE_TOPOLOGY_VERSION || topology.sourceOrder === undefined) {
+      return "direct child stage topology lacks current source identity";
+    }
+    if (topology.stageId.length === 0)
+      return "direct child stage id is empty";
+    merged.push(topology);
+  }
+  const ids = new Set(allowedNodeIds);
+  const stageIds = new Set;
+  const orders = new Set;
+  for (const topology of merged) {
+    if (stageIds.has(topology.stageId) || ids.has(topology.stageId))
+      return "direct child stage ids are not unique";
+    stageIds.add(topology.stageId);
+    ids.add(topology.stageId);
+    if (topology.sourceOrder !== undefined) {
+      if (orders.has(topology.sourceOrder))
+        return "direct child source orders are not unique";
+      orders.add(topology.sourceOrder);
+    }
+  }
+  if (merged.some((topology) => topology.parentIds.some((parentId) => !ids.has(parentId)))) {
+    return "direct child stage references an unknown parent";
+  }
+  return hasCycle(merged) ? "direct child stage topology contains a cycle" : undefined;
+}
+function owningBoundaryIdError(stages, owningRunId) {
+  const starts = stages.filter((stage) => stage.topology?.run?.runId === owningRunId && stage.topology.boundary?.event === "start");
+  const seen = new Map;
+  for (const start of starts) {
+    const stageId = start.topology.stageId;
+    if (stageId.length === 0)
+      return "owning-run boundary stage id is empty";
+    const prior = seen.get(stageId);
+    if (prior !== undefined && prior !== start.replayKey)
+      return "owning-run boundary stage id is aliased";
+    seen.set(stageId, start.replayKey);
+  }
+  return;
+}
+function sameRun(actual, expected) {
+  return actual !== undefined && actual.runId === expected.runId && actual.runName === expected.runName && actual.parentRunId === expected.parentRunId && actual.parentStageId === expected.parentStageId && actual.rootRunId === expected.rootRunId;
+}
+function sameStrings(left, right) {
+  return left.length === right.length && left.every((value2, index) => value2 === right[index]);
+}
+function sameOptionalRun(actual, expected) {
+  if (actual === undefined || expected === undefined)
+    return actual === expected;
+  return sameRun(actual, expected);
+}
+function promptOccurrenceIdentityError(stages) {
+  const replayByOccurrence = new Map;
+  const occurrenceByReplayStage = new Map;
+  const stageByReplayOccurrence = new Map;
+  for (const stage of stages) {
+    const topology = stage.topology;
+    const occurrence = topology?.occurrenceKey;
+    if (topology === undefined || occurrence === undefined)
+      continue;
+    const priorReplay = replayByOccurrence.get(occurrence);
+    if (priorReplay !== undefined && priorReplay !== stage.replayKey) {
+      return "prompt occurrence is bound to multiple replay keys";
+    }
+    replayByOccurrence.set(occurrence, stage.replayKey);
+    const replayStage = compositeKey("prompt-stage", stage.replayKey, topology.stageId);
+    const priorOccurrence = occurrenceByReplayStage.get(replayStage);
+    if (priorOccurrence !== undefined && priorOccurrence !== occurrence) {
+      return "prompt stage identity is bound to multiple occurrences";
+    }
+    occurrenceByReplayStage.set(replayStage, occurrence);
+    const replayOccurrence = compositeKey("prompt-occurrence", stage.replayKey, occurrence);
+    const priorStage = stageByReplayOccurrence.get(replayOccurrence);
+    if (priorStage !== undefined && priorStage !== topology.stageId) {
+      return "prompt occurrence is bound to multiple stage identities";
+    }
+    stageByReplayOccurrence.set(replayOccurrence, topology.stageId);
+  }
+  return;
+}
+function durableStageGroupKey(stage) {
+  const occurrence = stage.topology?.occurrenceKey;
+  return occurrence === undefined ? compositeKey("stage-replay", stage.replayKey) : compositeKey("prompt-occurrence", stage.replayKey, occurrence);
+}
+function groupByDurableStageKey(stages) {
+  const groups = new Map;
+  for (const stage of stages) {
+    const key = durableStageGroupKey(stage);
+    const group = groups.get(key) ?? [];
+    group.push(stage);
+    groups.set(key, group);
+  }
+  return groups;
+}
+function compositeKey(domain, ...parts) {
+  return JSON.stringify([domain, ...parts]);
+}
+function hasCycle(topologies) {
+  const parents = new Map(topologies.map((topology) => [topology.stageId, topology.parentIds]));
+  const visiting = new Set;
+  const visited = new Set;
+  const cyclic = (stageId) => {
+    if (visiting.has(stageId))
+      return true;
+    if (visited.has(stageId))
+      return false;
+    visiting.add(stageId);
+    if ((parents.get(stageId) ?? []).some(cyclic))
+      return true;
+    visiting.delete(stageId);
+    visited.add(stageId);
+    return false;
+  };
+  return topologies.some((topology) => cyclic(topology.stageId));
+}
+var init_stage_topology_validation = () => {};
+
+// dist/builtin/workflows/src/durable/workflow-child-result.ts
+function parseWorkflowChildResult(value2) {
+  if (!isOrdinaryObject(value2))
+    return;
+  const workflow = value2.workflow;
+  const runId = value2.runId;
+  const status = value2.status;
+  const exited = value2.exited;
+  const outputs = value2.outputs;
+  const exitReason = value2.exitReason;
+  if (typeof workflow !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
+    return;
+  if (exited === false) {
+    if (status !== "completed" || exitReason !== undefined)
+      return;
+    return value2;
+  }
+  if (exited !== true || !isWorkflowExitStatus(status) || exitReason !== undefined && typeof exitReason !== "string")
+    return;
+  return value2;
+}
+function isWorkflowChildResult(value2) {
+  return parseWorkflowChildResult(value2) !== undefined;
+}
+function isWorkflowExitStatus(value2) {
+  return value2 === "completed" || value2 === "skipped" || value2 === "cancelled" || value2 === "blocked" || value2 === "failed";
+}
+function isOrdinaryObject(value2) {
+  if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
+    return false;
+  const prototype = Object.getPrototypeOf(value2);
+  return prototype === Object.prototype || prototype === null;
+}
+
 // dist/builtin/workflows/src/durable/durable-hash.ts
 import { createHash } from "node:crypto";
 function durableHash(value2) {
@@ -5064,6 +5515,185 @@ function replacePendingStageMessagesForRun(existing, logicalRunId, messages) {
 function pendingStageMessagesForDurableRun(backend, logicalRunId, rootWorkflowId = logicalRunId) {
   return (backend.getWorkflow(rootWorkflowId)?.pendingStageMessages ?? []).filter((entry) => entry.runId === logicalRunId);
 }
+
+class StageReceipts {
+  exact = new Map;
+  anySession = new Map;
+  has(logicalRunId, sessionId, admission) {
+    return this.exact.get(logicalRunId)?.get(sessionId)?.has(admission) ?? false;
+  }
+  hasAnySession(logicalRunId, admission) {
+    return this.anySession.get(logicalRunId)?.has(admission) ?? false;
+  }
+  add(logicalRunId, sessionId, admission) {
+    let bySession = this.exact.get(logicalRunId);
+    if (bySession === undefined) {
+      bySession = new Map;
+      this.exact.set(logicalRunId, bySession);
+    }
+    let admissions = bySession.get(sessionId);
+    if (admissions === undefined) {
+      admissions = new Set;
+      bySession.set(sessionId, admissions);
+    }
+    if (admissions.has(admission))
+      return false;
+    admissions.add(admission);
+    return true;
+  }
+  addAnySession(logicalRunId, admission) {
+    let admissions = this.anySession.get(logicalRunId);
+    if (admissions === undefined) {
+      admissions = new Set;
+      this.anySession.set(logicalRunId, admissions);
+    }
+    if (admissions.has(admission))
+      return false;
+    admissions.add(admission);
+    return true;
+  }
+}
+
+class PendingStageReceiptIndex {
+  workflows = new Map;
+  add(workflowId, messageId, delivery, logicalRunId) {
+    let workflow = this.workflows.get(workflowId);
+    if (workflow === undefined) {
+      workflow = { byMessage: new Map, log: [] };
+      this.workflows.set(workflowId, workflow);
+    }
+    let byRun = workflow.byMessage.get(messageId);
+    if (byRun === undefined) {
+      byRun = new Map;
+      workflow.byMessage.set(messageId, byRun);
+    }
+    let byStage = byRun.get(delivery.runId);
+    if (byStage === undefined) {
+      byStage = new Map;
+      byRun.set(delivery.runId, byStage);
+    }
+    let receipts = byStage.get(delivery.stageId);
+    if (receipts === undefined) {
+      receipts = new StageReceipts;
+      byStage.set(delivery.stageId, receipts);
+    }
+    const added = receipts.add(logicalRunId, delivery.sessionId, delivery.admission);
+    let changed = added;
+    if (receipts.add(logicalRunId, undefined, undefined))
+      changed = true;
+    if (delivery.admission === "context" && delivery.sessionId !== undefined && receipts.addAnySession(logicalRunId, "context"))
+      changed = true;
+    if (changed)
+      workflow.log.push(messageId);
+    return added;
+  }
+  has(workflowId, messageId, delivery, logicalRunId, anySession = false) {
+    const receipts = this.workflows.get(workflowId)?.byMessage.get(messageId)?.get(delivery.runId)?.get(delivery.stageId);
+    if (receipts === undefined)
+      return false;
+    if (anySession && delivery.admission === "context")
+      return receipts.hasAnySession(logicalRunId, delivery.admission) || receipts.hasAnySession(undefined, delivery.admission);
+    return receipts.has(logicalRunId, delivery.sessionId, delivery.admission) || receipts.has(undefined, delivery.sessionId, delivery.admission);
+  }
+  changesSince(workflowId, cursor) {
+    let workflow = this.workflows.get(workflowId);
+    if (workflow === undefined) {
+      workflow = { byMessage: new Map, log: [] };
+      this.workflows.set(workflowId, workflow);
+    }
+    const next = { log: workflow.log, length: workflow.log.length };
+    if (cursor === undefined || cursor.log !== workflow.log || cursor.length > workflow.log.length)
+      return { cursor: next, messageIds: undefined };
+    return { cursor: next, messageIds: workflow.log.slice(cursor.length) };
+  }
+  delete(workflowId) {
+    this.workflows.delete(workflowId);
+  }
+  clear() {
+    this.workflows.clear();
+  }
+}
+function nextVersion() {
+  lastVersion += 1;
+  return lastVersion;
+}
+
+class NestedSnapshotVersion {
+  rootWorkflowId;
+  current = nextVersion();
+  latestCompletedAt = Number.NEGATIVE_INFINITY;
+  replayGroups = new Map;
+  boundaryReplayKeys = new Set;
+  constructor(rootWorkflowId) {
+    this.rootWorkflowId = rootWorkflowId;
+  }
+  get version() {
+    return this.current;
+  }
+  record(checkpoint) {
+    if (!this.isInert(checkpoint))
+      this.current = nextVersion();
+    this.latestCompletedAt = Math.max(this.latestCompletedAt, checkpoint.completedAt);
+    if (checkpoint.kind !== "stage")
+      return;
+    if (checkpoint.topology?.boundary !== undefined)
+      this.boundaryReplayKeys.add(checkpoint.replayKey);
+    if (checkpoint.topology?.occurrenceKey !== undefined)
+      return;
+    const identity = stageIdentity(checkpoint);
+    const exited = parseWorkflowChildResult(checkpoint.output)?.exited === true;
+    const summary = this.replayGroups.get(checkpoint.replayKey);
+    if (summary === undefined) {
+      this.replayGroups.set(checkpoint.replayKey, {
+        name: checkpoint.name,
+        identity,
+        consistent: true,
+        hasOutput: checkpoint.output !== undefined,
+        hasExitedChildOutput: exited
+      });
+      return;
+    }
+    summary.consistent &&= summary.name === checkpoint.name && summary.identity === identity;
+    summary.hasOutput ||= checkpoint.output !== undefined;
+    summary.hasExitedChildOutput ||= exited;
+  }
+  isInert(checkpoint) {
+    if (checkpoint.kind !== "stage" || !checkpoint.checkpointId.startsWith(STAGE_REPLAY_METADATA_CHECKPOINT_PREFIX) || checkpoint.output !== undefined || checkpoint.topology === undefined || checkpoint.topology.boundary !== undefined || checkpoint.topology.occurrenceKey !== undefined || !this.isRootOwned(checkpoint) || checkpoint.completedAt < this.latestCompletedAt) {
+      return false;
+    }
+    const summary = this.replayGroups.get(checkpoint.replayKey);
+    if (summary === undefined || !summary.consistent || !summary.hasOutput || summary.hasExitedChildOutput || summary.name !== checkpoint.name || summary.identity !== stageIdentity(checkpoint)) {
+      return false;
+    }
+    const id = checkpoint.checkpointId;
+    for (let colon = id.indexOf(":");colon >= 0; colon = id.indexOf(":", colon + 1)) {
+      if (this.boundaryReplayKeys.has(id.slice(0, colon)))
+        return false;
+    }
+    return true;
+  }
+  isRootOwned(checkpoint) {
+    const runId = checkpoint.topology?.run?.runId;
+    return runId === undefined || runId === this.rootWorkflowId;
+  }
+}
+function stageIdentity(checkpoint) {
+  const topology = checkpoint.topology;
+  return JSON.stringify([
+    durableStageGroupKey(checkpoint),
+    topology?.version,
+    topology?.stageId,
+    topology?.parentIds,
+    topology?.sourceOrder,
+    topology?.run === undefined ? undefined : [
+      topology.run.runId,
+      topology.run.runName,
+      topology.run.parentRunId,
+      topology.run.parentStageId,
+      topology.run.rootRunId
+    ]
+  ]);
+}
 function checkpointKey(c) {
   return `${c.kind}:${c.checkpointId}`;
 }
@@ -5075,7 +5705,7 @@ class JournalProjection {
   workflows = new Map;
   deletedWorkflowIds = new Set;
   pendingReceipts = new Map;
-  stickyReceipts = new Map;
+  stickyReceipts = new PendingStageReceiptIndex;
   registerWorkflow(handle, authoritativeOwner = false) {
     this.deletedWorkflowIds.delete(handle.workflowId);
     const existing = this.workflows.get(handle.workflowId);
@@ -5123,7 +5753,8 @@ class JournalProjection {
         toolByHash: new Map,
         uiByHash: new Map,
         stageOutputByReplayKey: new Map,
-        stageSessionByReplayKey: new Map
+        stageSessionByReplayKey: new Map,
+        nestedSnapshotVersion: new NestedSnapshotVersion(handle.workflowId)
       });
   }
   applyWorkflowSnapshot(handle) {
@@ -5149,39 +5780,43 @@ class JournalProjection {
     return this.pendingReceipts.get(workflowId)?.get(JSON.stringify([logicalRunId, messageId]));
   }
   stickyDeliveryCounts = new Map;
+  stickyDeliveryCountVersions = new Map;
   getPendingStageMessageDeliveryCount(workflowId, messageId, logicalRunId = workflowId) {
-    return this.stickyDeliveryCounts.get(workflowId)?.get(JSON.stringify([logicalRunId, messageId])) ?? 0;
+    return this.stickyDeliveryCounts.get(workflowId)?.get(logicalRunId)?.get(messageId) ?? 0;
+  }
+  pendingStageDeliveryCountVersion(workflowId) {
+    return this.stickyDeliveryCountVersions.get(workflowId) ?? 0;
+  }
+  bumpDeliveryCountVersion(workflowId) {
+    this.stickyDeliveryCountVersions.set(workflowId, ++deliveryCountEpoch);
   }
   async archivePendingStageDeliveryReceipt(workflowId, messageId, delivery, accounting) {
-    let receipts = this.stickyReceipts.get(workflowId);
-    if (receipts === undefined) {
-      receipts = new Set;
-      this.stickyReceipts.set(workflowId, receipts);
-    }
-    const receiptKey = pendingDeliveryReceiptKey(messageId, delivery, accounting?.messageRunId);
-    const existing = receipts.has(receiptKey);
-    receipts.add(receiptKey);
-    receipts.add(pendingDeliveryReceiptKey(messageId, { ...delivery, sessionId: undefined, admission: undefined }, accounting?.messageRunId));
-    if (delivery.admission === "context" && delivery.sessionId !== undefined)
-      receipts.add(`${pendingDeliveryReceiptKey(messageId, { ...delivery, sessionId: undefined }, accounting?.messageRunId)}:context-any-session`);
-    if (accounting !== undefined && !existing) {
-      let counts = this.stickyDeliveryCounts.get(workflowId);
+    const added = this.stickyReceipts.add(workflowId, messageId, delivery, accounting?.messageRunId);
+    if (accounting !== undefined && added) {
+      let byRun = this.stickyDeliveryCounts.get(workflowId);
+      if (byRun === undefined) {
+        byRun = new Map;
+        this.stickyDeliveryCounts.set(workflowId, byRun);
+      }
+      let counts = byRun.get(accounting.messageRunId);
       if (counts === undefined) {
         counts = new Map;
-        this.stickyDeliveryCounts.set(workflowId, counts);
+        byRun.set(accounting.messageRunId, counts);
       }
-      const key = JSON.stringify([accounting.messageRunId, messageId]);
-      counts.set(key, Math.max(counts.get(key) ?? 0, accounting.deliveryCount));
+      const previous = counts.get(messageId) ?? 0;
+      counts.set(messageId, Math.max(previous, accounting.deliveryCount));
+      if (accounting.deliveryCount > previous)
+        this.bumpDeliveryCountVersion(workflowId);
     }
   }
   async hasPendingStageDeliveryReceipt(workflowId, messageId, delivery, logicalRunId = workflowId) {
-    return [logicalRunId, undefined].some((logicalId) => this.stickyReceipts.get(workflowId)?.has(pendingDeliveryReceiptKey(messageId, delivery, logicalId)) ?? false);
+    return this.stickyReceipts.has(workflowId, messageId, delivery, logicalRunId);
   }
   hasCachedPendingStageDeliveryReceipt(workflowId, messageId, delivery, anySession = false, logicalRunId = workflowId) {
-    return [logicalRunId, undefined].some((logicalId) => {
-      const name = anySession && delivery.admission === "context" ? `${pendingDeliveryReceiptKey(messageId, { ...delivery, sessionId: undefined }, logicalId)}:context-any-session` : pendingDeliveryReceiptKey(messageId, delivery, logicalId);
-      return this.stickyReceipts.get(workflowId)?.has(name) ?? false;
-    });
+    return this.stickyReceipts.has(workflowId, messageId, delivery, logicalRunId, anySession);
+  }
+  pendingStageDeliveryReceiptChanges(workflowId, cursor) {
+    return this.stickyReceipts.changesSince(workflowId, cursor);
   }
   recordCheckpoint(recorded) {
     const checkpoint = recorded.kind === "stage" ? migrateStageSessionCheckpoint(recorded) : recorded;
@@ -5200,6 +5835,7 @@ class JournalProjection {
     if (rec.checkpoints.has(key))
       return;
     rec.checkpoints.set(key, currentCheckpoint);
+    rec.nestedSnapshotVersion.record(currentCheckpoint);
     if (currentCheckpoint.kind === "tool") {
       const existing = rec.toolByHash.get(currentCheckpoint.argsHash);
       if (currentCheckpoint.throwingFailureError === undefined && (existing === undefined || currentCheckpoint.completedAt >= existing.completedAt)) {
@@ -5257,6 +5893,9 @@ class JournalProjection {
   getWorkflow(workflowId) {
     return this.workflows.get(workflowId)?.handle;
   }
+  nestedSnapshotVersion(workflowId) {
+    return this.workflows.get(workflowId)?.nestedSnapshotVersion.version;
+  }
   getLoadableWorkflow(workflowId) {
     return this.getWorkflow(workflowId);
   }
@@ -5334,6 +5973,7 @@ class JournalProjection {
     this.pendingReceipts.delete(workflowId);
     this.stickyReceipts.delete(workflowId);
     this.stickyDeliveryCounts.delete(workflowId);
+    this.bumpDeliveryCountVersion(workflowId);
     this.deletedWorkflowIds.add(workflowId);
   }
   isWorkflowLoadable(workflowId) {
@@ -5344,6 +5984,8 @@ class JournalProjection {
     this.pendingReceipts.clear();
     this.stickyReceipts.clear();
     this.stickyDeliveryCounts.clear();
+    for (const workflowId of this.stickyDeliveryCountVersions.keys())
+      this.bumpDeliveryCountVersion(workflowId);
     this.deletedWorkflowIds.clear();
   }
 }
@@ -5400,13 +6042,10 @@ function toResumableEntry(handle) {
     updatedAt: handle.updatedAt
   };
 }
-function pendingDeliveryReceiptKey(messageId, delivery, logicalRunId) {
-  const identity = [messageId, delivery.runId, delivery.stageId, delivery.sessionId, delivery.admission];
-  return JSON.stringify(logicalRunId === undefined ? identity : ["counted", logicalRunId, ...identity]);
-}
-var SESSION_HEADER_READ_LIMIT_BYTES;
+var SESSION_HEADER_READ_LIMIT_BYTES, STAGE_REPLAY_METADATA_CHECKPOINT_PREFIX = "stage-replay-meta:", lastVersion = 0, deliveryCountEpoch = 0;
 var init_backend = __esm(() => {
   init_resume_eligibility();
+  init_stage_topology_validation();
   init_durable_hash();
   SESSION_HEADER_READ_LIMIT_BYTES = 64 * 1024;
 });
@@ -5490,205 +6129,24 @@ async function migrateLegacyStageSession(store, sessionId, sessionFile) {
 }
 var init_stage_session_store = () => {};
 
-// dist/builtin/workflows/src/durable/stage-topology-validation.ts
-function immutableStageGroupError(stages) {
-  const occurrenceError = promptOccurrenceIdentityError(stages);
-  if (occurrenceError !== undefined)
-    return occurrenceError;
-  const byReplayKey = groupByDurableStageKey(stages);
-  for (const group of byReplayKey.values()) {
-    const firstName = group[0]?.name;
-    if (group.some((stage) => stage.name !== firstName))
-      return "stage name drift within one replay-key group";
-    const topologies = group.flatMap((stage) => stage.topology === undefined ? [] : [stage.topology]);
-    const first = topologies[0];
-    if (first === undefined)
-      continue;
-    if (topologies.some((topology) => topology.version !== DURABLE_STAGE_TOPOLOGY_VERSION || topology.stageId !== first.stageId || !sameStrings(topology.parentIds, first.parentIds) || topology.sourceOrder !== first.sourceOrder || !sameOptionalRun(topology.run, first.run))) {
-      return "immutable stage identity drift within one replay-key group";
-    }
-  }
-  return;
-}
-function directChildTopologyError(stages, replayScope, expectedRun, allowedNodeIds = new Set) {
-  const prefix = `${replayScope}:`;
-  const claiming = stages.filter((stage) => stage.topology?.run?.runId === expectedRun.runId);
-  if (claiming.some((stage) => !stage.replayKey.startsWith(prefix))) {
-    return "child run topology exists outside its durable invocation scope";
-  }
-  if (claiming.some((stage) => !sameRun(stage.topology?.run, expectedRun))) {
-    return "child checkpoint ownership is not reciprocal";
-  }
-  const directKeys = new Set(claiming.map((stage) => durableStageGroupKey(stage)));
-  const direct = stages.filter((stage) => directKeys.has(durableStageGroupKey(stage)));
-  const immutableError = immutableStageGroupError(direct);
-  if (immutableError !== undefined)
-    return immutableError;
-  const merged = [];
-  for (const group of groupByDurableStageKey(direct).values()) {
-    const topology = group.find((stage) => stage.topology?.run?.runId === expectedRun.runId)?.topology;
-    if (topology === undefined)
-      return "direct child stage group lacks owning-run topology";
-    if (topology.version !== DURABLE_STAGE_TOPOLOGY_VERSION || topology.sourceOrder === undefined) {
-      return "direct child stage topology lacks current source identity";
-    }
-    if (topology.stageId.length === 0)
-      return "direct child stage id is empty";
-    merged.push(topology);
-  }
-  const ids = new Set(allowedNodeIds);
-  const stageIds = new Set;
-  const orders = new Set;
-  for (const topology of merged) {
-    if (stageIds.has(topology.stageId) || ids.has(topology.stageId))
-      return "direct child stage ids are not unique";
-    stageIds.add(topology.stageId);
-    ids.add(topology.stageId);
-    if (topology.sourceOrder !== undefined) {
-      if (orders.has(topology.sourceOrder))
-        return "direct child source orders are not unique";
-      orders.add(topology.sourceOrder);
-    }
-  }
-  if (merged.some((topology) => topology.parentIds.some((parentId) => !ids.has(parentId)))) {
-    return "direct child stage references an unknown parent";
-  }
-  return hasCycle(merged) ? "direct child stage topology contains a cycle" : undefined;
-}
-function owningBoundaryIdError(stages, owningRunId) {
-  const starts = stages.filter((stage) => stage.topology?.run?.runId === owningRunId && stage.topology.boundary?.event === "start");
-  const seen = new Map;
-  for (const start of starts) {
-    const stageId = start.topology.stageId;
-    if (stageId.length === 0)
-      return "owning-run boundary stage id is empty";
-    const prior = seen.get(stageId);
-    if (prior !== undefined && prior !== start.replayKey)
-      return "owning-run boundary stage id is aliased";
-    seen.set(stageId, start.replayKey);
-  }
-  return;
-}
-function sameRun(actual, expected) {
-  return actual !== undefined && actual.runId === expected.runId && actual.runName === expected.runName && actual.parentRunId === expected.parentRunId && actual.parentStageId === expected.parentStageId && actual.rootRunId === expected.rootRunId;
-}
-function sameStrings(left, right) {
-  return left.length === right.length && left.every((value2, index) => value2 === right[index]);
-}
-function sameOptionalRun(actual, expected) {
-  if (actual === undefined || expected === undefined)
-    return actual === expected;
-  return sameRun(actual, expected);
-}
-function promptOccurrenceIdentityError(stages) {
-  const replayByOccurrence = new Map;
-  const occurrenceByReplayStage = new Map;
-  const stageByReplayOccurrence = new Map;
-  for (const stage of stages) {
-    const topology = stage.topology;
-    const occurrence = topology?.occurrenceKey;
-    if (topology === undefined || occurrence === undefined)
-      continue;
-    const priorReplay = replayByOccurrence.get(occurrence);
-    if (priorReplay !== undefined && priorReplay !== stage.replayKey) {
-      return "prompt occurrence is bound to multiple replay keys";
-    }
-    replayByOccurrence.set(occurrence, stage.replayKey);
-    const replayStage = compositeKey("prompt-stage", stage.replayKey, topology.stageId);
-    const priorOccurrence = occurrenceByReplayStage.get(replayStage);
-    if (priorOccurrence !== undefined && priorOccurrence !== occurrence) {
-      return "prompt stage identity is bound to multiple occurrences";
-    }
-    occurrenceByReplayStage.set(replayStage, occurrence);
-    const replayOccurrence = compositeKey("prompt-occurrence", stage.replayKey, occurrence);
-    const priorStage = stageByReplayOccurrence.get(replayOccurrence);
-    if (priorStage !== undefined && priorStage !== topology.stageId) {
-      return "prompt occurrence is bound to multiple stage identities";
-    }
-    stageByReplayOccurrence.set(replayOccurrence, topology.stageId);
-  }
-  return;
-}
-function durableStageGroupKey(stage) {
-  const occurrence = stage.topology?.occurrenceKey;
-  return occurrence === undefined ? compositeKey("stage-replay", stage.replayKey) : compositeKey("prompt-occurrence", stage.replayKey, occurrence);
-}
-function groupByDurableStageKey(stages) {
-  const groups = new Map;
-  for (const stage of stages) {
-    const key = durableStageGroupKey(stage);
-    const group = groups.get(key) ?? [];
-    group.push(stage);
-    groups.set(key, group);
-  }
-  return groups;
-}
-function compositeKey(domain, ...parts) {
-  return JSON.stringify([domain, ...parts]);
-}
-function hasCycle(topologies) {
-  const parents = new Map(topologies.map((topology) => [topology.stageId, topology.parentIds]));
-  const visiting = new Set;
-  const visited = new Set;
-  const cyclic = (stageId) => {
-    if (visiting.has(stageId))
-      return true;
-    if (visited.has(stageId))
-      return false;
-    visiting.add(stageId);
-    if ((parents.get(stageId) ?? []).some(cyclic))
-      return true;
-    visiting.delete(stageId);
-    visited.add(stageId);
-    return false;
-  };
-  return topologies.some((topology) => cyclic(topology.stageId));
-}
-var init_stage_topology_validation = () => {};
-
-// dist/builtin/workflows/src/durable/workflow-child-result.ts
-function parseWorkflowChildResult(value2) {
-  if (!isOrdinaryObject(value2))
-    return;
-  const workflow = value2.workflow;
-  const runId = value2.runId;
-  const status = value2.status;
-  const exited = value2.exited;
-  const outputs = value2.outputs;
-  const exitReason = value2.exitReason;
-  if (typeof workflow !== "string" || typeof runId !== "string" || !isOrdinaryObject(outputs))
-    return;
-  if (exited === false) {
-    if (status !== "completed" || exitReason !== undefined)
-      return;
-    return value2;
-  }
-  if (exited !== true || !isWorkflowExitStatus(status) || exitReason !== undefined && typeof exitReason !== "string")
-    return;
-  return value2;
-}
-function isWorkflowChildResult(value2) {
-  return parseWorkflowChildResult(value2) !== undefined;
-}
-function isWorkflowExitStatus(value2) {
-  return value2 === "completed" || value2 === "skipped" || value2 === "cancelled" || value2 === "blocked" || value2 === "failed";
-}
-function isOrdinaryObject(value2) {
-  if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
-    return false;
-  const prototype = Object.getPrototypeOf(value2);
-  return prototype === Object.prototype || prototype === null;
-}
-
 // dist/builtin/workflows/src/durable/boundary-lifecycle.ts
 function resolveBoundaryLifecycle(start, stages, requireTerminal) {
   const startTopology = start.topology;
   const startBoundary = startTopology?.boundary;
-  const startRun = startTopology?.run;
   const related = stages.filter((stage) => {
     const boundary = stage.topology?.boundary;
     return boundary !== undefined && (stage.replayKey === start.replayKey || stage.topology?.stageId === startTopology?.stageId || boundary.child.runId === startBoundary?.child.runId);
   });
+  return resolveBoundaryLifecycleFromRecords(start, {
+    related,
+    outputRecords: () => stages.filter((stage) => stage.replayKey === start.replayKey && stage.output !== undefined)
+  }, requireTerminal);
+}
+function resolveBoundaryLifecycleFromRecords(start, records, requireTerminal) {
+  const startTopology = start.topology;
+  const startBoundary = startTopology?.boundary;
+  const startRun = startTopology?.run;
+  const related = records.related;
   const starts = related.filter((stage) => stage.topology.boundary.event === "start");
   if (starts.length !== 1 || starts[0] !== start)
     return failure("boundary has no unique start record");
@@ -5725,7 +6183,7 @@ function resolveBoundaryLifecycle(start, stages, requireTerminal) {
     return failure("boundary has an illegal terminal transition");
   }
   const completed = terminals.find((terminal) => terminal.topology.boundary.status === "completed");
-  const outputRecords = stages.filter((stage) => stage.replayKey === start.replayKey && stage.output !== undefined);
+  const outputRecords = records.outputRecords();
   if (outputRecords.length !== (completed === undefined ? 0 : 1) || completed !== undefined && outputRecords[0]?.checkpointId !== completed.checkpointId) {
     return failure("boundary replay key has conflicting output records");
   }
@@ -5755,10 +6213,120 @@ var init_boundary_lifecycle = __esm(() => {
   init_stage_topology_validation();
 });
 
+// dist/builtin/workflows/src/durable/completed-catalog-index.ts
+class CheckpointCatalogIndex {
+  checkpoints;
+  stages;
+  positions = new Map;
+  groupKeys = new Map;
+  groups = new Map;
+  stagesByRunId = new Map;
+  boundariesByReplayKey = new Map;
+  boundariesByStageId = new Map;
+  boundariesByChildRunId = new Map;
+  outputsByReplayKey = new Map;
+  evidence;
+  constructor(checkpoints) {
+    this.checkpoints = checkpoints;
+    const stages = [];
+    checkpoints.forEach((checkpoint, index) => {
+      if (!this.positions.has(checkpoint))
+        this.positions.set(checkpoint, index);
+      if (checkpoint.kind !== "stage")
+        return;
+      stages.push(checkpoint);
+      const key = durableStageGroupKey(checkpoint);
+      this.groupKeys.set(checkpoint, key);
+      append(this.groups, key, checkpoint);
+      const runId = checkpoint.topology?.run?.runId;
+      if (runId !== undefined)
+        append(this.stagesByRunId, runId, checkpoint);
+      if (checkpoint.output !== undefined)
+        append(this.outputsByReplayKey, checkpoint.replayKey, checkpoint);
+      const boundary = checkpoint.topology?.boundary;
+      if (boundary === undefined)
+        return;
+      append(this.boundariesByReplayKey, checkpoint.replayKey, checkpoint);
+      append(this.boundariesByStageId, checkpoint.topology.stageId, checkpoint);
+      append(this.boundariesByChildRunId, boundary.child.runId, checkpoint);
+    });
+    this.stages = stages;
+  }
+  sequence(checkpoint) {
+    return (this.positions.get(checkpoint) ?? -1) + 1;
+  }
+  stageGroups() {
+    return this.groups.values();
+  }
+  boundaryLifecycle(start, requireTerminal) {
+    const topology = start.topology;
+    const childRunId = topology?.boundary?.child.runId;
+    const related = this.inCheckpointOrder([
+      this.boundariesByReplayKey.get(start.replayKey),
+      topology === undefined ? undefined : this.boundariesByStageId.get(topology.stageId),
+      childRunId === undefined ? undefined : this.boundariesByChildRunId.get(childRunId)
+    ]);
+    return resolveBoundaryLifecycleFromRecords(start, { related, outputRecords: () => this.outputsByReplayKey.get(start.replayKey) ?? [] }, requireTerminal);
+  }
+  directChildRecords(childRunId) {
+    return {
+      claiming: this.stagesByRunId.get(childRunId) ?? [],
+      direct: (claiming) => this.inCheckpointOrder([...new Set(claiming.map((stage) => this.groupKeys.get(stage)))].map((key) => this.groups.get(key)))
+    };
+  }
+  childScopedEvidenceExists(boundaryReplayKey, childRunId) {
+    this.evidence ??= scopedEvidenceIndex(this.checkpoints);
+    return this.evidence.runIds.has(childRunId) || hasPrefix(this.evidence.identities, `${boundaryReplayKey}:`);
+  }
+  inCheckpointOrder(lists) {
+    const present = lists.filter((list) => list !== undefined);
+    if (present.length === 1)
+      return present[0];
+    return [...new Set(present.flat())].sort((left, right) => this.sequence(left) - this.sequence(right));
+  }
+}
+function scopedEvidenceIndex(checkpoints) {
+  const runIds = new Set;
+  const identities = [];
+  for (const checkpoint of checkpoints) {
+    identities.push(checkpoint.checkpointId, checkpoint.kind === "tool" ? checkpoint.argsHash : checkpoint.kind === "ui" ? checkpoint.promptHash : checkpoint.replayKey);
+    if (checkpoint.kind !== "ui" && checkpoint.topology?.run?.runId !== undefined) {
+      runIds.add(checkpoint.topology.run.runId);
+    }
+  }
+  identities.sort(compareCodeUnits);
+  return { runIds, identities };
+}
+function hasPrefix(sorted, prefix) {
+  let low = 0;
+  let high = sorted.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (compareCodeUnits(sorted[middle], prefix) < 0)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return low < sorted.length && sorted[low].startsWith(prefix);
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function append(map, key, value2) {
+  const list = map.get(key);
+  if (list === undefined)
+    map.set(key, [value2]);
+  else
+    list.push(value2);
+}
+var init_completed_catalog_index = __esm(() => {
+  init_boundary_lifecycle();
+  init_stage_topology_validation();
+});
+
 // dist/builtin/workflows/src/durable/completed-catalog-stage-groups.ts
-function validBoundaryRecordSet(checkpoints, strict) {
-  const stages = checkpoints.filter((item) => item.kind === "stage");
-  const boundaries = stages.filter((item) => item.topology?.boundary !== undefined);
+function validBoundaryRecordSet(index, strict) {
+  const boundaries = index.stages.filter((item) => item.topology?.boundary !== undefined);
   const startsByReplay = new Map;
   for (const checkpoint of boundaries) {
     if (checkpoint.topology.boundary.event !== "start")
@@ -5773,7 +6341,7 @@ function validBoundaryRecordSet(checkpoints, strict) {
     return false;
   return [...startsByReplay.values()].every((starts) => {
     const start = starts[0];
-    if (boundaryTransitionError(start, stages, strict) !== undefined)
+    if ("error" in index.boundaryLifecycle(start, strict))
       return false;
     return start.topology.boundary.invocationFingerprint !== undefined;
   });
@@ -5837,8 +6405,8 @@ function compareDraftSourceOrder(left, right) {
 function runTopologyFor(drafts, tools) {
   return drafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run ?? tools.find((checkpoint) => checkpoint.topology?.run !== undefined)?.topology?.run;
 }
-function validateRunGroups(grouped, rootRunId, tools, checkpoints, allowPendingChildren = false) {
-  const toolsFor = (runId) => tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
+function validateRunGroups(grouped, rootRunId, toolsByRun, index, allowPendingChildren = false) {
+  const toolsFor = (runId) => toolsByRun.get(runId) ?? [];
   const owners = new Map;
   const syntheticChildIds = new Set;
   for (const [parentRunId, drafts] of grouped) {
@@ -5849,12 +6417,12 @@ function validateRunGroups(grouped, rootRunId, tools, checkpoints, allowPendingC
       if (childRunId === parentRunId || owners.has(childRunId))
         return false;
       if (!grouped.has(childRunId)) {
-        if (allowPendingChildren && isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) && !childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId)) {
+        if (allowPendingChildren && isPendingChildBoundary(draft, parentRunId, childRunId, rootRunId) && !index.childScopedEvidenceExists(draft.replayKey, childRunId)) {
           syntheticChildIds.add(childRunId);
           owners.set(childRunId, draft);
           continue;
         }
-        if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId))
+        if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || index.childScopedEvidenceExists(draft.replayKey, childRunId))
           return false;
         syntheticChildIds.add(childRunId);
         owners.set(childRunId, draft);
@@ -5895,13 +6463,6 @@ function isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) {
   const boundary = draft.topology?.boundary;
   return child?.runId === childRunId && child.exited === true && boundary?.event === "terminal" && boundary.status === "completed" && boundary.child.runId === childRunId && boundary.child.parentRunId === parentRunId && boundary.child.parentStageId === draft.topology?.stageId && boundary.child.rootRunId === rootRunId;
 }
-function childScopedEvidenceExists(checkpoints, boundaryReplayKey, childRunId) {
-  const prefix = `${boundaryReplayKey}:`;
-  return checkpoints.some((checkpoint) => {
-    const lookupIdentity = checkpoint.kind === "tool" ? checkpoint.argsHash : checkpoint.kind === "ui" ? checkpoint.promptHash : checkpoint.replayKey;
-    return checkpoint.checkpointId.startsWith(prefix) || lookupIdentity.startsWith(prefix) || checkpoint.kind !== "ui" && checkpoint.topology?.run?.runId === childRunId;
-  });
-}
 function retainReachableRunGroups(grouped, rootRunId) {
   const reachable = new Set([rootRunId]);
   const settled = new Set;
@@ -5942,14 +6503,6 @@ function childRunIdFromDraft(draft) {
     return;
   return workflowChildFromDraft(draft)?.runId ?? boundary?.child.runId;
 }
-function boundaryOwner(grouped, childRunId) {
-  for (const drafts of grouped.values()) {
-    const owner = drafts.find((draft) => childRunIdFromDraft(draft) === childRunId);
-    if (owner !== undefined)
-      return owner;
-  }
-  return;
-}
 function childRunStatus(owner) {
   const child = workflowChildFromDraft(owner);
   if (child !== undefined)
@@ -5957,15 +6510,15 @@ function childRunStatus(owner) {
   const status = owner.topology?.boundary?.status;
   return status === "failed" || status === "skipped" || status === "completed" ? status : "running";
 }
-function mergeStageGroup(records, allStages, allCheckpoints) {
+function mergeStageGroup(records, index) {
   let merged;
   for (const record of records)
-    merged = mergeStageDraft(merged, record, allCheckpoints.indexOf(record) + 1);
+    merged = mergeStageDraft(merged, record, index.sequence(record));
   const draft = merged;
   const start = records.find((record) => record.topology?.boundary?.event === "start");
   if (start === undefined)
     return draft;
-  const resolved = resolveBoundaryLifecycle(start, allStages, false);
+  const resolved = index.boundaryLifecycle(start, false);
   if ("error" in resolved)
     return draft;
   const terminal = resolved.lifecycle.latestTerminal;
@@ -6028,9 +6581,7 @@ function workflowChildFromDraft(draft) {
     ...typeof child.exitReason === "string" ? { exitReason: child.exitReason } : {}
   };
 }
-var init_completed_catalog_stage_groups = __esm(() => {
-  init_boundary_lifecycle();
-});
+var init_completed_catalog_stage_groups = () => {};
 
 // dist/builtin/workflows/src/shared/abort.ts
 function raceAbort(operation, signal) {
@@ -6564,13 +7115,19 @@ function registerRunJournalVersions(journal, versions) {
 function runJournalVersions(journal) {
   return versionReaders.get(journal);
 }
+function registerRunJournalAppendMany(journal, appendMany) {
+  appendManyWriters.set(journal, appendMany);
+}
+function runJournalAppendMany(journal) {
+  return appendManyWriters.get(journal);
+}
 function registerSqlPoolStorage(journal, storage) {
   poolStorage.set(journal, storage);
 }
 function sqlPoolStorage(journal) {
   return poolStorage.get(journal);
 }
-var JOURNAL_READ_PAGE_SIZE = 256, NON_SNAPSHOT_EVENT_TYPES, versionReaders, poolStorage;
+var JOURNAL_READ_PAGE_SIZE = 256, NON_SNAPSHOT_EVENT_TYPES, versionReaders, appendManyWriters, poolStorage;
 var init_internal = __esm(() => {
   init_types();
   NON_SNAPSHOT_EVENT_TYPES = [
@@ -6579,6 +7136,7 @@ var init_internal = __esm(() => {
     RUN_EVENT_TYPES.messageDelivered
   ];
   versionReaders = new WeakMap;
+  appendManyWriters = new WeakMap;
   poolStorage = new WeakMap;
 });
 
@@ -6872,9 +7430,19 @@ function* invoke(action) {
   } catch (error) {
     if (error instanceof JournalError || error instanceof StorageError)
       throw error;
-    throw new StorageUnavailableError({ adapter: "custom", location: "custom journal" }, error instanceof Error ? error : new Error(String(error)));
+    throw customJournalUnavailable(error);
   }
 }
+function customJournalUnavailable(failure) {
+  const cause = failure instanceof Error ? failure : new Error(String(failure));
+  const code = hasErrorCode(cause) ? cause.code : undefined;
+  const detail = code === undefined ? cause.name : `${cause.name} (${String(code)})`;
+  return new StorageUnavailableError(CUSTOM_JOURNAL, cause, detail);
+}
+function hasErrorCode(error) {
+  const code = error.code;
+  return typeof code === "string" || typeof code === "number";
+}
 async function execute(operation) {
   let step = operation.next();
   while (!step.done) {
@@ -6902,6 +7470,8 @@ class JournalDurableBackend {
   executions = new Map;
   executionContext = new AsyncLocalStorage;
   pending = new Map;
+  reconciledPendingStages = new Map;
+  appendBatches = new Map;
   catalogQueue = Symbol("catalog");
   lost = new Map;
   prompts = new Map;
@@ -6934,7 +7504,7 @@ class JournalDurableBackend {
         await backend.close();
       if (error instanceof JournalError || error instanceof StorageError || error instanceof DurableNestedTopologyError)
         throw error;
-      throw new StorageUnavailableError({ adapter: "custom", location: "custom journal" }, error instanceof Error ? error : new Error(String(error)));
+      throw customJournalUnavailable(error);
     }
   }
   serialize(runId, action, requiresActiveExecution = true) {
@@ -6949,6 +7519,8 @@ class JournalDurableBackend {
     return this.enqueue(runId, action, admitted);
   }
   enqueue(runId, action, admitted = this.mutationContext.getStore() ?? new Set) {
+    if (typeof runId === "string")
+      this.appendBatches.delete(runId);
     const prior = this.pending.get(runId) ?? Promise.resolve();
     const result = prior.then(() => this.mutationContext.run(admitted, () => execute(action())));
     const settled = result.then(() => {}, () => {});
@@ -6963,6 +7535,7 @@ class JournalDurableBackend {
     if (entry.seq <= (this.sequences.get(entry.runId) ?? 0))
       return;
     const event = entry.event;
+    let raisedCount;
     if (event.type === RUN_EVENT_TYPES.checkpointRecorded) {
       const checkpoint = event.payload;
       validateCheckpointInvocationFingerprint(checkpoint);
@@ -6971,7 +7544,10 @@ class JournalDurableBackend {
       this.projection.archivePendingStageMessage(entry.runId, event.payload.message);
     } else if (event.type === RUN_EVENT_TYPES.messageDelivered) {
       const payload = event.payload;
+      const countVersion = this.projection.pendingStageDeliveryCountVersion(entry.runId);
       this.projection.archivePendingStageDeliveryReceipt(entry.runId, payload.messageId, payload.delivery, payload.accounting);
+      if (payload.accounting !== undefined && this.projection.pendingStageDeliveryCountVersion(entry.runId) !== countVersion)
+        raisedCount = { messageId: payload.messageId, messageRunId: payload.accounting.messageRunId };
     } else if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased) {
       this.projection.applyWorkflowSnapshot(decodeHandle(event.payload.handle, this.projection.getWorkflow(entry.runId)?.pendingStageMessages));
       this.prompts.set(entry.runId, new PromptReservationState(event.payload.handle.pendingPrompts, event.payload.prompts));
@@ -6982,20 +7558,80 @@ class JournalDurableBackend {
       if (event.type === RUN_EVENT_TYPES.runStarted || previous?.pendingPrompts !== handle.pendingPrompts)
         this.prompts.delete(entry.runId);
     }
-    const handle = this.projection.getWorkflow(entry.runId);
-    if (handle?.pendingStageMessages !== undefined) {
-      const messages = handle.pendingStageMessages.map((message) => {
-        if (message.sticky !== true)
-          return message;
-        const count = this.projection.getPendingStageMessageDeliveryCount(entry.runId, message.id, message.runId);
-        return count > (message.deliveryCount ?? message.deliveries?.length ?? 0) ? { ...message, deliveryCount: count } : message;
-      });
-      if (messages.some((message, index) => message !== handle.pendingStageMessages?.[index]))
-        this.projection.applyWorkflowSnapshot({ ...handle, pendingStageMessages: messages });
-    }
+    this.reconcileFoldedDeliveryCounts(entry.runId, raisedCount);
     this.sequences.set(entry.runId, entry.seq);
     this.foldedAt.set(entry.runId, entry.at);
   }
+  reconcileFoldedDeliveryCounts(runId, raisedCount) {
+    const handle = this.projection.getWorkflow(runId);
+    const list = handle?.pendingStageMessages;
+    if (handle === undefined || list === undefined) {
+      this.reconciledPendingStages.delete(runId);
+      return;
+    }
+    let state = this.reconciledPendingStages.get(runId);
+    let next;
+    const raise = (index, count) => {
+      const message = (next ?? list)[index];
+      if (count <= (message.deliveryCount ?? message.deliveries?.length ?? 0))
+        return;
+      next ??= [...list];
+      next[index] = { ...message, deliveryCount: count };
+    };
+    const reconcile = (index) => {
+      const message = list[index];
+      if (message.sticky !== true)
+        return;
+      raise(index, this.projection.getPendingStageMessageDeliveryCount(runId, message.id, message.runId));
+    };
+    if (state?.list !== list) {
+      const previous = state?.list ?? [];
+      let aligned = list.length >= previous.length;
+      const changed = [];
+      for (let index = 0;index < list.length; index++) {
+        const message = list[index];
+        if (previous[index] === message)
+          continue;
+        if (index < previous.length && previous[index].id !== message.id)
+          aligned = false;
+        changed.push(index);
+      }
+      const reconciled = aligned ? undefined : new Set(previous);
+      for (const index of changed)
+        if (!reconciled?.has(list[index]))
+          reconcile(index);
+      const positions = aligned ? state?.positions : undefined;
+      if (positions !== undefined) {
+        for (let index = previous.length;index < list.length; index++) {
+          const indexes = positions.get(list[index].id);
+          if (indexes === undefined)
+            positions.set(list[index].id, [index]);
+          else
+            indexes.push(index);
+        }
+      }
+      state = { list, positions };
+    }
+    if (raisedCount !== undefined) {
+      const count = this.projection.getPendingStageMessageDeliveryCount(runId, raisedCount.messageId, raisedCount.messageRunId);
+      state.positions ??= messagePositions(list);
+      for (const index of state.positions.get(raisedCount.messageId) ?? []) {
+        const message = list[index];
+        if (message.sticky === true && message.runId === raisedCount.messageRunId)
+          raise(index, count);
+      }
+    }
+    if (next === undefined) {
+      this.reconciledPendingStages.set(runId, state);
+      return;
+    }
+    this.projection.applyWorkflowSnapshot({ ...handle, pendingStageMessages: next });
+    const applied = this.projection.getWorkflow(runId)?.pendingStageMessages ?? next;
+    this.reconciledPendingStages.set(runId, {
+      list: applied,
+      positions: applied.length === list.length ? state.positions : undefined
+    });
+  }
   summarize(runId, tail) {
     const event = tail.snapshot.event;
     const handle = event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased ? event.payload.handle : event.payload;
@@ -7019,6 +7655,7 @@ class JournalDurableBackend {
   *rebuild(runId) {
     const entries = yield* this.entries(runId);
     this.projection.deleteWorkflow(runId);
+    this.reconciledPendingStages.delete(runId);
     this.sequences.delete(runId);
     this.foldedAt.delete(runId);
     this.summarized.delete(runId);
@@ -7114,9 +7751,9 @@ class JournalDurableBackend {
     }
     yield* this.write(runId, lease, event, options);
   }
-  *write(runId, lease, event, options) {
+  *write(runId, lease, event, options, context = (action) => action()) {
     try {
-      const outcome = yield* invoke(() => this.journal.append(lease, event, options));
+      const outcome = yield* invoke(() => context(() => this.journal.append(lease, event, options)));
       const nextSeq = (this.sequences.get(runId) ?? 0) + 1;
       if (outcome.entry.seq > nextSeq) {
         for (const entry of yield* this.entries(runId, nextSeq))
@@ -7300,13 +7937,80 @@ class JournalDurableBackend {
     return true;
   }
   async archivePendingStageMessage(runId, message) {
-    await this.serialize(runId, () => this.append(runId, { type: RUN_EVENT_TYPES.messageSettled, payload: { message } }, { key: JSON.stringify([RUN_EVENT_TYPES.messageSettled, message.runId, message.id]) }));
+    await this.queueAppend(runId, { type: RUN_EVENT_TYPES.messageSettled, payload: { message } }, JSON.stringify([RUN_EVENT_TYPES.messageSettled, message.runId, message.id]));
   }
   async archivePendingStageDeliveryReceipt(runId, messageId, delivery, accounting) {
-    await this.serialize(runId, () => this.append(runId, {
+    await this.queueAppend(runId, {
       type: RUN_EVENT_TYPES.messageDelivered,
       payload: { messageId, delivery, ...accounting === undefined ? {} : { accounting } }
-    }));
+    });
+  }
+  queueAppend(runId, event, key) {
+    try {
+      this.ensureOpen();
+      this.assertExecutionActive();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const open = this.appendBatches.get(runId);
+    const batch = open !== undefined && open.length < APPEND_BATCH_LIMIT ? open : [];
+    const queued = new Promise((resolve, reject) => {
+      batch.push({
+        event,
+        ...key === undefined ? {} : { key },
+        context: AsyncLocalStorage.snapshot(),
+        resolve,
+        reject
+      });
+    });
+    if (batch !== open) {
+      this.serialize(runId, () => this.appendBatch(runId, batch)).catch((error) => {
+        for (const append of batch)
+          append.reject(error);
+      });
+      this.appendBatches.set(runId, batch);
+    }
+    return queued;
+  }
+  *appendBatch(runId, batch) {
+    if (this.appendBatches.get(runId) === batch)
+      this.appendBatches.delete(runId);
+    const appendMany = runJournalAppendMany(this.journal);
+    if (appendMany === undefined || batch.length === 1) {
+      for (const append of batch) {
+        try {
+          const lease = yield* this.ownership(runId);
+          yield* this.write(runId, lease, append.event, append.key === undefined ? undefined : { key: append.key }, append.context);
+          append.resolve();
+        } catch (error) {
+          append.reject(error);
+        }
+      }
+      return;
+    }
+    let settled = 0;
+    try {
+      const lease = yield* this.ownership(runId);
+      const results = yield* invoke(() => appendMany(lease, batch));
+      for (const result of results) {
+        const append = batch[settled];
+        if (result.status === "rejected") {
+          append.reject(yield* this.mapOwnership(result.reason, runId));
+        } else {
+          const nextSeq = (this.sequences.get(runId) ?? 0) + 1;
+          if (result.value.entry.seq > nextSeq)
+            for (const entry of yield* this.entries(runId, nextSeq))
+              this.fold(entry);
+          this.fold(result.value.entry);
+          append.resolve();
+        }
+        settled++;
+      }
+    } catch (error) {
+      const failure = error instanceof Error ? yield* this.mapOwnership(error, runId) : error;
+      for (const append of batch.slice(settled))
+        append.reject(failure);
+    }
   }
   getToolOutput(...args) {
     return this.projection.getToolOutput(...args);
@@ -7326,6 +8030,9 @@ class JournalDurableBackend {
   listCheckpoints(runId) {
     return this.projection.listCheckpoints(runId);
   }
+  nestedSnapshotVersion(runId) {
+    return this.projection.nestedSnapshotVersion(runId);
+  }
   getWorkflow(runId) {
     return this.projection.getWorkflow(runId);
   }
@@ -7350,6 +8057,12 @@ class JournalDurableBackend {
   getPendingStageMessageDeliveryCount(...args) {
     return this.projection.getPendingStageMessageDeliveryCount(...args);
   }
+  pendingStageDeliveryReceiptChanges(...args) {
+    return this.projection.pendingStageDeliveryReceiptChanges(...args);
+  }
+  pendingStageDeliveryCountVersion(runId) {
+    return this.projection.pendingStageDeliveryCountVersion(runId);
+  }
   hasPendingStageDeliveryReceipt(...args) {
     return this.projection.hasPendingStageDeliveryReceipt(...args);
   }
@@ -7434,6 +8147,7 @@ class JournalDurableBackend {
     this.foldedAt.delete(runId);
     this.summarized.delete(runId);
     this.prompts.delete(runId);
+    this.reconciledPendingStages.delete(runId);
     this.projection.deleteWorkflow(runId);
   }
   async deleteWorkflow(runId) {
@@ -7616,8 +8330,24 @@ class JournalDurableBackend {
     }
   }
 }
+function messagePositions(list) {
+  const positions = new Map;
+  list.forEach((message, index) => {
+    const indexes = positions.get(message.id);
+    if (indexes === undefined)
+      positions.set(message.id, [index]);
+    else
+      indexes.push(index);
+  });
+  return positions;
+}
 function identity(message) {
-  return JSON.stringify([message.runId, message.id]);
+  let key = entryIdentity.get(message);
+  if (key === undefined) {
+    key = JSON.stringify([message.runId, message.id]);
+    entryIdentity.set(message, key);
+  }
+  return key;
 }
 function uniqueByIdentity(messages) {
   const result = new Map;
@@ -7791,7 +8521,7 @@ function decodePendingStageDeliveries(previous, messages) {
 function hasPendingStageDeliveryDelta(messages) {
   return messages?.some(isDeltaEncoded) === true;
 }
-var PROCESS_HOLDER_ID, CHANGE_APPEND_ATTEMPTS = 4, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError, entryJson;
+var PROCESS_HOLDER_ID, CHANGE_APPEND_ATTEMPTS = 4, APPEND_BATCH_LIMIT = 256, processExitCleanups, CUSTOM_JOURNAL, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError, entryIdentity, entryJson;
 var init_journal_backend = __esm(() => {
   init_workflow_instance_ownership_error();
   init_backend();
@@ -7803,6 +8533,7 @@ var init_journal_backend = __esm(() => {
   init_types();
   PROCESS_HOLDER_ID = randomUUID4();
   processExitCleanups = new Set;
+  CUSTOM_JOURNAL = { adapter: "custom", location: "custom journal" };
   JournalOwnershipError = class JournalOwnershipError extends WorkflowInstanceOwnershipError {
     runId;
     holderId;
@@ -7849,6 +8580,7 @@ var init_journal_backend = __esm(() => {
       this.name = "JournalMessageScopeError";
     }
   };
+  entryIdentity = new WeakMap;
   entryJson = new WeakMap;
 });
 
@@ -7976,6 +8708,7 @@ class SqlRunJournal {
       runVersions: () => this.runVersions(),
       snapshotTail: (runId) => this.snapshotTail(runId)
     });
+    registerRunJournalAppendMany(this, (lease, appends) => this.appendMany(lease, appends));
     registerSqlPoolStorage(this, {
       transaction: (body) => this.operation(() => this.database.transaction(body)),
       withAppendGuard: (guard, action) => this.appendGuard.run(guard, action),
@@ -8240,38 +8973,76 @@ class SqlRunJournal {
     this.assertOpen();
     validateText("runId", lease.runId);
     validateText("holderId", lease.holderId);
-    if (options?.key !== undefined)
-      validateText("key", options.key);
     const owned = { ...lease };
-    const key = options?.key;
+    const prepared = this.prepare(event, options?.key, this.appendGuard.getStore());
     const expected = options?.expectSeq;
+    return this.operation(() => this.database.transaction(async (tx) => {
+      await this.checkLease(tx, owned);
+      return this.insert(tx, owned, prepared, expected);
+    }));
+  }
+  async appendMany(lease, appends) {
+    this.assertOpen();
+    validateText("runId", lease.runId);
+    validateText("holderId", lease.holderId);
+    const owned = { ...lease };
+    const prepared = appends.map((append) => {
+      try {
+        return this.prepare(append.event, append.key, append.context(() => this.appendGuard.getStore()));
+      } catch (error) {
+        return error;
+      }
+    });
+    return this.operation(() => this.database.transaction(async (tx) => {
+      await this.checkLease(tx, owned);
+      const results = [];
+      for (const append of prepared) {
+        if (append instanceof Error) {
+          results.push({ status: "rejected", reason: append });
+          continue;
+        }
+        await tx.exec(`SAVEPOINT ${APPEND_SAVEPOINT}`);
+        try {
+          results.push({ status: "fulfilled", value: await this.insert(tx, owned, append) });
+        } catch (error) {
+          await tx.exec(`ROLLBACK TO ${APPEND_SAVEPOINT}`);
+          results.push({ status: "rejected", reason: error });
+        }
+        await tx.exec(`RELEASE ${APPEND_SAVEPOINT}`);
+      }
+      return results;
+    }));
+  }
+  prepare(event, key, appendGuard) {
+    if (key !== undefined)
+      validateText("key", key);
     const type = event.type;
     const payload = this.snapshotJson(event.payload);
-    const guard = type === RUN_EVENT_TYPES.messageQueued || type === RUN_EVENT_TYPES.messageDelivered || type === RUN_EVENT_TYPES.messageSettled ? this.appendGuard.getStore() : undefined;
+    const guard = type === RUN_EVENT_TYPES.messageQueued || type === RUN_EVENT_TYPES.messageDelivered || type === RUN_EVENT_TYPES.messageSettled ? appendGuard : undefined;
     const status = type === RUN_EVENT_TYPES.statusChanged && !(payload instanceof StorageUnavailableError2) ? JSON.parse(payload).status : undefined;
     if (type === RUN_EVENT_TYPES.statusChanged && !(payload instanceof StorageUnavailableError2))
       validateText("status", status);
-    return this.operation(() => this.database.transaction(async (tx) => {
-      await this.checkLease(tx, owned);
-      await guard?.(tx, owned.runId);
-      if (key !== undefined) {
-        const row = await tx.get(`SELECT * FROM ${this.tables.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.key} = ?`, owned.runId, key);
-        if (row)
-          return { status: "exists", entry: entryFromRow(row) };
-      }
-      const actual = await this.sequence(tx, owned.runId);
-      if (expected !== undefined && expected !== actual)
-        throw new JournalCasConflictError(owned.runId, expected, actual);
-      const seq = journalCounter(owned.runId, "seq", actual + 1, "overflow");
-      if (payload instanceof StorageUnavailableError2)
-        throw payload;
-      await tx.run(`INSERT INTO ${this.tables.events} VALUES (?, ?, ?, ?, ?, ?, ${STORE_NOW})`, owned.runId, seq, owned.epoch, key ?? null, type, payload);
-      if (status !== undefined)
-        await tx.run(`UPDATE ${this.tables.runs} SET ${JOURNAL_COLUMNS.status} = ? WHERE ${JOURNAL_COLUMNS.runId} = ?`, status, owned.runId);
-      const row = await tx.get(`SELECT * FROM ${this.tables.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.seq} = ?`, owned.runId, seq);
-      await guard?.(tx, owned.runId);
-      return { status: "appended", entry: entryFromRow(row) };
-    }));
+    return { key, type, payload, guard, status };
+  }
+  async insert(tx, owned, { key, type, payload, guard, status }, expected) {
+    await guard?.(tx, owned.runId);
+    if (key !== undefined) {
+      const row = await tx.get(`SELECT * FROM ${this.tables.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.key} = ?`, owned.runId, key);
+      if (row)
+        return { status: "exists", entry: entryFromRow(row) };
+    }
+    const actual = await this.sequence(tx, owned.runId);
+    if (expected !== undefined && expected !== actual)
+      throw new JournalCasConflictError(owned.runId, expected, actual);
+    const seq = journalCounter(owned.runId, "seq", actual + 1, "overflow");
+    if (payload instanceof StorageUnavailableError2)
+      throw payload;
+    await tx.run(`INSERT INTO ${this.tables.events} VALUES (?, ?, ?, ?, ?, ?, ${STORE_NOW})`, owned.runId, seq, owned.epoch, key ?? null, type, payload);
+    if (status !== undefined)
+      await tx.run(`UPDATE ${this.tables.runs} SET ${JOURNAL_COLUMNS.status} = ? WHERE ${JOURNAL_COLUMNS.runId} = ?`, status, owned.runId);
+    const row = await tx.get(`SELECT * FROM ${this.tables.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.seq} = ?`, owned.runId, seq);
+    await guard?.(tx, owned.runId);
+    return { status: "appended", entry: entryFromRow(row) };
   }
   async* read(runId, fromSeq = 1) {
     this.assertOpen();
@@ -8339,7 +9110,7 @@ class SqlRunJournal {
     return this.closePromise;
   }
 }
-var STORE_NOW = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", EVENT_COLUMNS;
+var STORE_NOW = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", EVENT_COLUMNS, APPEND_SAVEPOINT = "journal_append";
 var init_sql_run_journal = __esm(() => {
   init_internal();
   init_legacy_journal_tables();
@@ -8547,8 +9318,59 @@ function firstError(schema, value2) {
   }
   return;
 }
+function certainlySerializable(root, rootMustBeObject) {
+  if (rootMustBeObject && (root === null || typeof root !== "object" || Array.isArray(root)))
+    return false;
+  const pending = [root];
+  const ancestors = new Set;
+  const exits = [undefined];
+  while (pending.length > 0) {
+    const exit = exits.pop();
+    const value2 = pending.pop();
+    if (exit !== undefined) {
+      ancestors.delete(exit);
+      continue;
+    }
+    if (value2 === null || typeof value2 === "string" || typeof value2 === "boolean")
+      continue;
+    if (typeof value2 === "number") {
+      if (!Number.isFinite(value2))
+        return false;
+      continue;
+    }
+    if (typeof value2 !== "object" || ancestors.has(value2))
+      return false;
+    if (Object.getOwnPropertySymbols(value2).length > 0)
+      return false;
+    const names = Object.getOwnPropertyNames(value2);
+    let children;
+    if (Array.isArray(value2)) {
+      if (Object.getPrototypeOf(value2) !== Array.prototype || names.length !== value2.length + 1)
+        return false;
+      children = [];
+      for (let index = 0;index < value2.length; index++)
+        children.push(value2[index]);
+    } else {
+      const proto = Object.getPrototypeOf(value2);
+      if (proto !== Object.prototype && proto !== null)
+        return false;
+      const keys = Object.keys(value2);
+      if (keys.length !== names.length)
+        return false;
+      children = keys.map((key) => value2[key]);
+    }
+    ancestors.add(value2);
+    pending.push(value2);
+    exits.push(value2);
+    for (const child of children) {
+      pending.push(child);
+      exits.push(undefined);
+    }
+  }
+  return true;
+}
 function workflowSerializableValidationError(value2, label) {
-  if (Value.Check(workflowSerializableValueSchema, value2))
+  if (certainlySerializable(value2, false) || Value.Check(workflowSerializableValueSchema, value2))
     return;
   const issue = firstError(workflowSerializableValueSchema, value2);
   const issuePath = issue === undefined ? "" : formatInstancePath(issue.instancePath);
@@ -8557,7 +9379,7 @@ function workflowSerializableValidationError(value2, label) {
   return `${label}${location} must be ${WORKFLOW_SERIALIZABLE_DESCRIPTION}, got ${workflowSerializableTypeName(offending)}`;
 }
 function workflowSerializableObjectValidationError(value2, label) {
-  if (Value.Check(workflowSerializableObjectSchema, value2))
+  if (certainlySerializable(value2, true) || Value.Check(workflowSerializableObjectSchema, value2))
     return;
   const issue = firstError(workflowSerializableObjectSchema, value2);
   const issuePath = issue === undefined ? "" : formatInstancePath(issue.instancePath);
@@ -60991,39 +61813,406 @@ var init_pending_stage_route_readiness = __esm(() => {
   processState3[routeOwnersKey] = owners;
 });
 
-// dist/builtin/workflows/src/shared/sticky-stage-delivery-status.ts
-function stickyStageDeliveryStatuses(runs, rootRunId, availableBackend) {
-  const root = runs.find((run) => run.id === rootRunId);
-  const entries = (root?.pendingStageMessages ?? []).filter((entry) => entry.sticky === true);
-  const result = [];
-  const patternByTarget = new Map;
-  const patterns = [];
-  const entriesByPattern = [];
-  const ownEntries = [];
-  entries.forEach((entry, index) => {
+// dist/builtin/workflows/src/shared/sticky-delivery-state-bound.ts
+function boundStickyDeliveryStates(states, limit = STICKY_DELIVERY_STATE_EXEMPLAR_LIMIT) {
+  if (states.length === 0)
+    return { deliveryStates: states };
+  const counts = new Map(UNRESOLVED_STATES.map((state) => [state, 0]));
+  counts.set("delivered", 0);
+  for (const delivery of states)
+    counts.set(delivery.state, (counts.get(delivery.state) ?? 0) + 1);
+  const deliveryStateCounts = Object.fromEntries([...counts].filter(([, count]) => count > 0));
+  if (states.length <= limit)
+    return { deliveryStates: states, deliveryStateCounts };
+  const exemplars = [];
+  for (const state of UNRESOLVED_STATES) {
+    for (const delivery of states) {
+      if (exemplars.length === limit)
+        break;
+      if (delivery.state === state)
+        exemplars.push(delivery);
+    }
+  }
+  for (let index = states.length - 1;index >= 0 && exemplars.length < limit; index--) {
+    const delivery = states[index];
+    if (delivery.state === "delivered")
+      exemplars.push(delivery);
+  }
+  return {
+    deliveryStates: exemplars,
+    deliveryStateCounts,
+    omittedDeliveryStates: states.length - exemplars.length
+  };
+}
+function omittedDeliveryStatesLine(bounded) {
+  const omitted = bounded.omittedDeliveryStates ?? 0;
+  if (omitted === 0 || bounded.deliveryStateCounts === undefined)
+    return;
+  const counts = Object.entries(bounded.deliveryStateCounts).map(([state, count]) => `${count} ${state}`).join(", ");
+  return `… ${omitted} more delivery state${omitted === 1 ? "" : "s"} omitted (all: ${counts})`;
+}
+var STICKY_DELIVERY_STATE_EXEMPLAR_LIMIT = 5, UNRESOLVED_STATES;
+var init_sticky_delivery_state_bound = __esm(() => {
+  UNRESOLVED_STATES = [
+    "queued",
+    "receipt-unverified",
+    "session-replaced",
+    "delivery-unavailable",
+    "root-unresolved",
+    "stage-terminal"
+  ];
+});
+
+// dist/builtin/workflows/src/shared/possible-stage-rows.ts
+function boundPossibleStageDeliveryStates(states) {
+  const bounded = boundStickyDeliveryStates(states);
+  return {
+    ...bounded,
+    deliveryStates: bounded.deliveryStates.map(({ target: _target, ...state }) => state)
+  };
+}
+
+class WorkflowTopologyIndex {
+  lineage = [];
+  runById = new Map;
+  roots = new Map;
+  hops = new Map;
+  refresh(runs) {
+    const runById = new Map(runs.map((run) => [run.id, run]));
+    const lineage = [];
+    for (const run of runs) {
+      lineage.push(run.id, run.rootRunId, run.parentRunId, run.parentStageId);
+      if (run.parentRunId === undefined)
+        continue;
+      const parent = runById.get(run.parentRunId);
+      const boundary = parent?.stages.find((stage) => stage.id === run.parentStageId);
+      lineage.push(parent !== undefined, boundary?.name, authoritativeWorkflowChildRunId(boundary));
+    }
+    if (sameValues(lineage, this.lineage))
+      return;
+    this.lineage = lineage;
+    this.runById = runById;
+    this.roots.clear();
+    this.hops.clear();
+  }
+  rootOf(runId) {
+    if (this.roots.has(runId))
+      return this.roots.get(runId);
+    const root = reciprocalWorkflowRootRunId(this.runById, runId);
+    this.roots.set(runId, root);
+    return root;
+  }
+  hopsOf(runId) {
+    if (this.hops.has(runId))
+      return this.hops.get(runId);
+    const hops = boundaryHops(this.runById, runId);
+    this.hops.set(runId, hops);
+    return hops;
+  }
+}
+function boundaryHops(runById, runId) {
+  const hops = [];
+  let current = runById.get(runId);
+  while (current !== undefined && current.parentRunId !== undefined) {
+    const parent = runById.get(current.parentRunId);
+    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
+    if (parent === undefined || boundary === undefined)
+      return;
+    hops.unshift({ name: boundary.name, runId: current.id });
+    current = parent;
+  }
+  return current === undefined ? undefined : hops;
+}
+function sameValues(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index++)
+    if (left[index] !== right[index])
+      return false;
+  return true;
+}
+
+class PossibleStageRowsIndex {
+  rootRunId;
+  topology;
+  targets = new Map;
+  patterns = [];
+  targetOf = new Map;
+  targetsByMessage = new Map;
+  list = [];
+  stageFields = new WeakMap;
+  backend;
+  receiptCursor;
+  scanMatches = new Map;
+  rowCache = new Map;
+  boundedStates = new WeakMap;
+  deliveriesByEntry = new WeakMap;
+  statusCache = new WeakMap;
+  receiptGeneration = 0;
+  receiptEpochs = new Map;
+  constructor(rootRunId, topology) {
+    this.rootRunId = rootRunId;
+    this.topology = topology;
+  }
+  rows(runs, rootRun, availableBackend) {
+    if (isTerminalRunStatus(rootRun.status))
+      return [];
+    this.refreshEntries(rootRun.pendingStageMessages ?? []);
+    const resolvedBackend = availableRunDurableBackend(runs, this.rootRunId) ?? availableBackend;
+    const backend = resolvedBackend === undefined ? undefined : durableBackendForRun(resolvedBackend, runs, this.rootRunId);
+    this.refreshReceipts(backend);
+    this.refreshStages(runs);
+    for (const state of this.patterns)
+      if (state.dirty)
+        this.recompute(state, backend);
+    return this.assemble(runs, rootRun);
+  }
+  targetFor(entry) {
     const target = entry.targetPath ?? entry.stageKey;
-    let pattern = patternByTarget.get(target);
-    if (pattern === undefined) {
+    let state = this.targets.get(target);
+    if (state === undefined) {
       const parsed = parseWorkflowStageTarget(target);
-      pattern = parsed?.rootRunId === rootRunId ? patterns.push(parsed.segments) - 1 : -1;
-      if (pattern >= 0)
-        entriesByPattern.push([]);
-      patternByTarget.set(target, pattern);
+      const owned = parsed?.rootRunId === this.rootRunId;
+      state = {
+        target,
+        segments: owned ? parsed.segments : undefined,
+        pattern: owned ? this.patterns.length : -1,
+        entries: [],
+        positions: [],
+        queued: 0,
+        stages: [],
+        statuses: [],
+        dirty: true
+      };
+      this.targets.set(target, state);
+      if (owned)
+        this.patterns.push(state);
     }
-    if (pattern < 0)
+    return state;
+  }
+  refreshEntries(list) {
+    const previous = this.list;
+    if (list === previous)
       return;
-    entriesByPattern[pattern].push(index);
-    ownEntries.push(index);
-  });
-  if (ownEntries.length === 0)
-    return result;
-  const patternIndex = createStagePathPatternIndex(patterns);
-  const deliveriesByEntry = new Map;
-  const entryReceipts = (index, runId, stageId) => {
-    let byStage = deliveriesByEntry.get(index);
+    this.list = list;
+    let incremental = list.length >= previous.length;
+    const replaced = [];
+    for (let index = 0;incremental && index < previous.length; index++) {
+      if (list[index] === previous[index])
+        continue;
+      const before = previous[index];
+      const after = list[index];
+      if (before.sticky !== true && after.sticky !== true)
+        continue;
+      if (before.sticky !== true || after.sticky !== true || (before.targetPath ?? before.stageKey) !== (after.targetPath ?? after.stageKey)) {
+        incremental = false;
+        break;
+      }
+      replaced.push(index);
+    }
+    if (!incremental) {
+      this.rebuildEntries(list);
+      return;
+    }
+    for (const index of replaced) {
+      const before = previous[index];
+      const after = list[index];
+      const state = this.targetOf.get(before);
+      const slot = state.entries.indexOf(before);
+      state.entries[slot] = after;
+      this.targetOf.delete(before);
+      this.targetOf.set(after, state);
+      state.queued += (after.status === "queued" ? 1 : 0) - (before.status === "queued" ? 1 : 0);
+      if (before.id !== after.id)
+        this.rebuildMessageIndex();
+      state.dirty = true;
+    }
+    for (let index = previous.length;index < list.length; index++)
+      this.addEntry(list[index], index);
+  }
+  addEntry(entry, position) {
+    if (entry.sticky !== true)
+      return;
+    const state = this.targetFor(entry);
+    state.entries.push(entry);
+    state.positions.push(position);
+    if (entry.status === "queued")
+      state.queued++;
+    state.dirty = true;
+    this.targetOf.set(entry, state);
+    let targets = this.targetsByMessage.get(entry.id);
+    if (targets === undefined) {
+      targets = new Set;
+      this.targetsByMessage.set(entry.id, targets);
+    }
+    targets.add(state);
+  }
+  rebuildEntries(list) {
+    const before = new Map;
+    for (const state of this.targets.values()) {
+      before.set(state, state.entries);
+      state.entries = [];
+      state.positions = [];
+      state.queued = 0;
+    }
+    this.targetOf.clear();
+    this.targetsByMessage.clear();
+    list.forEach((entry, position) => {
+      this.addEntry(entry, position);
+    });
+    for (const state of this.targets.values()) {
+      const previous = before.get(state);
+      state.dirty ||= previous === undefined || !sameValues(previous, state.entries);
+    }
+  }
+  rebuildMessageIndex() {
+    this.targetsByMessage.clear();
+    for (const [entry, state] of this.targetOf) {
+      let targets = this.targetsByMessage.get(entry.id);
+      if (targets === undefined) {
+        targets = new Set;
+        this.targetsByMessage.set(entry.id, targets);
+      }
+      targets.add(state);
+    }
+  }
+  refreshReceipts(backend) {
+    if (backend !== this.backend) {
+      this.backend = backend;
+      this.receiptCursor = undefined;
+      this.invalidateReceipts();
+    }
+    if (backend?.hasCachedPendingStageDeliveryReceipt === undefined)
+      return;
+    const changes = backend.pendingStageDeliveryReceiptChanges?.(this.rootRunId, this.receiptCursor);
+    if (changes === undefined) {
+      this.invalidateReceipts();
+      return;
+    }
+    const firstRead = this.receiptCursor === undefined;
+    this.receiptCursor = changes.cursor;
+    if (changes.messageIds === undefined) {
+      if (!firstRead)
+        this.invalidateReceipts();
+      return;
+    }
+    for (const messageId of changes.messageIds) {
+      this.receiptEpochs.set(messageId, (this.receiptEpochs.get(messageId) ?? 0) + 1);
+      for (const state of this.targetsByMessage.get(messageId) ?? [])
+        state.dirty = true;
+    }
+  }
+  invalidateReceipts() {
+    this.receiptGeneration++;
+    this.receiptEpochs.clear();
+    for (const state of this.patterns)
+      state.dirty = true;
+  }
+  refreshStages(runs) {
+    const current = new Map;
+    let ordinal = 0;
+    for (const run of runs) {
+      const root = this.topology.rootOf(run.id);
+      if (run.id !== this.rootRunId && run.rootRunId !== this.rootRunId && root !== this.rootRunId)
+        continue;
+      const resolved = root === this.rootRunId;
+      const hops = this.topology.hopsOf(run.id);
+      for (const stage of run.stages) {
+        if (stage.nodeKind === "tool" || stage.replayKey?.startsWith("prompt:") === true || stage.replayKey?.startsWith("workflow:") === true || stage.workflowChildRun !== undefined || stage.workflowChild !== undefined)
+          continue;
+        const fields = this.fieldsOf(run, stage, resolved, hops);
+        const status = { run, stage, resolved, hops, ordinal: ordinal++ };
+        for (const state of fields.matched) {
+          const stages = current.get(state);
+          if (stages === undefined)
+            current.set(state, [status]);
+          else
+            stages.push(status);
+        }
+      }
+    }
+    for (const state of this.patterns) {
+      const stages = current.get(state) ?? [];
+      if (stages.length !== state.stages.length || stages.some((status, index) => {
+        const previous = state.stages[index];
+        return previous.stage !== status.stage || previous.run !== status.run;
+      }))
+        state.dirty = true;
+      state.stages = stages;
+    }
+  }
+  fieldsOf(run, stage, resolved, hops) {
+    let fields = this.stageFields.get(stage);
+    const matchable = resolved && hops !== undefined;
+    let changed = false;
+    if (fields === undefined || fields.run !== run || fields.resolved !== resolved || fields.hops !== hops || fields.id !== stage.id || fields.name !== stage.name || fields.status !== stage.status || fields.error !== stage.error || fields.sessionId !== stage.sessionId || fields.pendingStageDeliveryAvailable !== stage.pendingStageDeliveryAvailable) {
+      const previous = fields;
+      const sameMatching = previous !== undefined && previous.run === run && previous.resolved === resolved && previous.hops === hops && previous.id === stage.id && previous.name === stage.name;
+      fields = {
+        run,
+        status: stage.status,
+        error: stage.error,
+        sessionId: stage.sessionId,
+        pendingStageDeliveryAvailable: stage.pendingStageDeliveryAvailable,
+        resolved,
+        hops,
+        id: stage.id,
+        name: stage.name,
+        tested: sameMatching ? previous.tested : 0,
+        matched: sameMatching ? previous.matched : []
+      };
+      this.stageFields.set(stage, fields);
+      changed = true;
+    }
+    if (fields.tested < this.patterns.length) {
+      const added = this.patterns.slice(fields.tested);
+      if (!matchable)
+        fields.matched.push(...added);
+      else {
+        const index = createStagePathPatternIndex(added.map((state) => state.segments));
+        for (const position of index.matching(hops, [stage.id, stage.name]))
+          fields.matched.push(added[position]);
+      }
+      fields.tested = this.patterns.length;
+    }
+    if (changed)
+      for (const state of fields.matched)
+        state.dirty = true;
+    return fields;
+  }
+  recompute(state, backend) {
+    state.dirty = false;
+    const statuses = [];
+    for (const { run, stage, resolved, hops } of state.stages) {
+      const fields = this.stageFields.get(stage);
+      for (const entry of state.entries) {
+        let byStage = this.statusCache.get(entry);
+        if (byStage === undefined) {
+          byStage = new Map;
+          this.statusCache.set(entry, byStage);
+        }
+        const epoch = this.receiptEpochs.get(entry.id) ?? 0;
+        let cached = byStage.get(stage);
+        if (cached === undefined || cached.fields !== fields || cached.generation !== this.receiptGeneration || cached.epoch !== epoch) {
+          cached = {
+            fields,
+            generation: this.receiptGeneration,
+            epoch,
+            status: this.status(entry, run, stage, resolved && hops !== undefined, backend)
+          };
+          byStage.set(stage, cached);
+        }
+        statuses.push(cached.status);
+      }
+    }
+    if (!sameStatuses(statuses, state.statuses))
+      state.statuses = statuses;
+  }
+  receiptsOf(entry, runId, stageId) {
+    let byStage = this.deliveriesByEntry.get(entry);
     if (byStage === undefined) {
       byStage = new Map;
-      for (const delivery of entries[index].deliveries ?? []) {
+      for (const delivery of entry.deliveries ?? []) {
         const key = `${delivery.runId}\x00${delivery.stageId}`;
         const list = byStage.get(key);
         if (list === undefined)
@@ -61031,75 +62220,185 @@ function stickyStageDeliveryStatuses(runs, rootRunId, availableBackend) {
         else
           list.push(delivery);
       }
-      deliveriesByEntry.set(index, byStage);
+      this.deliveriesByEntry.set(entry, byStage);
     }
     return byStage.get(`${runId}\x00${stageId}`) ?? [];
-  };
-  availableBackend = availableRunDurableBackend(runs, rootRunId) ?? availableBackend;
-  const backend = availableBackend === undefined ? undefined : durableBackendForRun(availableBackend, runs, rootRunId);
-  const runById = new Map(runs.map((run) => [run.id, run]));
-  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
-  for (const run of runs) {
-    const durableRootRunId = reciprocalWorkflowRootRunId(runById, run.id);
-    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunId !== rootRunId)
-      continue;
-    const resolved = durableRootRunId === rootRunId;
-    const hops = hopsFor(run.id);
-    for (const stage of run.stages) {
-      if (stage.nodeKind === "tool" || stage.replayKey?.startsWith("prompt:") === true || stage.replayKey?.startsWith("workflow:") === true || stage.workflowChildRun !== undefined || stage.workflowChild !== undefined)
+  }
+  status(entry, run, stage, matchable, backend) {
+    const target = entry.targetPath ?? entry.stageKey;
+    const receipts = this.receiptsOf(entry, run.id, stage.id);
+    const delivered = backend?.hasCachedPendingStageDeliveryReceipt?.(this.rootRunId, entry.id, { runId: run.id, stageId: stage.id, sessionId: stage.sessionId, admission: "context" }, stage.sessionId === undefined) === true || receipts.some((delivery) => delivery.admission === "context" && delivery.sessionId !== undefined && (stage.sessionId === undefined || delivery.sessionId === stage.sessionId));
+    let state;
+    let reason;
+    if (!matchable) {
+      state = "root-unresolved";
+      reason = "Repair reciprocal parent/boundary ownership before startup";
+    } else if (delivered) {
+      state = "delivered";
+      reason = "Startup context admission confirmed; sticky subscription remains for future stages";
+    } else if (["completed", "failed", "skipped"].includes(stage.status)) {
+      state = "stage-terminal";
+      reason = `${stage.error ? `${stage.error}; ` : ""}Stage ended without confirmed context admission; steer a live stage or start a new stage`;
+    } else if (receipts.some((delivery) => delivery.admission !== "context" && (delivery.sessionId === undefined || stage.sessionId === undefined || delivery.sessionId === stage.sessionId))) {
+      state = "receipt-unverified";
+      reason = "Live delivery receipt only; inspect the session transcript to confirm context admission";
+    } else if (stage.pendingStageDeliveryAvailable !== true) {
+      state = "delivery-unavailable";
+      reason = "Stage has no pre-start Intercom helper; enable Intercom in the invocation group";
+    } else if (receipts.length > 0) {
+      state = "session-replaced";
+      reason = "Only a previous session has a receipt; replacement must drain before its first turn";
+    } else {
+      state = "queued";
+      reason = "No delivery receipt; stage startup must drain before its first turn";
+    }
+    return {
+      messageId: entry.message.id,
+      target,
+      runId: run.id,
+      stageId: stage.id,
+      ...stage.sessionId === undefined ? {} : { sessionId: stage.sessionId },
+      state,
+      reason
+    };
+  }
+  assemble(runs, rootRun) {
+    const rows = [];
+    const scanTargets = [...this.targets.values()].filter((state) => state.queued > 0 && state.segments !== undefined && !(state.segments.length === 1 && state.segments[0] === "**"));
+    let liveStageMatches;
+    const rowTargets = new Set;
+    for (const [position, scanEntry] of (rootRun.possibleStages ?? []).entries()) {
+      const rowSegments = splitStagePathSegments(scanEntry);
+      if (rowSegments.length === 0 || rowSegments.some((segment) => segment.length === 0))
         continue;
-      const matchedEntries = resolved && hops ? patternIndex.matching(hops, [stage.id, stage.name]).flatMap((pattern) => entriesByPattern[pattern]).sort((left, right) => left - right) : ownEntries;
-      for (const index of matchedEntries) {
-        const entry = entries[index];
-        const target = entry.targetPath ?? entry.stageKey;
-        const receipts = entryReceipts(index, run.id, stage.id);
-        const delivered = backend?.hasCachedPendingStageDeliveryReceipt?.(rootRunId, entry.id, {
-          runId: run.id,
-          stageId: stage.id,
-          sessionId: stage.sessionId,
-          admission: "context"
-        }, stage.sessionId === undefined) === true || receipts.some((delivery) => delivery.admission === "context" && delivery.sessionId !== undefined && (stage.sessionId === undefined || delivery.sessionId === stage.sessionId));
-        let state;
-        let reason;
-        if (!resolved || !hops) {
-          state = "root-unresolved";
-          reason = "Repair reciprocal parent/boundary ownership before startup";
-        } else if (delivered) {
-          state = "delivered";
-          reason = "Startup context admission confirmed; sticky subscription remains for future stages";
-        } else if (["completed", "failed", "skipped"].includes(stage.status)) {
-          state = "stage-terminal";
-          reason = `${stage.error ? `${stage.error}; ` : ""}Stage ended without confirmed context admission; steer a live stage or start a new stage`;
-        } else if (receipts.some((delivery) => delivery.admission !== "context" && (delivery.sessionId === undefined || stage.sessionId === undefined || delivery.sessionId === stage.sessionId))) {
-          state = "receipt-unverified";
-          reason = "Live delivery receipt only; inspect the session transcript to confirm context admission";
-        } else if (stage.pendingStageDeliveryAvailable !== true) {
-          state = "delivery-unavailable";
-          reason = "Stage has no pre-start Intercom helper; enable Intercom in the invocation group";
-        } else if (receipts.length > 0) {
-          state = "session-replaced";
-          reason = "Only a previous session has a receipt; replacement must drain before its first turn";
-        } else {
-          state = "queued";
-          reason = "No delivery receipt; stage startup must drain before its first turn";
-        }
-        result.push({
-          messageId: entry.message.id,
-          target,
-          runId: run.id,
-          stageId: stage.id,
-          ...stage.sessionId === undefined ? {} : { sessionId: stage.sessionId },
-          state,
-          reason
-        });
+      if (!rowSegments.some((segment) => segment.includes("*"))) {
+        liveStageMatches ??= this.materializedStageMatcher(runs);
+        if (liveStageMatches(rowSegments))
+          continue;
       }
+      let matches = this.scanMatches.get(scanEntry);
+      if (matches === undefined) {
+        matches = new Map;
+        this.scanMatches.set(scanEntry, matches);
+      }
+      let queuedCount = 0;
+      for (const state of scanTargets) {
+        let match = matches.get(state);
+        if (match === undefined) {
+          const segments = state.segments;
+          match = matchStagePathSegments(rowSegments, segments) || matchStagePathSegments(segments, rowSegments);
+          matches.set(state, match);
+        }
+        if (match)
+          queuedCount += state.queued;
+      }
+      const target = formatWorkflowStageTarget(this.rootRunId, ...rowSegments);
+      rows.push({ slot: `s${position}`, target, queuedCount });
+      rowTargets.add(target);
+    }
+    let broadcastCount = 0;
+    for (const state of this.targets.values()) {
+      if (state.segments?.length === 1 && state.segments[0] === "**")
+        broadcastCount += state.queued;
+    }
+    const broadcast = formatWorkflowStageTarget(this.rootRunId, "**");
+    rows.push({ slot: "b", target: broadcast, queuedCount: broadcastCount });
+    rowTargets.add(broadcast);
+    const statusTargets = this.patterns.filter((state) => state.statuses.length > 0).sort((left, right) => left.stages[0].ordinal - right.stages[0].ordinal || left.positions[0] - right.positions[0]);
+    const statusesByTarget = new Map(statusTargets.map((state) => [state.target, state.statuses]));
+    for (const state of statusTargets) {
+      if (rowTargets.has(state.target))
+        continue;
+      rowTargets.add(state.target);
+      rows.push({ slot: `d${state.target}`, target: state.target, queuedCount: state.queued, deliveryOnly: true });
     }
+    const result = rows.map((row) => this.row(row.slot, row.target, row.queuedCount, statusesByTarget.get(row.target), row.deliveryOnly));
+    this.pruneRows(result);
+    return result;
   }
-  return result;
+  row(slot, target, queuedCount, deliveryStates, deliveryOnly) {
+    const cached = this.rowCache.get(slot);
+    const same = cached !== undefined && cached.row.target === target && cached.row.queuedCount === queuedCount && cached.row.deliveryOnly === deliveryOnly;
+    if (same && cached.statuses === deliveryStates)
+      return cached.row;
+    const bounded = deliveryStates === undefined ? undefined : this.bounded(deliveryStates);
+    if (same && sameBoundedRow(cached.row, bounded)) {
+      this.rowCache.set(slot, { row: cached.row, statuses: deliveryStates });
+      return cached.row;
+    }
+    const row = {
+      target,
+      queuedCount,
+      ...deliveryOnly === true ? { deliveryOnly } : {},
+      ...bounded
+    };
+    this.rowCache.set(slot, { row, statuses: deliveryStates });
+    return row;
+  }
+  bounded(states) {
+    let bounded = this.boundedStates.get(states);
+    if (bounded === undefined) {
+      bounded = boundPossibleStageDeliveryStates(states);
+      this.boundedStates.set(states, bounded);
+    }
+    return bounded;
+  }
+  pruneRows(rows) {
+    if (this.rowCache.size <= rows.length * 4 + 16)
+      return;
+    const kept = new Set(rows);
+    for (const [key, cached] of this.rowCache)
+      if (!kept.has(cached.row))
+        this.rowCache.delete(key);
+  }
+  materializedStageMatcher(runs) {
+    const invocationRuns = runs.filter((run) => this.topology.rootOf(run.id) === this.rootRunId);
+    return (entrySegments) => {
+      for (const run of invocationRuns) {
+        const hops = this.topology.hopsOf(run.id);
+        if (hops === undefined)
+          continue;
+        for (const stage of run.stages) {
+          if (stage.pendingStageDeliveryAvailable !== true)
+            continue;
+          if (stage.status !== "pending" && stage.status !== "running" && stage.status !== "awaiting_input" && stage.status !== "paused" && stage.status !== "blocked") {
+            continue;
+          }
+          if (stageMatchesPathPattern(entrySegments, hops, [stage.id, stage.name]))
+            return true;
+        }
+      }
+      return false;
+    };
+  }
+}
+function sameBoundedRow(row, bounded) {
+  if (bounded === undefined)
+    return row.deliveryStates === undefined;
+  if (row.deliveryStates === undefined || row.omittedDeliveryStates !== bounded.omittedDeliveryStates)
+    return false;
+  const counts = Object.entries(row.deliveryStateCounts ?? {});
+  const boundedCounts = Object.entries(bounded.deliveryStateCounts ?? {});
+  if (counts.length !== boundedCounts.length || counts.some(([state, count], index) => boundedCounts[index][0] !== state || boundedCounts[index][1] !== count))
+    return false;
+  return sameStatuses(row.deliveryStates, bounded.deliveryStates);
 }
-var init_sticky_stage_delivery_status = __esm(() => {
+function sameStatuses(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index++) {
+    const a = left[index];
+    const b = right[index];
+    if (a.messageId !== b.messageId || a.target !== b.target || a.runId !== b.runId || a.stageId !== b.stageId || a.sessionId !== b.sessionId || a.state !== b.state || a.reason !== b.reason)
+      return false;
+  }
+  return true;
+}
+var init_possible_stage_rows = __esm(() => {
   init_run_owner_backend();
   init_pending_stage_status();
+  init_sticky_delivery_state_bound();
+  init_store_internal();
   init_workflow_stage_target();
 });
 
@@ -61164,11 +62463,32 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
     announceIfPending();
     return routeCompletions.get(runId);
   });
+  const topology = new WorkflowTopologyIndex;
+  const possibleStageRowIndexes = new Map;
+  const rowIdentities = new WeakMap;
+  let nextRowIdentity = 0;
+  const rowIdentity = (row) => {
+    let identity = rowIdentities.get(row);
+    if (identity === undefined) {
+      identity = nextRowIdentity++;
+      rowIdentities.set(row, identity);
+    }
+    return identity;
+  };
+  const possibleStageRowsIndex = (rootRunId) => {
+    let index = possibleStageRowIndexes.get(rootRunId);
+    if (index === undefined) {
+      index = new PossibleStageRowsIndex(rootRunId, topology);
+      possibleStageRowIndexes.set(rootRunId, index);
+    }
+    return index;
+  };
   const announceRoutes = () => {
     if (disposed)
       return;
     const ownedRunIds = new Set;
     const runs = activeStore.runs();
+    topology.refresh(runs);
     const runById = new Map(runs.map((run) => [run.id, run]));
     const childrenByBoundary = new Map;
     for (const run of runs) {
@@ -61183,7 +62503,7 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
     for (const run of runs) {
       if (externalRunRouteOwner(activeStore, run.id) !== undefined || !ownsRun(run.id))
         continue;
-      const rootRunId = reciprocalWorkflowRootRunId(runById, run.id);
+      const rootRunId = topology.rootOf(run.id);
       if (rootRunId === undefined)
         continue;
       ownedRunIds.add(run.id);
@@ -61193,6 +62513,13 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
         runId: parentRun.id,
         stageKeys: [boundary.id, boundary.name].filter((key) => resolveIndexedChildRun(childrenByBoundary, parentRun, key)?.id === run.id)
       };
+      let possibleStages;
+      if (run.id === rootRunId && isTerminalRunStatus(run.status)) {
+        possibleStageRowIndexes.delete(rootRunId);
+        possibleStages = [];
+      } else if (run.id === rootRunId) {
+        possibleStages = possibleStageRowsIndex(rootRunId).rows(runs, run, availableStoreDurableBackend(activeStore, rootRunId));
+      }
       const announcement = {
         runId: run.id,
         group: workflowInvocationIntercomGroup(rootRunId),
@@ -61217,11 +62544,9 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
             group: workflowInvocationIntercomGroup(rootRunId)
           }))
         ],
-        ...run.id === rootRunId ? {
-          possibleStages: possibleStageRows(runs, rootRunId, run, availableStoreDurableBackend(activeStore, rootRunId))
-        } : {}
+        ...possibleStages === undefined ? {} : { possibleStages }
       };
-      const signature = JSON.stringify(announcement);
+      const signature = possibleStages === undefined ? JSON.stringify(announcement) : `${JSON.stringify({ ...announcement, possibleStages: undefined })}\x00${possibleStages.map(rowIdentity).join(",")}`;
       if (announcedRoutes.get(run.id)?.signature === signature)
         continue;
       const entry = { signature };
@@ -61256,6 +62581,10 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
       if (!ownedRunIds.has(runId))
         routeCompletions.delete(runId);
     }
+    for (const rootRunId of possibleStageRowIndexes.keys()) {
+      if (!ownedRunIds.has(rootRunId))
+        possibleStageRowIndexes.delete(rootRunId);
+    }
     sweepPromise = sweepPromise.then(() => outsideWorkflowExecutions(() => settleUndeliverablePendingStageMessages(activeStore, notifyUndeliverable, ownsRun))).then(() => {
       return;
     }).catch((error) => reportWarning(`atomic-workflows: pending stage delivery sweep failed: ${error.message}`));
@@ -61416,102 +62745,6 @@ function stageRouteTarget(runs, rootRunId, runId, stageId, resolveBoundarySegmen
   const boundarySegments = runId === rootRunId ? [] : resolveBoundarySegments(runId);
   return formatWorkflowStageTarget(rootRunId, ...boundarySegments ?? [runId], stageId);
 }
-function possibleStageRows(runs, rootRunId, rootRun, backend) {
-  if (isTerminalRunStatus(rootRun.status))
-    return [];
-  const stickyQueued = (rootRun.pendingStageMessages ?? []).filter((entry) => entry.sticky === true && entry.status === "queued");
-  const segmentsByTarget = new Map;
-  const stickySegments = (entry) => {
-    const target = entry.targetPath ?? entry.stageKey;
-    if (segmentsByTarget.has(target))
-      return segmentsByTarget.get(target);
-    const parsed = parseWorkflowStageTarget(target);
-    const segments = parsed?.rootRunId === rootRunId ? parsed.segments : undefined;
-    segmentsByTarget.set(target, segments);
-    return segments;
-  };
-  const scanEntries = stickyQueued.filter((entry) => {
-    const segments = stickySegments(entry);
-    return !(segments !== undefined && segments.length === 1 && segments[0] === "**");
-  });
-  const liveStageMatches = materializedStageMatcher(runs, rootRunId);
-  const rows = [];
-  for (const scanEntry of rootRun.possibleStages ?? []) {
-    const rowSegments = splitStagePathSegments(scanEntry);
-    if (rowSegments.length === 0 || rowSegments.some((segment) => segment.length === 0))
-      continue;
-    if (!rowSegments.some((segment) => segment.includes("*")) && liveStageMatches(rowSegments)) {
-      continue;
-    }
-    rows.push({
-      target: formatWorkflowStageTarget(rootRunId, ...rowSegments),
-      queuedCount: scanEntries.filter((entry) => {
-        const segments = stickySegments(entry);
-        if (segments === undefined)
-          return false;
-        return matchStagePathSegments(rowSegments, segments) || matchStagePathSegments(segments, rowSegments);
-      }).length
-    });
-  }
-  rows.push({
-    target: formatWorkflowStageTarget(rootRunId, "**"),
-    queuedCount: stickyQueued.filter((entry) => {
-      const segments = stickySegments(entry);
-      return segments !== undefined && segments.length === 1 && segments[0] === "**";
-    }).length
-  });
-  const statuses = stickyStageDeliveryStatuses(runs, rootRunId, backend);
-  const statusesByTarget = new Map;
-  for (const status of statuses) {
-    const forTarget = statusesByTarget.get(status.target);
-    if (forTarget === undefined)
-      statusesByTarget.set(status.target, [status]);
-    else
-      forTarget.push(status);
-  }
-  const queuedByTarget = new Map;
-  for (const entry of stickyQueued) {
-    const target = entry.targetPath ?? entry.stageKey;
-    queuedByTarget.set(target, (queuedByTarget.get(target) ?? 0) + 1);
-  }
-  const rowTargets = new Set(rows.map((row) => row.target));
-  for (const target of statusesByTarget.keys()) {
-    if (rowTargets.has(target))
-      continue;
-    rowTargets.add(target);
-    rows.push({ target, queuedCount: queuedByTarget.get(target) ?? 0, deliveryOnly: true });
-  }
-  for (let index = 0;index < rows.length; index++) {
-    const row = rows[index];
-    const deliveryStates = statusesByTarget.get(row.target);
-    if (deliveryStates !== undefined)
-      rows[index] = { ...row, deliveryStates };
-  }
-  return rows;
-}
-function materializedStageMatcher(runs, rootRunId) {
-  const runById = new Map(runs.map((run) => [run.id, run]));
-  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
-  const invocationRuns = runs.filter((run) => reciprocalWorkflowRootRunId(runById, run.id) === rootRunId);
-  return (entrySegments) => materializedStageMatches(invocationRuns, hopsFor, entrySegments);
-}
-function materializedStageMatches(invocationRuns, hopsFor, entrySegments) {
-  for (const run of invocationRuns) {
-    const hops = hopsFor(run.id);
-    if (hops === undefined)
-      continue;
-    for (const stage of run.stages) {
-      if (stage.pendingStageDeliveryAvailable !== true)
-        continue;
-      if (stage.status !== "pending" && stage.status !== "running" && stage.status !== "awaiting_input" && stage.status !== "paused" && stage.status !== "blocked") {
-        continue;
-      }
-      if (stageMatchesPathPattern(entrySegments, hops, [stage.id, stage.name]))
-        return true;
-    }
-  }
-  return false;
-}
 function isPendingStageMessageEvent(value2) {
   if (typeof value2 !== "object" || value2 === null)
     return false;
@@ -61895,7 +63128,7 @@ var init_pending_stage_intercom = __esm(() => {
   init_pending_stage_route_capability();
   init_pending_stage_route_readiness();
   init_pending_stage_status();
-  init_sticky_stage_delivery_status();
+  init_possible_stage_rows();
   init_store_internal();
   init_workflow_stage_target();
 });
@@ -64766,9 +65999,146 @@ var init_definitions = __esm(() => {
   workerDefinitionSources = new WeakMap;
 });
 
+// dist/builtin/workflows/src/durable/journal/pool-checkpoint-index.ts
+function push(map, key, value2) {
+  if (key === undefined)
+    return;
+  const list = map.get(key);
+  if (list)
+    list.push(value2);
+  else
+    map.set(key, [value2]);
+}
+
+class Partitions {
+  byRun = new Map;
+  startsByChild = new Map;
+  stagesByGroup = new Map;
+  stagesByReplayKey = new Map;
+  boundariesByStageId = new Map;
+  boundariesByChild = new Map;
+  add(entry) {
+    const checkpoint = entry.checkpoint;
+    push(this.byRun, checkpoint.topology?.run?.runId, entry);
+    if (checkpoint.kind !== "stage")
+      return;
+    const stage = entry;
+    push(this.stagesByGroup, durableStageGroupKey(checkpoint), stage);
+    push(this.stagesByReplayKey, checkpoint.replayKey, stage);
+    const boundary = checkpoint.topology?.boundary;
+    if (!boundary)
+      return;
+    push(this.boundariesByStageId, checkpoint.topology?.stageId, stage);
+    push(this.boundariesByChild, boundary.child?.runId, stage);
+    if (boundary.event === "start")
+      push(this.startsByChild, boundary.child?.runId, stage);
+  }
+}
+function inKeyOrder(entries) {
+  return [...new Set(entries)].sort((left, right) => Buffer.compare(left.order, right.order) || left.seq - right.seq).map((entry) => entry.checkpoint);
+}
+
+class PoolCheckpointView {
+  base;
+  from;
+  delta;
+  constructor(base, from, delta) {
+    this.base = base;
+    this.from = from;
+    this.delta = delta;
+  }
+  entries(partition, key) {
+    const committed = (this.base?.partitions[partition].get(key) ?? []).filter((entry) => entry.seq <= this.from);
+    return [...committed, ...this.delta[partition].get(key) ?? []];
+  }
+}
+
+class PoolCheckpointRead {
+  index;
+  root;
+  pending;
+  constructor(index, root) {
+    this.index = index;
+    this.root = root;
+  }
+  read(tx, events) {
+    return this.index.read(tx, events, this.root, (apply) => {
+      this.pending = apply;
+    });
+  }
+  commit() {
+    this.pending?.();
+    this.pending = undefined;
+  }
+}
+
+class PoolCheckpointIndex {
+  roots = new Map;
+  begin(root) {
+    return new PoolCheckpointRead(this, root);
+  }
+  async read(tx, events, root, onCommit) {
+    const current = this.roots.get(root);
+    let base = current;
+    const head = await tx.get(`SELECT seq, key, at FROM ${events} WHERE run_id = ? ORDER BY seq DESC LIMIT 1`, root);
+    if (base && base.seq > 0) {
+      const mark = head?.seq === base.seq ? head : await tx.get(`SELECT key, at FROM ${events} WHERE run_id = ? AND seq = ?`, root, base.seq);
+      if (!mark || mark.key !== base.key || Number(mark.at) !== base.at)
+        base = undefined;
+    }
+    const from = base?.seq ?? 0;
+    const to = head ? Number(head.seq) : 0;
+    const delta = new Partitions;
+    const added = [];
+    if (to > from) {
+      const rows = await tx.all(`SELECT seq, key, payload FROM ${events} WHERE run_id = ? AND seq > ? AND seq <= ? AND type = ? ORDER BY seq`, root, from, to, RUN_EVENT_TYPES.checkpointRecorded);
+      for (const row of rows) {
+        const checkpoint = JSON.parse(String(row.payload));
+        if (checkpoint.kind === "ui")
+          continue;
+        const entry = {
+          seq: Number(row.seq),
+          order: row.key === null ? Buffer.alloc(0) : Buffer.from(row.key, "utf8"),
+          checkpoint
+        };
+        delta.add(entry);
+        added.push(entry);
+      }
+    }
+    onCommit(() => {
+      const latest = this.roots.get(root);
+      if (!base) {
+        if (latest !== current)
+          return;
+        const fresh = {
+          seq: to,
+          key: head?.key ?? null,
+          at: Number(head?.at ?? 0),
+          partitions: delta
+        };
+        this.roots.set(root, fresh);
+        return;
+      }
+      if (latest !== base || to <= base.seq)
+        return;
+      for (const entry of added)
+        if (entry.seq > base.seq)
+          base.partitions.add(entry);
+      base.seq = to;
+      base.key = head?.key ?? null;
+      base.at = Number(head?.at ?? 0);
+    });
+    return new PoolCheckpointView(base, from, delta);
+  }
+}
+var init_pool_checkpoint_index = __esm(() => {
+  init_stage_topology_validation();
+  init_types();
+});
+
 // dist/builtin/workflows/src/durable/journal/pool-mutations.ts
 import { StorageProvider as StorageProvider2 } from "@bastani/atomic/storage";
-async function validatePoolMutation(tx, journal, root, work, mutation) {
+async function validatePoolMutation(tx, journal, root, work, mutation, checkpoints) {
   if (!["checkpoint", "session-create", "session-replace"].includes(mutation.kind))
     throw new Error("Invalid pool mutation");
   const checkpoint = mutation.checkpoint;
@@ -64788,42 +66158,59 @@ async function validatePoolMutation(tx, journal, root, work, mutation) {
   }
   if (checkpoint.kind === "ui")
     return;
-  const rows = await tx.all(`SELECT payload FROM ${journal.events} WHERE run_id = ? AND type = ?`, root, RUN_EVENT_TYPES.checkpointRecorded);
-  const records = rows.map((row) => JSON.parse(String(row.payload)));
-  const stages = records.filter((entry) => entry.kind === "stage");
+  const view = await checkpoints.read(tx, journal.events);
   const topology = checkpoint.topology;
   const run = topology?.run;
   if (!topology || !run || run.rootRunId !== root || run.runId === root)
     throw new Error("Pool topology scope mismatch");
-  const owner = stages.find((entry) => entry.topology?.boundary?.event === "start" && entry.topology.boundary.child.runId === run.runId)?.topology?.boundary;
+  const owner = inKeyOrder(view.entries("startsByChild", run.runId))[0]?.topology?.boundary;
   if (!owner || !sameRun(run, owner.child) || !key.startsWith(`${owner.replayScope}:`) || !checkpoint.checkpointId.startsWith(`${owner.replayScope}:`) || !(owner.replayScope === work.scope || owner.replayScope.startsWith(prefix)))
     throw new Error("Pool topology scope mismatch");
   if (mutation.kind !== "checkpoint" && "header" in mutation && mutation.header.workflow && (mutation.header.workflow.runId !== run.runId || mutation.header.workflow.stageId !== ("stageId" in topology ? topology.stageId : undefined)))
     throw new Error("Pool session scope mismatch");
+  const runEntries = view.entries("byRun", run.runId);
   if (checkpoint.kind === "tool") {
     const tool = checkpoint.topology;
-    const peers = records.filter((entry) => entry.kind !== "ui" && entry.topology?.run?.runId === run.runId);
+    const peers = runEntries.map((entry) => entry.checkpoint);
     const ids = new Set(peers.map((entry) => entry.kind === "tool" ? entry.topology.nodeId : entry.topology.stageId));
     if (tool.version !== DURABLE_TOOL_TOPOLOGY_VERSION || !tool.nodeId || tool.parentIds.some((id) => id === tool.nodeId || !ids.has(id)) || peers.some((entry) => entry.kind === "tool" ? entry.argsHash === checkpoint.argsHash ? entry.topology.nodeId !== tool.nodeId || !sameStrings(entry.topology.parentIds, tool.parentIds) : entry.topology.nodeId === tool.nodeId : entry.topology.stageId === tool.nodeId))
       throw new Error("Pool tool topology scope mismatch");
     return;
   }
-  const next = [...stages.filter((entry) => entry.checkpointId !== checkpoint.checkpointId), checkpoint];
-  const tools = new Set(records.flatMap((entry) => entry.kind === "tool" && entry.topology?.run?.runId === run.runId ? [entry.topology.nodeId] : []));
+  const runStages = runEntries.filter((entry) => entry.checkpoint.kind === "stage");
+  const relevant = [...runStages];
+  const groups = new Set([...runStages.map((entry) => entry.checkpoint), checkpoint].filter((entry) => entry === checkpoint || entry.checkpointId !== checkpoint.checkpointId).map(durableStageGroupKey));
+  for (const group of groups)
+    relevant.push(...view.entries("stagesByGroup", group));
+  const boundary = checkpoint.topology?.boundary;
+  let start;
+  if (boundary) {
+    const replayed = view.entries("stagesByReplayKey", checkpoint.replayKey);
+    start = [...stagesExcept(replayed, checkpoint), checkpoint].find((entry) => entry.replayKey === checkpoint.replayKey && entry.topology?.boundary?.event === "start");
+    relevant.push(...replayed);
+    if (start) {
+      const startTopology = start.topology;
+      relevant.push(...view.entries("boundariesByStageId", startTopology.stageId));
+      relevant.push(...view.entries("boundariesByChild", startTopology.boundary.child.runId));
+    }
+  }
+  const next = [...stagesExcept(relevant, checkpoint), checkpoint];
+  const tools = new Set(runEntries.flatMap((entry) => entry.checkpoint.kind === "tool" ? [entry.checkpoint.topology.nodeId] : []));
   const stageError = directChildTopologyError(next, owner.replayScope, run, tools);
   if (stageError)
     throw new Error(`Pool topology scope: ${stageError}`);
-  const boundary = checkpoint.topology?.boundary;
   if (!boundary) {
     if (parseWorkflowChildResult(checkpoint.output))
       throw new Error("Pool boundary output without ownership");
     return;
   }
-  const start = next.find((entry) => entry.replayKey === checkpoint.replayKey && entry.topology?.boundary?.event === "start");
   const boundaryError = start ? boundaryTransitionError(start, next, false) : "missing start";
   if (!boundary.replayScope.startsWith(`${owner.replayScope}:`) || boundary.child.runId === root || boundary.child.runId === work.childRunId || boundaryError)
     throw new Error(`Pool boundary scope: ${boundaryError ?? "invalid child"}`);
 }
+function stagesExcept(entries, checkpoint) {
+  return inKeyOrder(entries).filter((entry) => entry.checkpointId !== checkpoint.checkpointId);
+}
 async function sessionStore(tx, prefix) {
   const database = {
     descriptor: { adapter: "pool-transaction", location: prefix },
@@ -64872,20 +66259,52 @@ var init_pool_mutations = __esm(() => {
   init_boundary_lifecycle();
   init_boundary_topology();
   init_stage_topology_validation();
-  init_types();
+  init_pool_checkpoint_index();
 });
 
 // dist/builtin/workflows/src/durable/journal/pool-stage-usage.ts
 function poolUsageTable(runs) {
   return `${runs}_pool_usage`;
 }
+function poolUsageTotalsTable(runs) {
+  return `${runs}_pool_usage_totals`;
+}
+function addToTotals(totals, runs, work, sign, row) {
+  const assignments = POOL_USAGE_FIELDS.map((field) => {
+    const total = field.toLowerCase();
+    const value2 = `(${sign}${row}.${total})`;
+    return `${total} = ${total} + ${value2}, ${total}_err = ${total}_err + CASE WHEN abs(${total}) > abs(${value2}) THEN (${total} - (${total} + ${value2})) + ${value2} ELSE (${value2} - (${total} + ${value2})) + ${total} END`;
+  });
+  return `UPDATE ${totals} SET ${assignments.join(", ")} WHERE root = (SELECT root FROM ${runs}_work WHERE id = ${work});`;
+}
 function poolUsageSchema(runs) {
-  return `CREATE TABLE IF NOT EXISTS ${poolUsageTable(runs)}(
+  const usage = poolUsageTable(runs);
+  const totals = poolUsageTotalsTable(runs);
+  const columns = POOL_USAGE_FIELDS.map((field) => field.toLowerCase());
+  return `CREATE TABLE IF NOT EXISTS ${usage}(
 		work TEXT NOT NULL REFERENCES ${runs}_work(id) ON DELETE CASCADE,
 		generation INTEGER NOT NULL, key TEXT NOT NULL,
 		input REAL NOT NULL, output REAL NOT NULL, cacheread REAL NOT NULL, cachewrite REAL NOT NULL, cost REAL NOT NULL,
 		PRIMARY KEY(work, generation, key)
-	)`;
+	);
+	CREATE TABLE IF NOT EXISTS ${totals}(
+		root TEXT PRIMARY KEY REFERENCES ${runs}_pool(root) ON DELETE CASCADE,
+		${columns.map((column) => `${column} REAL NOT NULL, ${column}_err REAL NOT NULL`).join(", ")}
+	);
+	CREATE TRIGGER IF NOT EXISTS ${totals}_insert AFTER INSERT ON ${usage} BEGIN
+		${addToTotals(totals, runs, "NEW.work", "", "NEW")}
+	END;
+	CREATE TRIGGER IF NOT EXISTS ${totals}_update AFTER UPDATE ON ${usage}
+	WHEN ${columns.map((column) => `OLD.${column} IS NOT NEW.${column}`).join(" OR ")} OR OLD.work IS NOT NEW.work BEGIN
+		${addToTotals(totals, runs, "OLD.work", "-", "OLD")}
+		${addToTotals(totals, runs, "NEW.work", "", "NEW")}
+	END;
+	CREATE TRIGGER IF NOT EXISTS ${totals}_delete AFTER DELETE ON ${usage} BEGIN
+		DELETE FROM ${totals} WHERE root = (SELECT root FROM ${runs}_work WHERE id = OLD.work);
+	END;
+	CREATE TRIGGER IF NOT EXISTS ${totals}_work_delete BEFORE DELETE ON ${runs}_work BEGIN
+		DELETE FROM ${totals} WHERE root = OLD.root;
+	END;`;
 }
 function poolStageUsageKey(runId, stageId) {
   return `stage:${runId}:${stageId}`;
@@ -64912,7 +66331,7 @@ var init_pool_stage_usage = __esm(() => {
 
 // dist/builtin/workflows/src/durable/journal/sql-pool-queue.ts
 import { createHash as createHash4, randomUUID as randomUUID16 } from "node:crypto";
-import { assertStorageSchemaVersion as assertStorageSchemaVersion2 } from "@bastani/atomic/storage";
+import { assertStorageSchemaVersion as assertStorageSchemaVersion2, StorageError as StorageError2 } from "@bastani/atomic/storage";
 function requestIdentity(request) {
   return createHash4("sha256").update(request).digest("hex");
 }
@@ -64951,6 +66370,7 @@ class SqlPoolQueue {
   operations;
   transaction;
   journal;
+  checkpoints = new PoolCheckpointIndex;
   constructor(storage) {
     this.storage = storage;
     const { transaction, tables: journal } = storage;
@@ -65062,17 +66482,23 @@ class SqlPoolQueue {
     lease = snapshotLease(lease);
     token = { ...token };
     return this.storage.withAppendGuard(async (tx, runId) => {
-      if (runId !== lease.runId)
-        throw new Error("Pool delivery cannot write another root");
-      const { now } = await this.authority(tx, lease).catch((error) => {
-        if (error instanceof StaleLeaseError)
-          throw new Error("Stale pool coordinator authority", { cause: error });
-        throw error;
-      });
-      const row = await this.current(tx, lease, token);
-      if (row.epoch !== lease.epoch || row.expires_at < now)
-        throw new Error(STALE_WORK_LEASE);
-      assertSession();
+      try {
+        if (runId !== lease.runId)
+          throw new Error("Pool delivery cannot write another root");
+        await this.authority(tx, lease).catch((error) => {
+          if (error instanceof StaleLeaseError)
+            throw new Error("Stale pool coordinator authority", { cause: error });
+          throw error;
+        });
+        const row = await this.current(tx, lease, token);
+        if (row.epoch !== lease.epoch)
+          throw new Error(STALE_WORK_LEASE);
+        assertSession();
+      } catch (error) {
+        if (error instanceof JournalError || error instanceof StorageError2 || !(error instanceof Error))
+          throw error;
+        throw new PoolAppendRefusedError(error.message, { cause: error });
+      }
     }, action);
   }
   async assertCurrent(lease, token) {
@@ -65185,7 +66611,8 @@ class SqlPoolQueue {
     const request = serializeJson({ epoch: token.epoch, worker: token.worker, mutation });
     const identity = requestIdentity(request);
     mutation = JSON.parse(request).mutation;
-    return this.transaction(async (tx) => {
+    const checkpoints = this.checkpoints.begin(lease.runId);
+    const receipt = await this.transaction(async (tx) => {
       const { now, status } = await this.authority(tx, lease);
       const row = await this.current(tx, lease, token);
       if (row.epoch !== lease.epoch)
@@ -65200,24 +66627,26 @@ class SqlPoolQueue {
         throw new Error(STALE_WORK_LEASE);
       if (!await this.admitsAttemptWrites(tx, lease, status))
         throw new Error("Pool root is not running");
-      const receipt = mutation.kind === "session-append" ? await this.appendSession(tx, row, mutation, now) : await this.recordCheckpoint(tx, lease, token, row, mutation, now);
+      const receipt = mutation.kind === "session-append" ? await this.appendSession(tx, row, mutation, now) : await this.recordCheckpoint(tx, lease, token, row, mutation, now, checkpoints);
       await tx.run(`INSERT INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, token.id, token.generation, operationId, identity, JSON.stringify(receipt));
       return receipt;
     });
+    checkpoints.commit();
+    return receipt;
   }
   async appendSession(tx, row, mutation, now) {
     return { at: now, lastSeq: await applyPoolSession(tx, `${this.journal.runs}_pool_`, row.id, mutation) };
   }
-  async recordCheckpoint(tx, lease, token, row, mutation, now) {
+  async recordCheckpoint(tx, lease, token, row, mutation, now, checkpoints) {
     const checkpoint = mutation.checkpoint;
-    await validatePoolMutation(tx, this.journal, lease.runId, fromRow(row), mutation);
+    await validatePoolMutation(tx, this.journal, lease.runId, fromRow(row), mutation, checkpoints);
     if (checkpoint.completedAt > Math.max(now, Date.now()) + MAX_WORKER_CLOCK_SKEW_MS)
       throw new Error("Pool checkpoint timestamp is in the future");
     assertWorkflowSerializableObject(checkpoint, "Pool checkpoint");
     const key = JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId]);
     const payload = serializeJson(checkpoint);
     const existing = await tx.get(`SELECT seq, at, payload FROM ${this.journal.events} WHERE run_id = ? AND key = ?`, lease.runId, key);
-    if (existing && existing.payload !== payload)
+    if (existing && !isRecordedCheckpoint(existing.payload, payload))
       throw new Error("Pool checkpoint identity conflict");
     if (existing && mutation.kind !== "checkpoint")
       throw new Error("Pool session checkpoint identity conflict");
@@ -65315,22 +66744,37 @@ class SqlPoolQueue {
     return this.transaction(async (tx) => (await tx.all(`SELECT * FROM ${this.work} WHERE root = ? ORDER BY ready_at, rowid`, root)).map(fromRow));
   }
 }
+function isRecordedCheckpoint(stored, payload) {
+  if (stored === payload)
+    return true;
+  const { completedAt } = JSON.parse(stored);
+  if (typeof completedAt !== "number")
+    return false;
+  return serializeJson({ ...JSON.parse(payload), completedAt }) === stored;
+}
 function openSqlPoolQueue(journal) {
   const storage = sqlPoolStorage(journal);
   if (!storage)
     return Promise.reject(new Error("Worker pool requires a SQL run journal"));
   return SqlPoolQueue.open(storage);
 }
-var STORE_NOW2 = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", MAX_WORKER_CLOCK_SKEW_MS = 1000, POOL_SCHEMA_VERSION = 2, STALE_WORK_LEASE = "Stale work lease";
+var STORE_NOW2 = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", MAX_WORKER_CLOCK_SKEW_MS = 1000, POOL_SCHEMA_VERSION = 2, STALE_WORK_LEASE = "Stale work lease", PoolAppendRefusedError;
 var init_sql_pool_queue = __esm(() => {
   init_serializable();
   init_boundary_topology();
   init_durable_hash();
   init_internal();
+  init_pool_checkpoint_index();
   init_pool_mutations();
   init_pool_stage_usage();
   init_types();
   init_values();
+  PoolAppendRefusedError = class PoolAppendRefusedError extends JournalError {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "PoolAppendRefusedError";
+    }
+  };
 });
 
 // dist/builtin/workflows/src/workers/coordinator-protocol.ts
@@ -65353,15 +66797,22 @@ function validate(report) {
       throw new Error(`Pool usage ${field} must be a finite non-negative number`);
   }
 }
+function addCompensated(total, value2) {
+  const sum = total.sum + value2;
+  total.error += Math.abs(total.sum) > Math.abs(value2) ? total.sum - sum + value2 : value2 - sum + total.sum;
+  total.sum = sum;
+}
 
 class SqlPoolUsage {
   transaction;
   journal;
   table;
+  totals;
   constructor(transaction, journal) {
     this.transaction = transaction;
     this.journal = journal;
     this.table = poolUsageTable(journal.runs);
+    this.totals = poolUsageTotalsTable(journal.runs);
   }
   static async open(transaction, journal) {
     const usage = new SqlPoolUsage(transaction, journal);
@@ -65369,9 +66820,27 @@ class SqlPoolUsage {
     return usage;
   }
   async totalIn(tx, root) {
+    const columns = POOL_USAGE_FIELDS.map((field) => field.toLowerCase());
+    const kept = await tx.get(`SELECT * FROM ${this.totals} WHERE root = ?`, root);
+    if (kept)
+      return Object.fromEntries(POOL_USAGE_FIELDS.map((field, index) => [
+        field,
+        Number(kept[columns[index]]) + Number(kept[`${columns[index]}_err`])
+      ]));
     const row = await tx.get(`SELECT ${POOL_USAGE_FIELDS.map((field) => `COALESCE(SUM(u.${field.toLowerCase()}), 0) AS ${field}`).join(", ")}
 			 FROM ${this.table} u JOIN ${this.journal.runs}_work w ON w.id = u.work WHERE w.root = ?`, root);
-    return Object.fromEntries(POOL_USAGE_FIELDS.map((field) => [field, Number(row?.[field] ?? 0)]));
+    const total = Object.fromEntries(POOL_USAGE_FIELDS.map((field) => [field, Number(row?.[field] ?? 0)]));
+    if (!await tx.get(`SELECT 1 FROM ${this.journal.runs}_pool WHERE root = ?`, root))
+      return total;
+    const sums = columns.map(() => ({ sum: 0, error: 0 }));
+    const rows = await tx.all(`SELECT ${columns.map((column) => `u.${column}`).join(", ")}
+			 FROM ${this.table} u JOIN ${this.journal.runs}_work w ON w.id = u.work WHERE w.root = ?`, root);
+    for (const usage of rows)
+      for (const [index, column] of columns.entries())
+        addCompensated(sums[index], Number(usage[column]));
+    await tx.run(`INSERT INTO ${this.totals}(root, ${columns.map((column) => `${column}, ${column}_err`).join(", ")})
+			 VALUES (?, ${columns.map(() => "?, ?").join(", ")})`, root, ...sums.flatMap(({ sum, error }) => [sum, error]));
+    return total;
   }
   async report(lease, token, reports) {
     validateText("runId", lease.runId);
@@ -68724,29 +70193,23 @@ var init_run_durable_stage_session = __esm(() => {
 
 // dist/builtin/workflows/src/durable/completed-subtree.ts
 function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
-  const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
-  if (!nested.some((run) => run.id === childRunId))
+  const catalog = durableNestedRunCatalog(backend, rootWorkflowId);
+  if (!catalog.positionsById.has(childRunId))
     return;
-  const intentionalExitStatuses = new Map;
-  for (const checkpoint of backend.listCheckpoints(rootWorkflowId)) {
-    if (checkpoint.kind !== "stage")
-      continue;
-    const child = parseWorkflowChildResult(checkpoint.output);
-    if (child?.exited === true)
-      intentionalExitStatuses.set(child.runId, child.status);
-  }
   const included = new Set([childRunId]);
-  let priorSize = -1;
-  while (priorSize !== included.size) {
-    priorSize = included.size;
-    for (const run of nested) {
-      if (run.parentRunId !== undefined && included.has(run.parentRunId))
-        included.add(run.id);
+  const pending = [childRunId];
+  for (let runId = pending.pop();runId !== undefined; runId = pending.pop()) {
+    for (const childId of catalog.childIdsByParent.get(runId) ?? []) {
+      if (included.has(childId))
+        continue;
+      included.add(childId);
+      pending.push(childId);
     }
   }
-  const subtree = nested.filter((run) => included.has(run.id));
-  const complete = subtree.length === included.size && subtree.every((run) => isCompleteCachedRun(run, intentionalExitStatuses));
-  return complete ? subtree : undefined;
+  const positions = [...included].flatMap((runId) => catalog.positionsById.get(runId) ?? []).sort((left, right) => left - right);
+  const subtree = positions.map((position) => catalog.runs[position]);
+  const complete = subtree.length === included.size && subtree.every((run) => isCompleteCachedRun(run, catalog.intentionalExitStatuses));
+  return complete ? subtree.map(cloneRunSnapshot) : undefined;
 }
 function isCompleteCachedRun(run, intentionalExitStatuses) {
   if (run.endedAt === undefined || !run.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
@@ -68867,7 +70330,7 @@ function createDurableCachedStageRecorder(input) {
       const persistence = stage === undefined ? undefined : input.backend.commitCheckpoint({
         kind: "stage",
         workflowId: input.run.id,
-        checkpointId: `stage-replay-meta:${durableHash({ replayKey, stageId: stage.id, parentIds: stage.parentIds })}`,
+        checkpointId: `${STAGE_REPLAY_METADATA_CHECKPOINT_PREFIX}${durableHash({ replayKey, stageId: stage.id, parentIds: stage.parentIds })}`,
         name,
         replayKey,
         completedAt: Date.now(),
@@ -77288,11 +78751,68 @@ function runResultFields(backend, handle) {
   const result = durableRunResult(backend, handle.workflowId);
   return result === undefined ? {} : { result };
 }
-function durableNestedRunSnapshots(backend, rootWorkflowId) {
+function durableNestedRunCatalog(backend, rootWorkflowId) {
   const handle = backend.getWorkflow(rootWorkflowId);
   if (handle === undefined)
-    return [];
-  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, ACTIVE_INSPECTION_RECONSTRUCTION).filter((run) => run.id !== rootWorkflowId);
+    return EMPTY_NESTED_RUN_CATALOG;
+  const version = backend.nestedSnapshotVersion?.(rootWorkflowId);
+  const cached = version === undefined ? undefined : nestedRunCatalogs.get(backend)?.get(rootWorkflowId);
+  if (cached !== undefined && cached.version === version && cached.name === handle.name && (cached.updatedAt === undefined || cached.updatedAt === handle.updatedAt)) {
+    return cached.catalog;
+  }
+  const checkpoints = backend.listCheckpoints(rootWorkflowId);
+  const runs = runSnapshotsFromCheckpoints(checkpoints, rootWorkflowId, handle.name, handle.updatedAt, ACTIVE_INSPECTION_RECONSTRUCTION).filter((run) => run.id !== rootWorkflowId);
+  const catalog = nestedRunCatalog(runs, checkpoints);
+  if (version !== undefined) {
+    const byRoot = nestedRunCatalogs.get(backend) ?? new Map;
+    nestedRunCatalogs.set(backend, byRoot);
+    byRoot.delete(rootWorkflowId);
+    byRoot.set(rootWorkflowId, {
+      version,
+      name: handle.name,
+      updatedAt: runs.some(readsFallbackCompletedAt) ? handle.updatedAt : undefined,
+      catalog
+    });
+    if (byRoot.size > MAX_CACHED_ROOTS_PER_BACKEND)
+      byRoot.delete(byRoot.keys().next().value);
+  }
+  return catalog;
+}
+function nestedRunCatalog(runs, checkpoints) {
+  const positionsById = new Map;
+  const childIdsByParent = new Map;
+  runs.forEach((run, position) => {
+    const positions = positionsById.get(run.id);
+    if (positions === undefined)
+      positionsById.set(run.id, [position]);
+    else
+      positions.push(position);
+    if (run.parentRunId === undefined)
+      return;
+    const children = childIdsByParent.get(run.parentRunId);
+    if (children === undefined)
+      childIdsByParent.set(run.parentRunId, [run.id]);
+    else
+      children.push(run.id);
+  });
+  const intentionalExitStatuses = new Map;
+  for (const checkpoint of checkpoints) {
+    if (checkpoint.kind !== "stage")
+      continue;
+    const child = parseWorkflowChildResult(checkpoint.output);
+    if (child?.exited === true)
+      intentionalExitStatuses.set(child.runId, child.status);
+  }
+  return { runs, positionsById, childIdsByParent, intentionalExitStatuses };
+}
+function readsFallbackCompletedAt(run) {
+  return run.endedAt !== undefined && run.stages.some((stage) => stage.endedAt === undefined);
+}
+function cloneRunSnapshot(run) {
+  const copy = structuredClone(run);
+  for (const tool of copy.toolNodes)
+    Object.freeze(tool.parentIds);
+  return copy;
 }
 async function validatedStageTranscript(stage, store) {
   if (stage.sessionId !== undefined && await isReopenableSession(store, stage.sessionId))
@@ -77322,11 +78842,8 @@ function checkpointDrafts(checkpoints) {
     tools: [...toolByHash.values()]
   };
 }
-function completedToolNodes(checkpoints, runId, rootRunId, sourceIds) {
-  return checkpoints.flatMap((checkpoint) => {
-    const topologyRunId = checkpoint.topology?.run?.runId ?? rootRunId;
-    if (topologyRunId !== runId)
-      return [];
+function completedToolNodes(ownedCheckpoints, sourceIds) {
+  return ownedCheckpoints.flatMap((checkpoint) => {
     const topology = checkpoint.topology;
     if (topology === undefined)
       return [];
@@ -77363,18 +78880,34 @@ function summarizeCompletedToolResult(value2) {
   return serialized.length <= 240 ? serialized : `${flattenTruncatedString(serialized.slice(0, 237))}...`;
 }
 function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallbackCompletedAt, policy = COMPLETED_RECONSTRUCTION) {
-  if (!validBoundaryRecordSet(checkpoints, policy.requireTerminal))
+  const index = new CheckpointCatalogIndex(checkpoints);
+  if (!validBoundaryRecordSet(index, policy.requireTerminal))
     return [];
-  const stageRecords = checkpoints.filter((checkpoint) => checkpoint.kind === "stage");
+  const stageRecords = index.stages;
   const identityRecords = stageRecords.filter((stage) => stage.topology?.sourceOrder !== undefined || stage.topology?.status !== undefined || stage.topology?.occurrenceKey !== undefined || stage.topology?.boundary !== undefined);
   if (immutableStageGroupError(identityRecords) !== undefined)
     return [];
-  const recordsByGroup = groupByDurableStageKey(stageRecords);
-  const candidates = [...recordsByGroup.values()].map((records) => mergeStageGroup(records, stageRecords, checkpoints)).filter((draft) => policy.retainActive || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined).sort(compareDraftSourceOrder);
+  const candidates = [...index.stageGroups()].map((records) => mergeStageGroup(records, index)).filter((draft) => policy.retainActive || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined).sort(compareDraftSourceOrder);
   const drafts = checkpointDrafts(checkpoints);
   const toolCheckpoints = drafts.tools;
   if (toolCheckpoints.some((checkpoint) => checkpoint.topology === undefined))
     return [];
+  const toolNodeIdsByClaimedRun = new Map;
+  const toolsByRun = new Map;
+  for (const checkpoint of toolCheckpoints) {
+    const claimedRunId = checkpoint.topology?.run?.runId;
+    if (claimedRunId !== undefined) {
+      const ids = toolNodeIdsByClaimedRun.get(claimedRunId) ?? new Set;
+      ids.add(checkpoint.topology.nodeId);
+      toolNodeIdsByClaimedRun.set(claimedRunId, ids);
+    }
+    const ownerRunId = claimedRunId ?? rootRunId;
+    const owned = toolsByRun.get(ownerRunId);
+    if (owned === undefined)
+      toolsByRun.set(ownerRunId, [checkpoint]);
+    else
+      owned.push(checkpoint);
+  }
   for (const draft of candidates) {
     const boundary = draft.topology?.boundary;
     if (boundary === undefined || childRunIdFromDraft(draft) === undefined)
@@ -77388,8 +78921,8 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       parentStageId: boundary.child.parentStageId,
       rootRunId: boundary.child.rootRunId
     };
-    const childToolIds = new Set(toolCheckpoints.flatMap((checkpoint) => checkpoint.topology?.run?.runId === expectedChildRun.runId ? [checkpoint.topology.nodeId] : []));
-    if (directChildTopologyError(stageRecords, boundary.replayScope, expectedChildRun, childToolIds) !== undefined)
+    const childToolIds = toolNodeIdsByClaimedRun.get(expectedChildRun.runId) ?? new Set;
+    if (directChildTopologyErrorFromRecords(index.directChildRecords(expectedChildRun.runId), boundary.replayScope, expectedChildRun, childToolIds) !== undefined)
       return [];
   }
   if (candidates.length === 0 && toolCheckpoints.length === 0) {
@@ -77417,7 +78950,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     group.sort(compareDraftSourceOrder);
   if (!retainReachableRunGroups(grouped, rootRunId) && policy.failOnUnreachable)
     return [];
-  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints, policy.retainActive))
+  if (!validateRunGroups(grouped, rootRunId, toolsByRun, index, policy.retainActive))
     return [];
   const syntheticChildren = [];
   const pendingChildren = [];
@@ -77431,7 +78964,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       const child = workflowChildFromDraft(draft);
       if (child?.exited !== true || grouped.has(child.runId))
         continue;
-      if (!isSyntheticExitedChild(draft, parentRunId, child.runId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, child.runId)) {
+      if (!isSyntheticExitedChild(draft, parentRunId, child.runId, rootRunId) || index.childScopedEvidenceExists(draft.replayKey, child.runId)) {
         return [];
       }
       syntheticChildren.push({ parentRunId, owner: draft, child });
@@ -77439,7 +78972,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   const idMaps = new Map;
   for (const [runId, runDrafts] of grouped) {
-    const ownedTools = toolCheckpoints.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
+    const ownedTools = toolsByRun.get(runId) ?? [];
     if (!validStageGroup(runDrafts, runId, rootRunId, ownedTools))
       return [];
     const ids = new Map;
@@ -77457,32 +78990,45 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     });
     if (hasIdentityConflict)
       return [];
-    for (const checkpoint of toolCheckpoints) {
-      const ownerRunId = checkpoint.topology?.run?.runId ?? rootRunId;
+    for (const checkpoint of ownedTools) {
       const sourceId = checkpoint.topology?.nodeId ?? checkpoint.checkpointId;
-      if (ownerRunId === runId)
-        ids.set(sourceId, sourceId);
+      ids.set(sourceId, sourceId);
     }
     idMaps.set(runId, ids);
   }
+  const boundaryOwners = new Map;
+  const boundarySourcesByParent = new Map;
+  for (const [parentRunId, runDrafts] of grouped) {
+    const sources = new Map;
+    for (const draft of runDrafts) {
+      const childRunId = childRunIdFromDraft(draft);
+      if (childRunId === undefined)
+        continue;
+      if (!boundaryOwners.has(childRunId))
+        boundaryOwners.set(childRunId, draft);
+      if (!sources.has(childRunId))
+        sources.set(childRunId, draft);
+    }
+    boundarySourcesByParent.set(parentRunId, sources);
+  }
   const runs = [];
   const emittedRunIds = new Set;
   for (const [runId, runDrafts] of grouped) {
     const ids = idMaps.get(runId);
-    const ownedTools = toolCheckpoints.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
+    const ownedTools = toolsByRun.get(runId) ?? [];
     const hasUnknownParents = runDrafts.some((draft) => draft.topology.parentIds.some((parentId) => !ids.has(parentId))) || ownedTools.some((checkpoint) => checkpoint.topology?.parentIds.some((parentId) => !ids.has(parentId)) === true);
     if (hasUnknownParents)
       return [];
     const stages = runDrafts.map((draft) => stageSnapshotFromDraft(draft, ids.get(draft.topology.stageId), draft.topology.parentIds.map((parentId) => ids.get(parentId))));
-    const toolNodes = completedToolNodes(toolCheckpoints, runId, rootRunId, ids);
+    const toolNodes = completedToolNodes(ownedTools, ids);
     const run = runTopologyFor(runDrafts, ownedTools);
     const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.startedAt ?? tool.endedAt ?? fallbackCompletedAt));
     const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.endedAt ?? fallbackCompletedAt));
-    const owner = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
+    const owner = runId === rootRunId ? undefined : boundaryOwners.get(runId);
     const status = owner === undefined ? "completed" : childRunStatus(owner);
     const terminal = status !== "running" && status !== "pending" && status !== "paused" && status !== "blocked";
     const parentRunId = run?.parentRunId ?? rootRunId;
-    const boundarySourceId = grouped.get(parentRunId)?.find((draft) => childRunIdFromDraft(draft) === runId)?.topology?.stageId;
+    const boundarySourceId = boundarySourcesByParent.get(parentRunId)?.get(runId)?.topology?.stageId;
     const declaredParentStageId = run?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run.parentStageId);
     const parentStageId = declaredParentStageId ?? (boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
     const ownerChild = owner === undefined ? undefined : workflowChildFromDraft(owner);
@@ -77618,10 +79164,11 @@ function emptyGraphRun(runId, runName, completedAt) {
     resumable: false
   };
 }
-var COMPLETED_RECONSTRUCTION, ACTIVE_INSPECTION_RECONSTRUCTION;
+var MAX_CACHED_ROOTS_PER_BACKEND = 8, nestedRunCatalogs, EMPTY_NESTED_RUN_CATALOG, COMPLETED_RECONSTRUCTION, ACTIVE_INSPECTION_RECONSTRUCTION;
 var init_completed_catalog = __esm(() => {
   init_stage_session_store();
   init_tool_payload_bounds();
+  init_completed_catalog_index();
   init_completed_catalog_stage_groups();
   init_resume_eligibility();
   init_resume_runtime();
@@ -77630,6 +79177,13 @@ var init_completed_catalog = __esm(() => {
   init_workflow_heartbeat_anchor();
   init_stage_topology_validation();
   init_tool_outcome();
+  nestedRunCatalogs = new WeakMap;
+  EMPTY_NESTED_RUN_CATALOG = {
+    runs: [],
+    positionsById: new Map,
+    childIdsByParent: new Map,
+    intentionalExitStatuses: new Map
+  };
   COMPLETED_RECONSTRUCTION = {
     requireTerminal: true,
     retainActive: false,
@@ -89860,7 +91414,119 @@ function observeRunExecution(run, now = Date.now()) {
 }
 
 // dist/builtin/workflows/src/runs/background/run-inspect.ts
-init_sticky_stage_delivery_status();
+init_sticky_delivery_state_bound();
+
+// dist/builtin/workflows/src/shared/sticky-stage-delivery-status.ts
+init_run_owner_backend();
+init_pending_stage_status();
+init_workflow_stage_target();
+function stickyStageDeliveryStatuses(runs, rootRunId, availableBackend) {
+  const root = runs.find((run) => run.id === rootRunId);
+  const entries = (root?.pendingStageMessages ?? []).filter((entry) => entry.sticky === true);
+  const result = [];
+  const patternByTarget = new Map;
+  const patterns = [];
+  const entriesByPattern = [];
+  const ownEntries = [];
+  entries.forEach((entry, index) => {
+    const target = entry.targetPath ?? entry.stageKey;
+    let pattern = patternByTarget.get(target);
+    if (pattern === undefined) {
+      const parsed = parseWorkflowStageTarget(target);
+      pattern = parsed?.rootRunId === rootRunId ? patterns.push(parsed.segments) - 1 : -1;
+      if (pattern >= 0)
+        entriesByPattern.push([]);
+      patternByTarget.set(target, pattern);
+    }
+    if (pattern < 0)
+      return;
+    entriesByPattern[pattern].push(index);
+    ownEntries.push(index);
+  });
+  if (ownEntries.length === 0)
+    return result;
+  const patternIndex = createStagePathPatternIndex(patterns);
+  const deliveriesByEntry = new Map;
+  const entryReceipts = (index, runId, stageId) => {
+    let byStage = deliveriesByEntry.get(index);
+    if (byStage === undefined) {
+      byStage = new Map;
+      for (const delivery of entries[index].deliveries ?? []) {
+        const key = `${delivery.runId}\x00${delivery.stageId}`;
+        const list = byStage.get(key);
+        if (list === undefined)
+          byStage.set(key, [delivery]);
+        else
+          list.push(delivery);
+      }
+      deliveriesByEntry.set(index, byStage);
+    }
+    return byStage.get(`${runId}\x00${stageId}`) ?? [];
+  };
+  availableBackend = availableRunDurableBackend(runs, rootRunId) ?? availableBackend;
+  const backend = availableBackend === undefined ? undefined : durableBackendForRun(availableBackend, runs, rootRunId);
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
+  for (const run of runs) {
+    const durableRootRunId = reciprocalWorkflowRootRunId(runById, run.id);
+    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunId !== rootRunId)
+      continue;
+    const resolved = durableRootRunId === rootRunId;
+    const hops = hopsFor(run.id);
+    for (const stage of run.stages) {
+      if (stage.nodeKind === "tool" || stage.replayKey?.startsWith("prompt:") === true || stage.replayKey?.startsWith("workflow:") === true || stage.workflowChildRun !== undefined || stage.workflowChild !== undefined)
+        continue;
+      const matchedEntries = resolved && hops ? patternIndex.matching(hops, [stage.id, stage.name]).flatMap((pattern) => entriesByPattern[pattern]).sort((left, right) => left - right) : ownEntries;
+      for (const index of matchedEntries) {
+        const entry = entries[index];
+        const target = entry.targetPath ?? entry.stageKey;
+        const receipts = entryReceipts(index, run.id, stage.id);
+        const delivered = backend?.hasCachedPendingStageDeliveryReceipt?.(rootRunId, entry.id, {
+          runId: run.id,
+          stageId: stage.id,
+          sessionId: stage.sessionId,
+          admission: "context"
+        }, stage.sessionId === undefined) === true || receipts.some((delivery) => delivery.admission === "context" && delivery.sessionId !== undefined && (stage.sessionId === undefined || delivery.sessionId === stage.sessionId));
+        let state;
+        let reason;
+        if (!resolved || !hops) {
+          state = "root-unresolved";
+          reason = "Repair reciprocal parent/boundary ownership before startup";
+        } else if (delivered) {
+          state = "delivered";
+          reason = "Startup context admission confirmed; sticky subscription remains for future stages";
+        } else if (["completed", "failed", "skipped"].includes(stage.status)) {
+          state = "stage-terminal";
+          reason = `${stage.error ? `${stage.error}; ` : ""}Stage ended without confirmed context admission; steer a live stage or start a new stage`;
+        } else if (receipts.some((delivery) => delivery.admission !== "context" && (delivery.sessionId === undefined || stage.sessionId === undefined || delivery.sessionId === stage.sessionId))) {
+          state = "receipt-unverified";
+          reason = "Live delivery receipt only; inspect the session transcript to confirm context admission";
+        } else if (stage.pendingStageDeliveryAvailable !== true) {
+          state = "delivery-unavailable";
+          reason = "Stage has no pre-start Intercom helper; enable Intercom in the invocation group";
+        } else if (receipts.length > 0) {
+          state = "session-replaced";
+          reason = "Only a previous session has a receipt; replacement must drain before its first turn";
+        } else {
+          state = "queued";
+          reason = "No delivery receipt; stage startup must drain before its first turn";
+        }
+        result.push({
+          messageId: entry.message.id,
+          target,
+          runId: run.id,
+          stageId: stage.id,
+          ...stage.sessionId === undefined ? {} : { sessionId: stage.sessionId },
+          state,
+          reason
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// dist/builtin/workflows/src/runs/background/run-inspect.ts
 init_store();
 
 // dist/builtin/workflows/src/shared/workflow-identity.ts
@@ -89903,7 +91569,7 @@ function inspectRun(runId, opts) {
     inputs: copy.inputs,
     stages: expandedStages.map((stage) => structuredClone(stage)),
     tools: expandedGraph.tools.map((tool) => structuredClone(tool)),
-    deliveryStates: stickyStageDeliveryStatuses(activeStore.runs(), copy.rootRunId ?? copy.id, availableStoreDurableBackend(activeStore, copy.id)).filter((delivery) => copy.id === (copy.rootRunId ?? copy.id) || delivery.runId === copy.id),
+    ...boundStickyDeliveryStates(stickyStageDeliveryStatuses(activeStore.runs(), copy.rootRunId ?? copy.id, availableStoreDurableBackend(activeStore, copy.id)).filter((delivery) => copy.id === (copy.rootRunId ?? copy.id) || delivery.runId === copy.id)),
     result: copy.result,
     error: copy.error ?? (strandedRoot ? IMPOSSIBLE_ROOT_LIVENESS_MESSAGE : effectiveRunStatus(copy) === copy.status ? undefined : structuredRecoverableWorkflowFailureText(copy) ?? actionableReturnedStatusText(copy.result)),
     exited: copy.exited,
@@ -97628,7 +99294,7 @@ function buildWorkflowRunStatusDigest(detail) {
 // dist/builtin/workflows/src/extension/workflow-status-summary.ts
 init_pending_stage_status();
 init_returned_run_status();
-init_sticky_stage_delivery_status();
+init_sticky_delivery_state_bound();
 var workflowStatusRenderRuns = new WeakMap;
 function setWorkflowStatusRenderRuns(result, runs) {
   workflowStatusRenderRuns.set(result, runs);
@@ -97735,7 +99401,7 @@ function summarizeRunSnapshot(run, now = Date.now(), options) {
       ...stage.rateLimits !== undefined ? { rateLimits: stage.rateLimits } : {}
     })),
     pendingStages: pendingWorkflowStageStatuses(run, options?.owningRunStatus, options?.resolveBoundarySegments),
-    deliveryStates: stickyStageDeliveryStatuses(options?.allRuns ?? [run], run.id, options?.durableBackend),
+    ...boundStickyDeliveryStates(stickyStageDeliveryStatuses(options?.allRuns ?? [run], run.id, options?.durableBackend)),
     tools: run.toolNodes.map((tool) => {
       const owner = tool;
       return {
@@ -97937,7 +99603,7 @@ function formatStageStartup(startup, now = Date.now()) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool-content.ts
-init_sticky_stage_delivery_status();
+init_sticky_delivery_state_bound();
 function stringifyWorkflowToolResult(result) {
   return JSON.stringify(result, null, 2);
 }
@@ -98036,9 +99702,13 @@ function renderStatusToolContent(result) {
     }
     for (const entry of run.awaitingInput)
       lines.push(statusAwaitingInputLine(entry));
-    for (const delivery of run.deliveryStates ?? stickyStageDeliveryStatuses(allRuns, run.runId, undefined)) {
+    const deliveries = run.deliveryStates === undefined ? boundStickyDeliveryStates(stickyStageDeliveryStatuses(allRuns, run.runId, undefined)) : run;
+    for (const delivery of deliveries.deliveryStates ?? []) {
       lines.push(`    Intercom delivery ${delivery.messageId} target=${delivery.target} stage=${delivery.runId}/${delivery.stageId}${delivery.sessionId === undefined ? "" : ` session=${delivery.sessionId}`} state=${delivery.state} — ${delivery.reason}`);
     }
+    const omittedDeliveries = omittedDeliveryStatesLine(deliveries);
+    if (omittedDeliveries !== undefined)
+      lines.push(`    ${omittedDeliveries}`);
     for (const stage of run.pendingStages.slice(0, STATUS_PENDING_STAGE_LIMIT)) {
       lines.push(statusPendingStageLine(stage));
     }