@bastani/atomic 0.9.61 → 0.9.62-alpha.1

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [0.9.62] - 2026-11-02
+
+Pooled roots that keep dispatching under load, children that survive a stalled worker, and Intercom sends that no longer report a delivered message as failed.
+
+- **Pooled roots no longer stall while children start:** checkpoints queued back to back share one journal transaction, so a loop that launches dozens of children keeps to its timers; with 300 busy workers, all children ran in 13 s instead of up to 100 s ([#4181](https://github.com/bastani-inc/atomic/pull/4181))
+- **A stalled worker's waiting admissions survive:** a waiting stage, subagent or process admission fenced while its process stalled rejoins the queue instead of failing its child with `Resource admission holder was stopped`, and an admission released for good is a retryable pool fault ([#4180](https://github.com/bastani-inc/atomic/pull/4180))
+- **Unanswered sends are an unknown outcome:** an Intercom send the broker never answered is reported as possibly delivered, not as `Failed to send`, so it is not resent as a duplicate ([#4178](https://github.com/bastani-inc/atomic/pull/4178))
+
+### Fixed
+
+- A workflow that launches many child workflows onto local workers (`workflows.localWorkers`) no longer stalls its own next steps while the children start. Every child launch and every `ctx.tool` step wrote its checkpoint in a journal transaction of its own, one after another. So a loop that launched a few dozen children and then saved its state waited for each launch's write in turn, and on a journal busy with hundreds of workers that took minutes: the loop missed its timers and launches crawled. Checkpoints queued back to back now share one transaction. With 300 busy workers, the step after a 48-child burst finished in 78 ms at the 90th percentile (253 ms at most) instead of 3.4 to 9.4 s (14 s at most), and all 300 children were running in 13 s instead of 40 to 100 s. A workflow started from the SDK also no longer pauses its host for seconds at a time when the process holds thousands of finished runs. ([#4174](https://github.com/bastani-inc/atomic/issues/4174))
+- Children on a local worker pool no longer fail with `Resource admission holder was stopped` under heavy load. A waiting resource admission (a stage session, subagent or process start) whose owner lease lapsed while its process stalled was fenced by another worker's cleanup, and the next pass of its wait failed the child. A waiter holds no capacity, so a live one now rejoins the queue. History pruning keeps a fenced waiter's permit for 10 minutes after its owner's lease lapsed, so it can still be taken back. An admission the pool released for good, for example after its worker exited, or whose permit is gone, is now a retryable `stale_work_lease` fault, replayed within the child's attempt limit, rather than a failure of the child's own work; stopping a worker also keeps its just-fenced waiters stopped. ([#4179](https://github.com/bastani-inc/atomic/issues/4179))
+- An Intercom `send` whose broker response timed out, while the broker still answered its health check, is now reported as an unknown outcome instead of `Failed to send: Send timeout`. The broker can still queue or deliver such a message, so the tool now says to check with the recipient before sending again, and marks the result `outcome: "unknown"`. Under heavy load the old wording led to resends that delivered the message twice. ([#4177](https://github.com/bastani-inc/atomic/issues/4177))
+
+## [0.9.62-alpha.1] - 2026-11-02
+
+Pooled roots that keep dispatching under load, children that survive a stalled worker, and Intercom sends that no longer report a delivered message as failed.
+
+- **Pooled roots no longer stall while children start:** checkpoints queued back to back share one journal transaction, so a loop that launches dozens of children keeps to its timers; with 300 busy workers, all children ran in 13 s instead of up to 100 s ([#4181](https://github.com/bastani-inc/atomic/pull/4181))
+- **A stalled worker's waiting admissions survive:** a waiting stage, subagent or process admission fenced while its process stalled rejoins the queue instead of failing its child with `Resource admission holder was stopped`, and an admission released for good is a retryable pool fault ([#4180](https://github.com/bastani-inc/atomic/pull/4180))
+- **Unanswered sends are an unknown outcome:** an Intercom send the broker never answered is reported as possibly delivered, not as `Failed to send`, so it is not resent as a duplicate ([#4178](https://github.com/bastani-inc/atomic/pull/4178))
+
+### Fixed
+
+- A workflow that launches many child workflows onto local workers (`workflows.localWorkers`) no longer stalls its own next steps while the children start. Every child launch and every `ctx.tool` step wrote its checkpoint in a journal transaction of its own, one after another. So a loop that launched a few dozen children and then saved its state waited for each launch's write in turn, and on a journal busy with hundreds of workers that took minutes: the loop missed its timers and launches crawled. Checkpoints queued back to back now share one transaction. With 300 busy workers, the step after a 48-child burst finished in 78 ms at the 90th percentile (253 ms at most) instead of 3.4 to 9.4 s (14 s at most), and all 300 children were running in 13 s instead of 40 to 100 s. A workflow started from the SDK also no longer pauses its host for seconds at a time when the process holds thousands of finished runs. ([#4174](https://github.com/bastani-inc/atomic/issues/4174))
+- Children on a local worker pool no longer fail with `Resource admission holder was stopped` under heavy load. A waiting resource admission (a stage session, subagent or process start) whose owner lease lapsed while its process stalled was fenced by another worker's cleanup, and the next pass of its wait failed the child. A waiter holds no capacity, so a live one now rejoins the queue. History pruning keeps a fenced waiter's permit for 10 minutes after its owner's lease lapsed, so it can still be taken back. An admission the pool released for good, for example after its worker exited, or whose permit is gone, is now a retryable `stale_work_lease` fault, replayed within the child's attempt limit, rather than a failure of the child's own work; stopping a worker also keeps its just-fenced waiters stopped. ([#4179](https://github.com/bastani-inc/atomic/issues/4179))
+- An Intercom `send` whose broker response timed out, while the broker still answered its health check, is now reported as an unknown outcome instead of `Failed to send: Send timeout`. The broker can still queue or deliver such a message, so the tool now says to check with the recipient before sending again, and marks the result `outcome: "unknown"`. Under heavy load the old wording led to resends that delivered the message twice. ([#4177](https://github.com/bastani-inc/atomic/issues/4177))
+
 ## [0.9.61] - 2026-11-02
 
 Local worker pools that hold up under faults and load, a lighter terminal under heavy workflow load, and workflows that can work in any repository's worktree.

package/dist/builtin/intercom/index.bundle.mjs

@@ -4224,6 +4224,9 @@ import { Text as Text3 } from "@earendil-works/pi-tui";
 function retryErrorDetails(retryToken) {
   return retryToken === undefined ? { error: true } : { error: true, retryToken };
 }
+function sendOutcomeUnknown(error) {
+  return error instanceof PendingSendTimeoutError;
+}
 function retainRecoverableRetry(reservations, attempt) {
   const retryToken = reservations.retainAfterRecoverableDisconnect(attempt);
   return {
@@ -4809,6 +4812,16 @@ ${message}${attachmentText}`);
                   retryIdentities.release(retryIdentity);
                 }
               }
+              if (failure === error && sendOutcomeUnknown(error)) {
+                return {
+                  content: [{
+                    type: "text",
+                    text: `The broker did not answer the send to "${to}" in time, so whether the message was queued or delivered is unknown: it may still arrive. Check with the recipient before sending it again (for a workflow-stage target, \`intercom list\` shows queued counts), because a new send is a new message.`
+                  }],
+                  isError: true,
+                  details: { error: true, outcome: "unknown" }
+                };
+              }
               return {
                 content: [{
                   type: "text",
@@ -5340,6 +5353,7 @@ var init_intercom_tool = __esm(() => {
   init_recoverable_disconnect();
   init_retry_identity();
   init_tool_retry();
+  init_pending_send_registry();
 });
 
 // dist/builtin/intercom/ui/compose.ts

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.61",
+  "version": "0.9.62-alpha.1",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.61",
+  "version": "0.9.62-alpha.1",
   "private": true,
   "description": "Atomic's pi-compatible MCP integration for server connections, OAuth, tools, resources, and terminal management.",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.61",
+  "version": "0.9.62-alpha.1",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.61",
+  "version": "0.9.62-alpha.1",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.61",
+  "version": "0.9.62-alpha.1",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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

@@ -14289,15 +14289,12 @@ class JournalDurableBackend {
   commitCheckpoint(checkpoint, options) {
     if (options?.signal?.aborted)
       return Promise.reject(new JournalOperationAbortedError(checkpoint.workflowId, options.signal.reason instanceof Error ? options.signal.reason : undefined));
-    return this.serialize(checkpoint.workflowId, () => this.checkpoint(checkpoint));
-  }
-  *checkpoint(checkpoint) {
-    validateCheckpointInvocationFingerprint(checkpoint);
-    if (!(yield* this.current(checkpoint.workflowId)))
-      return;
-    yield* this.append(checkpoint.workflowId, { type: RUN_EVENT_TYPES.checkpointRecorded, payload: checkpoint }, {
-      key: JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId])
-    });
+    try {
+      validateCheckpointInvocationFingerprint(checkpoint);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    return this.queueAppend(checkpoint.workflowId, { type: RUN_EVENT_TYPES.checkpointRecorded, payload: checkpoint }, JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId]), true);
   }
   async commitAdditiveCheckpointBestEffort(checkpoint) {
     try {
@@ -14434,7 +14431,7 @@ class JournalDurableBackend {
       payload: { messageId, delivery, ...accounting === undefined ? {} : { accounting } }
     });
   }
-  queueAppend(runId, event, key) {
+  queueAppend(runId, event, key, requiresRegisteredRun = false) {
     try {
       this.ensureOpen();
       this.assertExecutionActive();
@@ -14447,6 +14444,7 @@ class JournalDurableBackend {
       batch.push({
         event,
         ...key === undefined ? {} : { key },
+        ...requiresRegisteredRun ? { requiresRegisteredRun } : {},
         context: AsyncLocalStorage3.snapshot(),
         resolve,
         reject
@@ -14461,9 +14459,12 @@ class JournalDurableBackend {
     }
     return queued;
   }
-  *appendBatch(runId, batch) {
-    if (this.appendBatches.get(runId) === batch)
+  *appendBatch(runId, queued) {
+    if (this.appendBatches.get(runId) === queued)
       this.appendBatches.delete(runId);
+    const batch = yield* this.registeredAppends(runId, queued);
+    if (batch.length === 0)
+      return;
     const appendMany = runJournalAppendMany(this.journal);
     if (appendMany === undefined || batch.length === 1) {
       for (const append of batch) {
@@ -14501,6 +14502,25 @@ class JournalDurableBackend {
         append.reject(failure);
     }
   }
+  *registeredAppends(runId, batch) {
+    if (!batch.some((append) => append.requiresRegisteredRun === true))
+      return [...batch];
+    let registered;
+    try {
+      registered = (yield* this.current(runId)) !== undefined;
+    } catch (error) {
+      for (const append of batch)
+        if (append.requiresRegisteredRun === true)
+          append.reject(error);
+      return batch.filter((append) => append.requiresRegisteredRun !== true);
+    }
+    if (registered)
+      return [...batch];
+    for (const append of batch)
+      if (append.requiresRegisteredRun === true)
+        append.resolve();
+    return batch.filter((append) => append.requiresRegisteredRun !== true);
+  }
   getToolOutput(...args) {
     return this.projection.getToolOutput(...args);
   }
@@ -20703,7 +20723,7 @@ class SqlResourceAdmission {
     signal?.throwIfAborted();
     const operation = randomUUID7();
     const release = (reason = "resource cleanup confirmed") => this.storage.transaction(async (tx) => {
-      await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = ? WHERE operation = ? AND state != 'released'`, reason, operation);
+      await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = ? WHERE operation = ? AND (state != 'released' OR reason = ?)`, reason, operation, FENCED_WAITER_REASON);
     });
     release.bindProcess = async (identity) => {
       if (kind !== "process" || identity.kind !== "unix-process-group" || !Number.isSafeInteger(identity.id) || identity.id <= 0)
@@ -20715,6 +20735,15 @@ class SqlResourceAdmission {
           throw new Error("Resource process permit is no longer held");
       });
     };
+    const keepWaiting = async (tx) => {
+      const permit = await tx.get(`SELECT state, reason FROM ${this.permits} WHERE operation = ?`, operation);
+      if (permit?.state === "released" && permit.reason === FENCED_WAITER_REASON)
+        await tx.run(`UPDATE ${this.permits} SET state = 'waiting', reason = NULL WHERE operation = ?`, operation);
+      else if (permit === undefined)
+        throw new AdmissionHolderStoppedError("permit no longer recorded");
+      else if (permit.state !== "waiting")
+        throw new AdmissionHolderStoppedError(permit.reason === null ? undefined : String(permit.reason));
+    };
     await this.storage.transaction(async (tx) => {
       await tx.run(`UPDATE ${this.owners} SET expires_at = CAST(unixepoch('subsec') * 1000 AS INTEGER) + ? WHERE id = ?`, OWNER_LEASE_MS, this.owner);
       await tx.run(`INSERT INTO ${this.permits}(operation, root, holder, kind, state, owner, attempt) VALUES (?, ?, ?, ?, 'waiting', ?, ?)`, operation, this.options.root, this.options.holder, kind, this.owner, this.options.attempt ? JSON.stringify({
@@ -20737,11 +20766,12 @@ class SqlResourceAdmission {
         const granted = await this.storage.transaction(async (tx) => {
           quarantined = undefined;
           await tx.run(`UPDATE ${this.owners} SET expires_at = CAST(unixepoch('subsec') * 1000 AS INTEGER) + ? WHERE id = ?`, OWNER_LEASE_MS, this.owner);
+          await keepWaiting(tx);
           const { root } = this.options;
           if (!await this.assertCurrentAttempt(tx)) {
             const waiting = await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE operation = ? AND state = 'waiting'`, LATE_ATTEMPT_REASON, operation);
             if (waiting.changes !== 1)
-              throw new Error("Resource admission holder was stopped");
+              throw new AdmissionHolderStoppedError(undefined);
             return false;
           }
           let reason = hostReason;
@@ -20784,7 +20814,7 @@ class SqlResourceAdmission {
           const stageStart = kind === "session" && request?.delegated !== true;
           const updated = await tx.run(`UPDATE ${this.permits} SET state = ?, reason = ?, granted_at = CASE WHEN ? IS NULL AND ? THEN ${NOW_MS} ELSE NULL END WHERE operation = ? AND state = 'waiting'`, reason ? "waiting" : "granted", reason ?? null, reason ?? null, stageStart ? 1 : 0, operation);
           if (updated.changes !== 1)
-            throw new Error("Resource admission holder was stopped");
+            throw new AdmissionHolderStoppedError(undefined);
           return !reason;
         });
         if (granted) {
@@ -20826,7 +20856,7 @@ class SqlResourceAdmission {
 				WHERE p.state IN ('waiting', 'granted')`);
       if (live.some((permit) => this.needsFencing(permit, fence)))
         return true;
-      return !!await db.get(`SELECT 1 AS prunable FROM ${this.permits} WHERE +state = 'released' AND ticket <= ${this.prunableBefore} LIMIT 1`, RELEASED_PERMIT_RETENTION);
+      return !!await db.get(`SELECT 1 AS prunable FROM ${this.permits} r WHERE ${this.prunable} LIMIT 1`, RELEASED_PERMIT_RETENTION, FENCED_WAITER_REASON, FENCED_WAITER_RETENTION_MS);
     });
     if (!pending)
       return;
@@ -20835,7 +20865,7 @@ class SqlResourceAdmission {
       const owners = await tx.all(`SELECT o.* FROM ${this.owners} o WHERE o.id IN (SELECT owner FROM ${this.permits} WHERE state IN ('waiting', 'granted'))`);
       for (const owner of owners) {
         const { rebooted, stopped } = fence(owner);
-        await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'abandoned waiter fenced' WHERE owner = ? AND state = 'waiting' AND (? OR EXISTS (SELECT 1 FROM ${this.owners} WHERE id = ? AND expires_at < ${NOW_MS}))`, owner.id, stopped ? 1 : 0, owner.id);
+        await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = ? WHERE owner = ? AND state = 'waiting' AND (? OR EXISTS (SELECT 1 FROM ${this.owners} WHERE id = ? AND expires_at < ${NOW_MS}))`, FENCED_WAITER_REASON, owner.id, stopped ? 1 : 0, owner.id);
         if (rebooted) {
           await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'host reboot confirmed' WHERE owner = ? AND state = 'granted'`, owner.id);
         } else if (stopped) {
@@ -20853,13 +20883,17 @@ class SqlResourceAdmission {
       }
       await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'legacy waiter fenced' WHERE owner IS NULL AND state = 'waiting'`);
       await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE owner IS NULL AND state = 'granted' AND reason IS NOT ?`, ANONYMOUS_REASON, ANONYMOUS_REASON);
-      await tx.run(`DELETE FROM ${this.permits} WHERE ticket IN (SELECT ticket FROM ${this.permits} WHERE +state = 'released'
-				AND ticket <= ${this.prunableBefore} ORDER BY ticket LIMIT ?)`, RELEASED_PERMIT_RETENTION, RELEASED_PERMIT_PRUNE_BATCH);
+      await tx.run(`DELETE FROM ${this.permits} WHERE ticket IN (SELECT ticket FROM ${this.permits} r WHERE ${this.prunable}
+				ORDER BY ticket LIMIT ?)`, RELEASED_PERMIT_RETENTION, FENCED_WAITER_REASON, FENCED_WAITER_RETENTION_MS, RELEASED_PERMIT_PRUNE_BATCH);
     });
   }
   get prunableBefore() {
     return `(SELECT ticket FROM ${this.permits} WHERE state = 'released' ORDER BY ticket DESC LIMIT 1 OFFSET ?)`;
   }
+  get prunable() {
+    return `+r.state = 'released' AND r.ticket <= ${this.prunableBefore} AND (r.reason IS NOT ? OR NOT EXISTS
+			(SELECT 1 FROM ${this.owners} o WHERE o.id = r.owner AND o.expires_at >= ${NOW_MS} - ?))`;
+  }
   needsFencing(permit, fence) {
     if (permit.owner === null)
       return permit.state === "waiting" || permit.reason !== ANONYMOUS_REASON;
@@ -20884,6 +20918,7 @@ class SqlResourceAdmission {
     await this.reconcile();
     return this.storage.transaction(async (tx) => {
       await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = 'worker exit confirmed' WHERE root = ? AND holder = ? AND state IN ('waiting', 'granted') AND (kind = 'session' OR state = 'waiting')`, this.options.root, holder);
+      await tx.run(`UPDATE ${this.permits} SET reason = 'worker exit confirmed' WHERE root = ? AND holder = ? AND state = 'released' AND reason = ?`, this.options.root, holder, FENCED_WAITER_REASON);
       await tx.run(`UPDATE ${this.permits} SET reason = ? WHERE root = ? AND holder = ? AND kind = 'process' AND state = 'granted' AND reason IS NOT ?`, UNCONFIRMED_REASON, this.options.root, holder, QUARANTINED_REASON);
       const held = await tx.get(`SELECT COUNT(*) AS count FROM ${this.permits} WHERE root = ? AND holder = ? AND kind = 'process' AND state = 'granted'`, this.options.root, holder);
       return Number(held?.count);
@@ -20956,7 +20991,7 @@ async function reapProcessGroups(journal, root, scope) {
     return { survivors: [], unprobeable: [] };
   return settleProcessGroups(storage, root, scope, true);
 }
-var OWNER_LEASE_MS = 30000, REAP_TERM_GRACE_MS = 5000, REAP_KILL_GRACE_MS = 1e4, REAP_POLL_MS = 50, RELEASED_PERMIT_RETENTION = 256, RELEASED_PERMIT_PRUNE_BATCH = 1000, EXPIRED_REASON = "owner expired; cleanup unconfirmed", UNCONFIRMED_REASON = "cleanup unconfirmed", QUARANTINED_REASON = "cleanup unconfirmed; permit quarantined", ANONYMOUS_REASON = "owner identity unavailable; cleanup unconfirmed", QUARANTINED_CAPACITY_WAIT_MS, QuarantinedCapacityError, NOW_MS = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", LATE_ATTEMPT_POLL_MS = 100, LATE_ATTEMPT_REASON = "waiting for its attempt lease", STAGE_START_SPACING_MS = 5000, STAGE_START_PRESSURE_REASON = "paced for host load";
+var OWNER_LEASE_MS = 30000, REAP_TERM_GRACE_MS = 5000, REAP_KILL_GRACE_MS = 1e4, REAP_POLL_MS = 50, RELEASED_PERMIT_RETENTION = 256, RELEASED_PERMIT_PRUNE_BATCH = 1000, EXPIRED_REASON = "owner expired; cleanup unconfirmed", UNCONFIRMED_REASON = "cleanup unconfirmed", QUARANTINED_REASON = "cleanup unconfirmed; permit quarantined", ANONYMOUS_REASON = "owner identity unavailable; cleanup unconfirmed", QUARANTINED_CAPACITY_WAIT_MS, QuarantinedCapacityError, FENCED_WAITER_REASON = "abandoned waiter fenced", FENCED_WAITER_RETENTION_MS, AdmissionHolderStoppedError, NOW_MS = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", LATE_ATTEMPT_POLL_MS = 100, LATE_ATTEMPT_REASON = "waiting for its attempt lease", STAGE_START_SPACING_MS = 5000, STAGE_START_PRESSURE_REASON = "paced for host load";
 var init_resource_admission = __esm(() => {
   init_internal();
   init_sql_run_journal();
@@ -20970,6 +21005,12 @@ var init_resource_admission = __esm(() => {
       super("worker_cleanup_unconfirmed", `Local worker process cleanup unconfirmed; process permit refused after ${Math.round(waitedMs)} ms: ${limits} ${capacity.length === 1 ? "is" : "are"} held by quarantined permits of process groups ${groups} that survived SIGKILL`);
     }
   };
+  FENCED_WAITER_RETENTION_MS = 10 * 60000;
+  AdmissionHolderStoppedError = class AdmissionHolderStoppedError extends WorkflowInfrastructureError {
+    constructor(reason) {
+      super("stale_work_lease", `Stale resource admission attempt: the admission holder was stopped${reason === undefined ? "" : ` (${reason})`}`);
+    }
+  };
 });
 
 // dist/builtin/workflows/src/workers/admission-binding.ts
@@ -68191,6 +68232,37 @@ var init_workflow_route_owner = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/foreground/sdk-intercom.ts
+function indexRoots(runs) {
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const rootOf = new Map;
+  const deliverable = new Set;
+  for (const run of runs) {
+    const root = reciprocalWorkflowRootRunId(runById, run.id);
+    rootOf.set(run.id, root);
+    if (root !== undefined && run.stages.some((stage) => stage.pendingStageDeliveryAvailable === true))
+      deliverable.add(root);
+  }
+  return { rootOf, deliverable };
+}
+function createStandaloneRouteOwnership(store, roots) {
+  const activated = new Set;
+  let index;
+  const dispose = store.subscribeInvalidation(() => {
+    index = undefined;
+  });
+  return {
+    owns: (runId) => {
+      index ??= indexRoots(store.runs());
+      const root = index.rootOf.get(runId) ?? runId;
+      if (!roots.has(root))
+        return false;
+      if (!activated.has(root) && index.deliverable.has(root))
+        activated.add(root);
+      return activated.has(root);
+    },
+    dispose
+  };
+}
 function releaseRoot(owner, runId) {
   const remaining = (owner.roots.get(runId) ?? 1) - 1;
   if (remaining > 0) {
@@ -68206,22 +68278,14 @@ async function acquireStandaloneIntercom(store, runId, cwd) {
     if (hasWorkflowPendingStageRouteOwner(store))
       return async () => {};
     const roots = new Map;
-    const activated = new Set;
     owner = {
       roots,
       ready: outsideWorkflowExecutions(async () => {
         await Promise.resolve().then(() => init_workflow_route_owner());
         const routes = createWorkflowRouteOwner(cwd);
-        const bridge = registerPendingStageIntercomBridge({ events: routes.events }, store, (id) => {
-          const runs = store.runs();
-          const root = durableRootRunIdForRun(runs, id) ?? id;
-          if (!roots.has(root))
-            return false;
-          if (!activated.has(root) && runs.some((run) => durableRootRunIdForRun(runs, run.id) === root && run.stages.some((stage) => stage.pendingStageDeliveryAvailable === true)))
-            activated.add(root);
-          return activated.has(root);
-        });
-        return { routes, bridge };
+        const ownership = createStandaloneRouteOwnership(store, roots);
+        const bridge = registerPendingStageIntercomBridge({ events: routes.events }, store, ownership.owns);
+        return { routes, bridge, unwatch: ownership.dispose };
       })
     };
     owners2.set(store, owner);
@@ -68245,6 +68309,7 @@ async function acquireStandaloneIntercom(store, runId, cwd) {
         initialized.bridge.refresh();
         if (retained.roots.size === 0) {
           initialized.bridge();
+          initialized.unwatch();
           if (owners2.get(store) === retained)
             owners2.delete(store);
         }
@@ -68256,10 +68321,10 @@ async function acquireStandaloneIntercom(store, runId, cwd) {
 var owners2;
 var init_sdk_intercom = __esm(() => {
   init_execution_context_boundary();
-  init_run_owner_backend();
   init_pending_stage_intercom();
   init_intercom_group();
   init_pending_stage_route_readiness();
+  init_workflow_run_ownership();
   owners2 = new WeakMap;
 });