@bastani/atomic 0.9.44-alpha.1 → 0.9.44-alpha.3

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.44-alpha.1",
+  "version": "0.9.44-alpha.3",
   "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/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.44-alpha.3] - 2026-10-25
+
+### Fixed
+
+- A workflow whose stages send many Intercom messages to stage patterns (for example `workflow:<rootRunId>/child-*/**`) no longer saturates the workflow host. The host matched every queued pattern message against every stage on each change; it now indexes the patterns and each stage's paths once. In a 150-child fan-out test, delivered sends went from 566 of 900 to 900 of 900 and host event-loop lag p99 from about 1 s to under 200 ms ([#3931](https://github.com/bastani-inc/atomic/issues/3931))
+- Workflow journal events no longer store a run's whole list of pending stage messages each time. Pattern sends stay queued until the root run ends, so every queued message rewrote the growing list and the journal grew quadratically with the number of sends. Each event now records only what changed; older journals still read as before ([#3929](https://github.com/bastani-inc/atomic/issues/3929))
+
+## [0.9.44-alpha.2] - 2026-10-24
+
+### Fixed
+
+- A sticky Intercom broadcast, such as `workflow:<rootRunId>/**`, that reaches many workflow stages no longer makes the workflow journal grow quadratically. Recording one more delivery used to rewrite every stage's deliveries in the run's queued-message event; each event now stores only the deliveries that changed since the run's previous event. In a 160-worker run this shrinks those events from about 160 MB to about 9 MB. Journals written by earlier versions read and resume unchanged ([#3920](https://github.com/bastani-inc/atomic/issues/3920))
+
 ## [0.9.44-alpha.1] - 2026-10-24
 
 ### Changed

package/dist/builtin/workflows/package.json

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

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

@@ -2120,7 +2120,20 @@ function createWorkflowBoundarySegmentsResolver(runs) {
   };
 }
 function workflowBoundaryHops(runs, runId) {
+  return boundaryHopsFrom(new Map(runs.map((run) => [run.id, run])), runId);
+}
+function createWorkflowBoundaryHopsResolver(runs) {
   const runById = new Map(runs.map((run) => [run.id, run]));
+  const cache = new Map;
+  return (runId) => {
+    if (cache.has(runId))
+      return cache.get(runId);
+    const hops = boundaryHopsFrom(runById, runId);
+    cache.set(runId, hops);
+    return hops;
+  };
+}
+function boundaryHopsFrom(runById, runId) {
   const hops = [];
   let current = runById.get(runId);
   while (current !== undefined && current.parentRunId !== undefined) {
@@ -2146,6 +2159,35 @@ function workflowStagePathVariants(hops, stageSegments) {
 function stageMatchesPathPattern(patternSegments, hops, stageSegments) {
   return workflowStagePathVariants(hops, stageSegments).some((candidate) => matchStagePathSegments(patternSegments, candidate));
 }
+function createStagePathPatternIndex(patterns) {
+  const byFirstSegment = new Map;
+  const globFirst = [];
+  patterns.forEach((pattern, index) => {
+    const first = pattern[0];
+    if (first === undefined || first.includes("*")) {
+      globFirst.push(index);
+      return;
+    }
+    const bucket = byFirstSegment.get(first);
+    if (bucket === undefined)
+      byFirstSegment.set(first, [index]);
+    else
+      bucket.push(index);
+  });
+  return {
+    matching(hops, stageSegments) {
+      if (patterns.length === 0)
+        return [];
+      const variants = workflowStagePathVariants(hops, stageSegments);
+      const candidates = new Set(globFirst);
+      for (const variant of variants) {
+        for (const index of byFirstSegment.get(variant[0]) ?? [])
+          candidates.add(index);
+      }
+      return [...candidates].sort((left, right) => left - right).filter((index) => variants.some((variant) => matchStagePathSegments(patterns[index], variant)));
+    }
+  };
+}
 function pendingStageTarget(runId, stage) {
   return "workflowGraphTarget" in stage ? stage.workflowGraphTarget : { runId, stageId: stage.id };
 }
@@ -6808,6 +6850,17 @@ function removeProcessExitCleanup(cleanup) {
   if (processExitCleanups.delete(cleanup) && processExitCleanups.size === 0)
     process.off("exit", runProcessExitCleanups);
 }
+function writtenHandle(event) {
+  if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased)
+    return event.payload.handle;
+  if (event.type === RUN_EVENT_TYPES.checkpointRecorded || event.type === RUN_EVENT_TYPES.messageSettled || event.type === RUN_EVENT_TYPES.messageDelivered)
+    return;
+  return event.payload;
+}
+function snapshotNeedsHistory(tail) {
+  const handle = writtenHandle(tail.snapshot.event);
+  return handle !== undefined && (handle.pendingStageMessageChange !== undefined || hasPendingStageDeliveryDelta(handle.pendingStageMessages));
+}
 function* invoke(action) {
   try {
     const result = action();
@@ -6920,11 +6973,11 @@ class JournalDurableBackend {
       const payload = event.payload;
       this.projection.archivePendingStageDeliveryReceipt(entry.runId, payload.messageId, payload.delivery, payload.accounting);
     } else if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased) {
-      this.projection.applyWorkflowSnapshot(event.payload.handle);
+      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));
     } else {
-      const handle = event.payload;
       const previous = this.projection.getWorkflow(entry.runId);
+      const handle = decodeHandle(event.payload, previous?.pendingStageMessages);
       this.projection.applyWorkflowSnapshot(handle);
       if (event.type === RUN_EVENT_TYPES.runStarted || previous?.pendingPrompts !== handle.pendingPrompts)
         this.prompts.delete(entry.runId);
@@ -7044,6 +7097,20 @@ class JournalDurableBackend {
   }
   *append(runId, event, options) {
     const lease = yield* this.ownership(runId);
+    const base = this.sequences.get(runId);
+    const pinned = options?.expectSeq;
+    const encoded = base !== undefined && (pinned === undefined || pinned === base) && event.type !== RUN_EVENT_TYPES.runStarted ? encodeHandleEvent(event, this.projection.getWorkflow(runId)?.pendingStageMessages) : undefined;
+    if (encoded !== undefined) {
+      try {
+        return yield* this.write(runId, lease, encoded, { ...options, expectSeq: base });
+      } catch (error) {
+        if (!(error instanceof JournalCasConflictError) || pinned !== undefined)
+          throw error;
+      }
+    }
+    yield* this.write(runId, lease, event, options);
+  }
+  *write(runId, lease, event, options) {
     try {
       const outcome = yield* invoke(() => this.journal.append(lease, event, options));
       const nextSeq = (this.sequences.get(runId) ?? 0) + 1;
@@ -7220,11 +7287,12 @@ class JournalDurableBackend {
     for (const message of messages)
       if (message.runId !== logicalRunId)
         throw new JournalMessageScopeError(logicalRunId, message.runId);
-    yield* this.snapshot({
+    const next = {
       ...handle,
       pendingStageMessages: replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages),
       updatedAt: Math.max(Date.now(), handle.updatedAt + 1)
-    }, RUN_EVENT_TYPES.messageQueued);
+    };
+    yield* this.snapshot(next, RUN_EVENT_TYPES.messageQueued);
     return true;
   }
   async archivePendingStageMessage(runId, message) {
@@ -7318,7 +7386,7 @@ class JournalDurableBackend {
       if (summarized !== undefined && summarized.seq === version.seq && summarized.at === version.at)
         return;
       const tail = yield* invoke(() => journal.snapshotTail(runId));
-      if (tail !== undefined)
+      if (tail !== undefined && !snapshotNeedsHistory(tail))
         return this.summarize(runId, tail);
       if (summarized === undefined && version.seq === 0)
         return;
@@ -7544,7 +7612,182 @@ class JournalDurableBackend {
     }
   }
 }
-var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError;
+function identity(message) {
+  return JSON.stringify([message.runId, message.id]);
+}
+function uniqueByIdentity(messages) {
+  const result = new Map;
+  const repeated = new Set;
+  for (const message of messages) {
+    const key = identity(message);
+    if (result.has(key))
+      repeated.add(key);
+    result.set(key, message);
+  }
+  for (const key of repeated)
+    result.delete(key);
+  return result;
+}
+function isDeltaEncoded(message) {
+  return message.deliveryDelta !== undefined;
+}
+function deliveryDelta(base, deliveries) {
+  const drop = [];
+  let kept = 0;
+  base.forEach((delivery, index) => {
+    if (kept < deliveries.length && JSON.stringify(delivery) === JSON.stringify(deliveries[kept]))
+      kept++;
+    else
+      drop.push(index);
+  });
+  const add = deliveries.slice(kept);
+  return drop.length === 0 ? { add } : { drop, add };
+}
+function pendingStageFields(message) {
+  return Object.keys(message);
+}
+function copyField(target, source, key) {
+  target[key] = source[key];
+}
+function isRemovedField(message, key) {
+  return message[key] === undefined;
+}
+function json(message) {
+  let text = entryJson.get(message);
+  if (text === undefined) {
+    text = JSON.stringify(message);
+    entryJson.set(message, text);
+  }
+  return text;
+}
+function patchEntry(index, base, message) {
+  const set = {};
+  const unset = pendingStageFields(base).filter((key) => base[key] !== undefined && isRemovedField(message, key));
+  for (const key of pendingStageFields(message)) {
+    if (message[key] === undefined || key === "deliveries")
+      continue;
+    if (JSON.stringify(message[key]) !== JSON.stringify(base[key]))
+      copyField(set, message, key);
+  }
+  let delta;
+  if (message.deliveries !== undefined) {
+    if (base.deliveries === undefined)
+      set.deliveries = message.deliveries;
+    else if (JSON.stringify(base.deliveries) !== JSON.stringify(message.deliveries))
+      delta = deliveryDelta(base.deliveries, message.deliveries);
+  }
+  return {
+    patch: index,
+    ...Object.keys(set).length === 0 ? {} : { set },
+    ...unset.length === 0 ? {} : { unset },
+    ...delta === undefined ? {} : { deliveryDelta: delta }
+  };
+}
+function encodePendingStageList(previous, next) {
+  const positions = new Map;
+  const repeated = new Set;
+  previous.forEach((message, index) => {
+    const key = identity(message);
+    if (positions.has(key))
+      repeated.add(key);
+    positions.set(key, index);
+  });
+  for (const key of repeated)
+    positions.delete(key);
+  const items = [];
+  let reused = 0;
+  for (const message of next) {
+    const index = positions.get(identity(message));
+    const base = index === undefined ? undefined : previous[index];
+    if (base === undefined) {
+      items.push(message);
+      continue;
+    }
+    reused++;
+    const patched = base === message || json(base) === json(message) ? undefined : patchEntry(index, base, message);
+    if (patched === undefined || Object.keys(patched).length === 1) {
+      const last = items.at(-1);
+      if (Array.isArray(last) && last[0] + last[1] === index)
+        last[1]++;
+      else
+        items.push([index, 1]);
+      continue;
+    }
+    items.push(JSON.stringify(patched).length < json(message).length ? patched : message);
+  }
+  return reused > 0 ? items : undefined;
+}
+function decodePendingStageList(previous, items) {
+  const base = (index) => {
+    if (!Number.isInteger(index) || index < 0 || index >= previous.length)
+      throw new Error(`atomic-workflows: journal pending-stage change names missing entry ${index}`);
+    return previous[index];
+  };
+  const result = [];
+  for (const item of items) {
+    if (Array.isArray(item)) {
+      const [start, count] = item;
+      for (let index = start;index < start + count; index++)
+        result.push(base(index));
+    } else if (typeof item.patch === "number") {
+      const { patch, set, unset, deliveryDelta: delta } = item;
+      const entry = { ...base(patch), ...set };
+      for (const key of unset ?? [])
+        delete entry[key];
+      if (delta !== undefined) {
+        const dropped = new Set(delta.drop ?? []);
+        const deliveries = base(patch).deliveries ?? [];
+        entry.deliveries = [...deliveries.filter((_, index) => !dropped.has(index)), ...delta.add];
+      }
+      result.push(entry);
+    } else
+      result.push(item);
+  }
+  return result;
+}
+function encodeHandleEvent(event, previous) {
+  const handle = writtenHandle(event);
+  if (handle?.pendingStageMessages === undefined || previous === undefined)
+    return;
+  const change = encodePendingStageList(previous, handle.pendingStageMessages);
+  if (change === undefined)
+    return;
+  const { pendingStageMessages: _full, ...rest } = handle;
+  const encoded = { ...rest, pendingStageMessageChange: change };
+  if (event.type === RUN_EVENT_TYPES.promptAsked || event.type === RUN_EVENT_TYPES.promptReleased)
+    return { ...event, payload: { ...event.payload, handle: encoded } };
+  return { ...event, payload: encoded };
+}
+function decodeHandle(handle, previous) {
+  const { pendingStageMessageChange: change, ...rest } = handle;
+  if (change !== undefined)
+    return { ...rest, pendingStageMessages: decodePendingStageList(previous ?? [], change) };
+  if (!hasPendingStageDeliveryDelta(handle.pendingStageMessages))
+    return handle;
+  return {
+    ...handle,
+    pendingStageMessages: decodePendingStageDeliveries(previous ?? [], handle.pendingStageMessages ?? [])
+  };
+}
+function decodePendingStageDeliveries(previous, messages) {
+  if (!messages.some(isDeltaEncoded))
+    return messages;
+  const bases = uniqueByIdentity(previous);
+  return messages.map((message) => {
+    if (!isDeltaEncoded(message))
+      return message;
+    const base = bases.get(identity(message))?.deliveries;
+    if (base === undefined)
+      throw new Error(`atomic-workflows: journal delivery change for ${identity(message)} has no base entry`);
+    const { deliveryDelta, ...rest } = message;
+    const dropped = new Set(deliveryDelta.drop ?? []);
+    return { ...rest, deliveries: [...base.filter((_, index) => !dropped.has(index)), ...deliveryDelta.add] };
+  });
+}
+function hasPendingStageDeliveryDelta(messages) {
+  return messages?.some(isDeltaEncoded) === true;
+}
+var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError, entryJson;
 var init_journal_backend = __esm(() => {
   init_workflow_instance_ownership_error();
   init_backend();
@@ -7602,6 +7845,7 @@ var init_journal_backend = __esm(() => {
       this.name = "JournalMessageScopeError";
     }
   };
+  entryJson = new WeakMap;
 });
 
 // dist/builtin/workflows/src/durable/journal/legacy-journal-tables.ts
@@ -60727,24 +60971,63 @@ 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) {
-    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunIdForRun(runs, run.id) !== rootRunId)
+    const durableRootRunId = reciprocalWorkflowRootRunId(runById, run.id);
+    if (run.id !== rootRunId && run.rootRunId !== rootRunId && durableRootRunId !== rootRunId)
       continue;
-    const resolved = durableRootRunIdForRun(runs, run.id) === rootRunId;
-    const hops = workflowBoundaryHops(runs, run.id);
+    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;
-      for (const entry of entries) {
+      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 parsed = parseWorkflowStageTarget(target);
-        if (!parsed || parsed.rootRunId !== rootRunId)
-          continue;
-        if (resolved && hops && !stageMatchesPathPattern(parsed.segments, hops, [stage.id, stage.name]))
-          continue;
-        const receipts = (entry.deliveries ?? []).filter((delivery) => delivery.runId === run.id && delivery.stageId === stage.id);
+        const receipts = entryReceipts(index, run.id, stage.id);
         const delivered = backend?.hasCachedPendingStageDeliveryReceipt?.(rootRunId, entry.id, {
           runId: run.id,
           stageId: stage.id,
@@ -61062,20 +61345,27 @@ 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 parsed = parseWorkflowStageTarget(entry.targetPath ?? entry.stageKey);
-    return parsed?.rootRunId === rootRunId ? parsed.segments : undefined;
+    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("*")) && materializedStageMatches(runs, rootRunId, rowSegments)) {
+    if (!rowSegments.some((segment) => segment.includes("*")) && liveStageMatches(rowSegments)) {
       continue;
     }
     rows.push({
@@ -61096,28 +61386,43 @@ function possibleStageRows(runs, rootRunId, rootRun, backend) {
     }).length
   });
   const statuses = stickyStageDeliveryStatuses(runs, rootRunId, backend);
-  for (const target of new Set(statuses.map((status) => status.target))) {
-    if (rows.some((row) => row.target === target))
+  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;
-    rows.push({
-      target,
-      queuedCount: stickyQueued.filter((entry) => (entry.targetPath ?? entry.stageKey) === target).length,
-      deliveryOnly: true
-    });
+    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 = statuses.filter((status) => status.target === row.target);
-    if (deliveryStates.length > 0)
+    const deliveryStates = statusesByTarget.get(row.target);
+    if (deliveryStates !== undefined)
       rows[index] = { ...row, deliveryStates };
   }
   return rows;
 }
-function materializedStageMatches(runs, rootRunId, entrySegments) {
-  for (const run of runs) {
-    if (durableRootRunIdForRun(runs, run.id) !== rootRunId)
-      continue;
-    const hops = workflowBoundaryHops(runs, run.id);
+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) {
@@ -61392,10 +61697,12 @@ async function recordConfirmedStickyDeliveries(activeStore, event) {
 }
 function matchingLiveStages(runs, rootRunId, patternSegments) {
   const matches = [];
+  const runById = new Map(runs.map((run) => [run.id, run]));
+  const hopsFor = createWorkflowBoundaryHopsResolver(runs);
   for (const run of runs) {
-    if (durableRootRunIdForRun(runs, run.id) !== rootRunId)
+    if (reciprocalWorkflowRootRunId(runById, run.id) !== rootRunId)
       continue;
-    const hops = workflowBoundaryHops(runs, run.id);
+    const hops = hopsFor(run.id);
     if (hops === undefined)
       continue;
     for (const stage of run.stages) {
@@ -61531,11 +61838,26 @@ function writeMessage(socket, msg, callback) {
 }
 function createMessageReader(onMessage, onError) {
   let buffer = Buffer.alloc(0);
+  let pending = [];
+  let pendingLength = 0;
+  let awaitedLength = 0;
   return (data) => {
-    buffer = Buffer.concat([buffer, data]);
+    if (pendingLength + data.length < awaitedLength) {
+      pending.push(data);
+      pendingLength += data.length;
+      return;
+    }
+    buffer = pending.length === 0 ? Buffer.concat([buffer, data]) : Buffer.concat([...pending, data]);
+    pending = [];
+    pendingLength = 0;
+    awaitedLength = 0;
     while (buffer.length >= 4) {
       const length = buffer.readUInt32BE(0);
       if (buffer.length < 4 + length) {
+        pending = [buffer];
+        pendingLength = buffer.length;
+        awaitedLength = 4 + length;
+        buffer = Buffer.alloc(0);
         break;
       }
       const payload = buffer.subarray(4, 4 + length);
@@ -61647,7 +61969,8 @@ function buildSendSignature(to, options) {
     attachments: canonicalizeAttachmentsForSendSignature(options.attachments) ?? [],
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
-    replyError: options.replyError ?? null
+    replyError: options.replyError ?? null,
+    ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery }
   });
 }
 
@@ -61833,6 +62156,8 @@ function isMessage(value2) {
     return false;
   if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
     return false;
+  if (message.delivery !== undefined && message.delivery !== "steer" && message.delivery !== "followUp" && message.delivery !== "interrupt")
+    return false;
   if (message.replyError !== undefined && typeof message.replyError !== "string")
     return false;
   if (message.source !== undefined && !isMessageSource(message.source))
@@ -63042,6 +63367,7 @@ var init_client = __esm(() => {
         timestamp: Date.now(),
         replyTo: options.replyTo,
         expectsReply: options.expectsReply,
+        ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery },
         replyError: options.replyError,
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }