@bastani/atomic 0.9.18-alpha.2 → 0.9.18-alpha.4

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

@@ -36322,7 +36322,6 @@ function compactStage(stage) {
     inputRequest,
     notices,
     mcpScope: _mcpScope,
-    pendingStageDeliveryAvailable: _pendingStageDeliveryAvailable,
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
@@ -38144,6 +38143,31 @@ function effectiveWidth(width) {
   return chatWidth(width);
 }
 
+// dist/builtin/workflows/src/shared/pending-stage-status.ts
+function pendingStageTarget(runId, stage) {
+  return "workflowGraphTarget" in stage ? stage.workflowGraphTarget : { runId, stageId: stage.id };
+}
+function pendingWorkflowStageStatus(run, stage, resolveOwningRunStatus) {
+  if (stage.status !== "pending")
+    return;
+  const identity = pendingStageTarget(run.id, stage);
+  const owningRunStatus = identity.runId === run.id ? run.status : resolveOwningRunStatus?.(identity.runId);
+  const pendingStageDeliveryAvailable = owningRunStatus !== undefined && owningRunStatus !== "crashed" && !isTerminalRunStatus(owningRunStatus) && stage.pendingStageDeliveryAvailable === true;
+  return {
+    stageId: identity.stageId,
+    name: stage.name,
+    lifecycle: "pending",
+    pendingStageDeliveryAvailable,
+    ...pendingStageDeliveryAvailable ? { target: `${identity.runId}:${identity.stageId}` } : {}
+  };
+}
+function pendingWorkflowStageStatuses(run, resolveOwningRunStatus) {
+  return run.stages.flatMap((stage) => {
+    const pending = pendingWorkflowStageStatus(run, stage, resolveOwningRunStatus);
+    return pending === undefined ? [] : [pending];
+  });
+}
+
 // dist/builtin/workflows/src/tui/status-helpers.ts
 function statusColor(status, theme) {
   switch (status) {
@@ -38222,10 +38246,10 @@ function renderRunDetail(detail, opts = {}) {
   const now = opts.now ?? Date.now();
   const width = Math.max(32, opts.width ?? 80);
   if (opts.theme === undefined)
-    return renderPlain(detail, now, width);
-  return renderThemed(detail, now, opts.theme, width);
+    return renderPlain(detail, now, width, opts.owningRunStatus);
+  return renderThemed(detail, now, opts.theme, width, opts.owningRunStatus);
 }
-function renderPlain(detail, now, width) {
+function renderPlain(detail, now, width, resolveOwningRunStatus) {
   const out = [];
   const stateBadge = stateLabel(detail);
   out.push(...renderIdentifierRows2(detail.runId, width - 2));
@@ -38244,7 +38268,7 @@ function renderPlain(detail, now, width) {
       out.push("  (no stages recorded yet) ");
     else
       for (const stage of detail.stages)
-        out.push(...renderStageRowsPlain(stage, now, width - 4));
+        out.push(...renderStageRowsPlain(detail.runId, detail.status, stage, now, width - 4, resolveOwningRunStatus));
     out.push("");
   }
   if (tools.length > 0) {
@@ -38268,7 +38292,7 @@ function renderPlain(detail, now, width) {
     width
   });
 }
-function renderThemed(detail, now, theme, width) {
+function renderThemed(detail, now, theme, width, resolveOwningRunStatus) {
   const out = [];
   const muted = hexToAnsi(theme.textMuted);
   const dim = hexToAnsi(theme.dim);
@@ -38290,7 +38314,7 @@ function renderThemed(detail, now, theme, width) {
       out.push(`  ${dim}(no stages recorded yet)${RESET} `);
     else
       for (const stage of detail.stages)
-        out.push(...renderStageRowsThemed(stage, now, theme, width - 4));
+        out.push(...renderStageRowsThemed(detail.runId, detail.status, stage, now, theme, width - 4, resolveOwningRunStatus));
     out.push("");
   }
   if (tools.length > 0) {
@@ -38383,16 +38407,37 @@ function stageLineThemed(stage, now, theme, width) {
   const durSeg = dur ? `${dim}${dur}${RESET}` : "";
   return truncateToWidth(`${iconFg}${icon}${RESET} ${text}${namePad}${RESET}  ${stateFg}${statePad}${RESET}${activitySeg}${durSeg}`, width, "…");
 }
-function renderStageRowsPlain(stage, now, width) {
-  const rows = [` ${stageLinePlain(stage, now, Math.max(1, width - 2))} `];
+function pendingStageRows(runId, runStatus, stage, width, theme, resolveOwningRunStatus) {
+  const pending = pendingWorkflowStageStatus({ id: runId, status: runStatus }, stage, resolveOwningRunStatus);
+  if (pending === undefined)
+    return [];
+  const value2 = pending.target ?? `${pending.stageId} · delivery unavailable`;
+  const label = pending.target === undefined ? "pending id" : "pending target";
+  const firstPrefix = `   ${pad(label, 16)}`;
+  const continuationPrefix = " ".repeat(19);
+  const wrapped = wrapIdentifierLines(value2, Math.max(1, width - 1), firstPrefix, continuationPrefix);
+  if (theme === undefined)
+    return wrapped.map(({ prefix, chunk }) => `${prefix}${chunk} `);
+  const muted = hexToAnsi(theme.textMuted);
+  const text = hexToAnsi(theme.text);
+  return wrapped.map(({ prefix, chunk }, index) => index === 0 ? `   ${muted}${pad(label, 16)}${RESET}${text}${chunk}${RESET} ` : `${prefix}${text}${chunk}${RESET} `);
+}
+function renderStageRowsPlain(runId, runStatus, stage, now, width, resolveOwningRunStatus) {
+  const rows = [
+    ` ${stageLinePlain(stage, now, Math.max(1, width - 2))} `,
+    ...pendingStageRows(runId, runStatus, stage, width, undefined, resolveOwningRunStatus)
+  ];
   if (stage.error) {
     rows.push(`   error  ${truncateToWidth(stage.error.split(`
 `)[0] ?? "", Math.max(1, width - 10), "…")} `);
   }
   return rows;
 }
-function renderStageRowsThemed(stage, now, theme, width) {
-  const rows = [` ${stageLineThemed(stage, now, theme, Math.max(1, width - 2))} `];
+function renderStageRowsThemed(runId, runStatus, stage, now, theme, width, resolveOwningRunStatus) {
+  const rows = [
+    ` ${stageLineThemed(stage, now, theme, Math.max(1, width - 2))} `,
+    ...pendingStageRows(runId, runStatus, stage, width, theme, resolveOwningRunStatus)
+  ];
   if (stage.error) {
     const errFg = hexToAnsi(theme.error);
     rows.push(`   ${hexToAnsi(theme.textMuted)}error${RESET}  ${errFg}${truncateToWidth(stage.error.split(`
@@ -38708,7 +38753,7 @@ function renderStatusList(runs, opts = {}) {
     for (let i = 0;i < sorted.length; i++) {
       if (i > 0)
         body.push("");
-      body.push(...renderRunEntry(sorted[i], now, cardWidth, opts.theme, opts.allRuns ?? runs, opts.indicatorStatuses));
+      body.push(...renderRunEntry(sorted[i], now, cardWidth, opts.theme, opts.allRuns ?? runs, opts.indicatorStatuses, opts.owningRunStatus));
     }
   }
   if (opts.showDetailHint !== false && sorted.length > 0) {
@@ -38723,7 +38768,7 @@ function renderStatusList(runs, opts = {}) {
     width
   });
 }
-function renderRunEntry(run, now, width, theme, allRuns, indicatorStatuses) {
+function renderRunEntry(run, now, width, theme, allRuns, indicatorStatuses, resolveOwningRunStatus) {
   const bodyWidth = effectiveWidth2(width);
   const interior = Math.max(8, bodyWidth - 4);
   const indicatorStatus = indicatorStatuses?.[run.id] ?? runIndicatorStatus(run, allRuns);
@@ -38762,7 +38807,56 @@ function renderRunEntry(run, now, width, theme, allRuns, indicatorStatuses) {
   const modeSeg = theme ? `${muted}${mode}${reset}` : mode;
   const metaSeg = theme ? `${dim}${meta}${reset}` : meta;
   const metaLine = `   ${modeSeg}    ${strip}${" ".repeat(gap)}${metaSeg} `;
-  return [...identityRows, identity, metaLine];
+  return [...identityRows, identity, metaLine, ...pendingStageLines(run, interior, theme, resolveOwningRunStatus)];
+}
+var MAX_PENDING_STAGE_ROWS = 3;
+function pendingStageIdentityLines(stage, width, suffix = "") {
+  const full = `   pending: ${stage.name} (${stage.stageId})${suffix}`;
+  if (visibleWidth(full) <= width)
+    return [full];
+  const labelledPrefix = "   pending: ";
+  const prefix = visibleWidth(labelledPrefix) < width ? labelledPrefix : width > 3 ? "   " : "";
+  const continuation = width > 3 ? "   " : "";
+  const rows = wrapIdentifierLines(stage.stageId, width, prefix, continuation).map(({ prefix: rowPrefix, chunk }) => `${rowPrefix}${chunk}`);
+  if (suffix.length === 0)
+    return rows;
+  const last = rows.at(-1);
+  if (visibleWidth(`${last}${suffix}`) <= width)
+    rows[rows.length - 1] = `${last}${suffix}`;
+  else
+    rows.push(`${continuation}${suffix.trim()}`);
+  return rows;
+}
+function pendingStageLines(run, width, theme, resolveOwningRunStatus) {
+  const stages = pendingWorkflowStageStatuses(run, resolveOwningRunStatus);
+  const visible = stages.slice(0, MAX_PENDING_STAGE_ROWS).flatMap((stage) => {
+    const prefix = `   pending: ${stage.name} (${stage.stageId})`;
+    if (stage.target === undefined) {
+      const unavailable = `${prefix} · delivery unavailable`;
+      if (visibleWidth(unavailable) <= width)
+        return [pendingStageLine(unavailable, width, theme)];
+      return [
+        ...pendingStageIdentityLines(stage, width).map((line) => pendingStageLine(line, width, theme)),
+        pendingStageLine("   delivery unavailable", width, theme)
+      ];
+    }
+    const inline = `${prefix} → ${stage.target}`;
+    if (visibleWidth(inline) <= width)
+      return [pendingStageLine(inline, width, theme)];
+    const labelRows = pendingStageIdentityLines(stage, width, " →").map((line) => pendingStageLine(line, width, theme));
+    const targetRows = wrapIdentifierLines(stage.target, width, "   ", "   ").map(({ prefix: prefix2, chunk }) => pendingStageLine(`${prefix2}${chunk}`, width, theme));
+    return [...labelRows, ...targetRows];
+  });
+  if (stages.length > MAX_PENDING_STAGE_ROWS) {
+    const omitted = stages.length - MAX_PENDING_STAGE_ROWS;
+    const line = truncateToWidth(`   … ${omitted} more pending stage${omitted === 1 ? "" : "s"}`, width, ELLIPSIS);
+    visible.push(theme === undefined ? line : `${hexToAnsi(theme.dim)}${line}${RESET}`);
+  }
+  return visible;
+}
+function pendingStageLine(line, width, theme) {
+  const visible = truncateToWidth(line, width, ELLIPSIS);
+  return theme === undefined ? visible : `${hexToAnsi(theme.textMuted)}${visible}${RESET}`;
 }
 function runAccent(run, theme, indicatorStatus) {
   if (!theme)
@@ -39188,7 +39282,12 @@ function renderChatSurfacePlainText(payload, options = {}) {
 `);
     }
     case "detail": {
-      const rendered = renderRunDetail(payload.detail, { width, now, ...themed });
+      const rendered = renderRunDetail(payload.detail, {
+        width,
+        now,
+        ...themed,
+        owningRunStatus: (runId) => payload.owningRunStatuses?.[runId]
+      });
       const lines = [
         rendered,
         `run id: ${payload.detail.runId}`,
@@ -39269,7 +39368,12 @@ function renderPayload(payload, theme, width, now) {
     case "list":
       return renderWorkflowList(payload.entries, { theme, width });
     case "detail":
-      return renderRunDetail(payload.detail, { theme, width, now });
+      return renderRunDetail(payload.detail, {
+        theme,
+        width,
+        now,
+        owningRunStatus: (runId) => payload.owningRunStatuses?.[runId]
+      });
   }
 }
 
@@ -48234,7 +48338,30 @@ function activeToolLabel(run) {
   const details = nodes.map((node) => `${node.name} · ${node.status}`).join(", ");
   return nodes.length === 1 ? details : `${nodes.length} tools · ${details}`;
 }
-function metaLine(run, now) {
+var MAX_PENDING_WIDGET_ITEMS = 2;
+function pendingStageLabel(run, width = Number.POSITIVE_INFINITY) {
+  const stages = pendingWorkflowStageStatuses(run);
+  if (stages.length === 0)
+    return;
+  const maxItems = Math.min(MAX_PENDING_WIDGET_ITEMS, stages.length);
+  for (let count = maxItems;count >= 1; count--) {
+    let combinations = [[]];
+    for (const stage of stages.slice(0, count)) {
+      const exact = stage.target === undefined ? `${stage.name} (${stage.stageId}) · unavailable` : `${stage.name} (${stage.stageId}) → ${stage.target}`;
+      const variants = stage.target === undefined ? [exact] : [exact, `${stage.name} · stage ${stage.stageId}`];
+      combinations = combinations.flatMap((labels) => variants.map((variant) => [...labels, variant]));
+    }
+    for (const labels of combinations) {
+      const omitted = stages.length - count;
+      const visible = omitted > 0 ? [...labels, `… ${omitted} more`] : labels;
+      const label = `pending: ${visible.join(", ")}`;
+      if (visibleWidth(label) <= width)
+        return label;
+    }
+  }
+  return;
+}
+function metaLine(run, now, width = Number.POSITIVE_INFINITY) {
   if (run.endedAt !== undefined) {
     return elapsedLabel(run, now);
   }
@@ -48242,17 +48369,21 @@ function metaLine(run, now) {
     return "quit · resumable via /workflow resume";
   if (effectiveRunStatus(run) === "blocked")
     return "blocked · resumable via /workflow resume";
-  const parts = [modeLabel(run)];
+  const prefix = [modeLabel(run)];
   const prog = progressLabel(run);
   if (prog)
-    parts.push(prog);
+    prefix.push(prog);
+  const suffix = [];
   const tools = activeToolLabel(run);
   if (tools)
-    parts.push(tools);
+    suffix.push(tools);
   const elapsed = elapsedLabel(run, now);
   if (elapsed)
-    parts.push(elapsed);
-  return parts.join(" · ");
+    suffix.push(elapsed);
+  const otherParts = [...prefix, ...suffix];
+  const pendingWidth = Math.max(0, width - otherParts.reduce((total, part) => total + visibleWidth(part), 0) - otherParts.length * 3);
+  const pending = pendingStageLabel(run, pendingWidth);
+  return [...prefix, ...pending === undefined ? [] : [pending], ...suffix].join(" · ");
 }
 function countBadges(counts, theme) {
   const badges = [];
@@ -48290,8 +48421,12 @@ function formatTitleBadges(badges, theme, themed) {
   const fallbackFg = hexToAnsi(theme.border);
   return badges.map((b) => `${b.fg ? hexToAnsi(b.fg) : fallbackFg}${b.text}${RESET}${fallbackFg}`).join("  ");
 }
-function themedRunLines(run, now, theme, allRuns) {
-  const meta = metaLine(run, now);
+function runMetaWidth(run, width) {
+  const inner = Math.max(2, Math.max(32, width) - 2);
+  return Math.max(0, inner - visibleWidth(`     ${run.name} · `));
+}
+function themedRunLines(run, now, theme, allRuns, width) {
+  const meta = metaLine(run, now, runMetaWidth(run, width));
   const metaColor = effectiveRunStatus(run) === "running" ? theme.textMuted : theme.dim;
   return renderRunIdentityRows({
     runId: run.id,
@@ -48303,11 +48438,11 @@ function themedRunLines(run, now, theme, allRuns) {
     theme
   });
 }
-function plainRunLines(run, now, allRuns) {
+function plainRunLines(run, now, allRuns, width) {
   return renderRunIdentityRows({
     runId: run.id,
     name: run.name,
-    meta: metaLine(run, now),
+    meta: metaLine(run, now, runMetaWidth(run, width)),
     glyph: statusGlyph2(run, allRuns)
   });
 }
@@ -48362,7 +48497,7 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
   const body = [];
   for (let i = 0;i < display.length; i++) {
     const run = display[i];
-    const runLines = themed ? themedRunLines(run, now, graphTheme, snap.runs) : plainRunLines(run, now, snap.runs);
+    const runLines = themed ? themedRunLines(run, now, graphTheme, snap.runs, width) : plainRunLines(run, now, snap.runs, width);
     body.push(...runLines);
     if (i < display.length - 1)
       body.push("");
@@ -49341,6 +49476,7 @@ function encodeCheckpoint(checkpoint) {
         version: s.topology.version,
         stageId: s.topology.stageId,
         parentIds: [...s.topology.parentIds],
+        ...s.topology.intercomGroup !== undefined ? { intercomGroup: s.topology.intercomGroup } : {},
         ...s.topology.sourceOrder !== undefined ? { sourceOrder: s.topology.sourceOrder } : {},
         ...s.topology.occurrenceKey !== undefined ? { occurrenceKey: s.topology.occurrenceKey } : {},
         ...s.topology.status !== undefined ? { status: s.topology.status } : {},
@@ -49473,7 +49609,7 @@ function stageTopology(value2) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
     return;
   const record = value2;
-  if (record.version !== DURABLE_STAGE_TOPOLOGY_VERSION || typeof record.stageId !== "string" || !isStringArray(record.parentIds) || !isOptionalSourceOrder(record.sourceOrder) || record.occurrenceKey !== undefined && typeof record.occurrenceKey !== "string" || record.status !== undefined && !isStageLifecycleStatus(record.status))
+  if (record.version !== DURABLE_STAGE_TOPOLOGY_VERSION || typeof record.stageId !== "string" || !isStringArray(record.parentIds) || !isOptionalSourceOrder(record.sourceOrder) || record.intercomGroup !== undefined && typeof record.intercomGroup !== "string" || record.occurrenceKey !== undefined && typeof record.occurrenceKey !== "string" || record.status !== undefined && !isStageLifecycleStatus(record.status))
     return;
   const run = stageRunTopology(record.run);
   if (record.run !== undefined && run === undefined)
@@ -49485,6 +49621,7 @@ function stageTopology(value2) {
     version: DURABLE_STAGE_TOPOLOGY_VERSION,
     stageId: record.stageId,
     parentIds: record.parentIds,
+    ...typeof record.intercomGroup === "string" ? { intercomGroup: record.intercomGroup } : {},
     ...typeof record.sourceOrder === "number" ? { sourceOrder: record.sourceOrder } : {},
     ...typeof record.occurrenceKey === "string" ? { occurrenceKey: record.occurrenceKey } : {},
     ...isStageLifecycleStatus(record.status) ? { status: record.status } : {},
@@ -54052,6 +54189,7 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
       version: DURABLE_STAGE_TOPOLOGY_VERSION,
       stageId: stage.id,
       parentIds: [...stage.parentIds],
+      ...stage.intercomGroup !== undefined ? { intercomGroup: stage.intercomGroup } : {},
       ...stage.executionOrder !== undefined ? { order: stage.executionOrder } : {},
       ...sourceOrder !== undefined && sourceOrder >= 0 ? { sourceOrder } : {},
       ...stage.promptFootprint !== undefined ? { occurrenceKey: stage.id } : {},
@@ -54784,11 +54922,13 @@ function createDurableStagePrimitive(input) {
     const isMidSessionResume = session?.sessionFile !== undefined;
     const topology = activeStageTopology(input.backend, input.workflowId, replayKey);
     const durableStageId = topology?.stageId ?? pendingStageIdForReplay(input.backend, input.workflowId, replayKey, name);
+    const durableIntercomGroup = topology?.intercomGroup ?? input.durableIntercomGroup?.(replayKey, durableStageId);
     const liveOptions = {
       ...options ?? {},
       durableReplayKey: replayKey,
       ...durableStageId !== undefined ? { durableStageId } : {},
       ...topology !== undefined ? { durableParentIds: [...topology.parentIds] } : {},
+      ...durableIntercomGroup !== undefined ? { durableIntercomGroup } : {},
       ...isMidSessionResume ? {
         resumeFromSessionFile: session.sessionFile,
         durableAccumulatedDurationMs: session.durationMs ?? 0
@@ -54817,6 +54957,7 @@ function createDurableTaskPrimitive(input) {
     }
     const session = input.backend.getStageSession(input.workflowId, replayKey);
     const topology = activeStageTopology(input.backend, input.workflowId, replayKey);
+    const durableIntercomGroup = topology?.intercomGroup ?? input.durableIntercomGroup?.(replayKey, topology?.stageId);
     const taskOptions = {
       ...options,
       durableReplayKey: replayKey,
@@ -54824,6 +54965,7 @@ function createDurableTaskPrimitive(input) {
         durableStageId: topology.stageId,
         durableParentIds: [...topology.parentIds]
       } : {},
+      ...durableIntercomGroup !== undefined ? { durableIntercomGroup } : {},
       ...session?.sessionFile !== undefined ? {
         resumeFromSessionFile: session.sessionFile,
         durableAccumulatedDurationMs: session.durationMs ?? 0
@@ -55486,6 +55628,7 @@ function appendStageStart(api, payload) {
     name: payload.name,
     parentIds: [...payload.parentIds],
     ...payload.model !== undefined ? { model: payload.model } : {},
+    ...payload.intercomGroup !== undefined ? { intercomGroup: payload.intercomGroup } : {},
     ...payload.pendingStageDeliveryAvailable !== undefined ? { pendingStageDeliveryAvailable: payload.pendingStageDeliveryAvailable } : {},
     ...payload.replayKey !== undefined ? { replayKey: payload.replayKey } : {},
     ...payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {},
@@ -56030,6 +56173,7 @@ function installCompactionHook(api, store2) {
           stageId: stage.id,
           name: stage.name,
           parentIds: [...stage.parentIds],
+          intercomGroup: stage.intercomGroup,
           pendingStageDeliveryAvailable: stage.pendingStageDeliveryAvailable,
           ts: stage.startedAt ?? now
         });
@@ -57157,7 +57301,9 @@ function fallbackRunDetailFromResult(workflowName, inputs, result) {
 function emitTerminalRunDetailSurface(pi, workflowName, inputs, result) {
   const inspected = inspectRun(result.runId);
   const detail = inspected.ok ? inspected.detail : fallbackRunDetailFromResult(workflowName, inputs, result);
-  emitChatSurface(pi, { kind: "detail", detail }, { content: renderRunDetail(detail, { width: 100 }) });
+  const owningRunStatuses = Object.fromEntries(store.graphSnapshot().runs.map((run) => [run.id, run.status]));
+  const owningRunStatus = (runId) => owningRunStatuses[runId];
+  emitChatSurface(pi, { kind: "detail", detail, owningRunStatuses }, { content: renderRunDetail(detail, { width: 100, owningRunStatus }) });
 }
 function formatWorkflowResourceLoadWarning(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -69037,18 +69183,28 @@ function resolveStageGroup(stageOptions, workflowGroup) {
   const group = stageOptions.group;
   if (group === undefined)
     return workflowGroup;
-  if (group === true)
-    return randomUUID5();
-  const trimmed = group.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
+  const authored = group === true ? randomUUID5() : group.trim();
+  if (authored.length === 0)
+    return;
+  if (workflowGroup === undefined || authored === DEFAULT_INTERCOM_GROUP)
+    return authored;
+  const owner2 = normalizeGroup(workflowGroup);
+  if (authored === owner2 || authored.startsWith(`${owner2}/`))
+    return authored;
+  return `${owner2}/${authored}`;
+}
+function workflowInvocationOwnsGroup(workflowGroup, candidate) {
+  if (workflowGroup === undefined || candidate === undefined)
+    return false;
+  const owner2 = normalizeGroup(workflowGroup);
+  const group = normalizeGroup(candidate);
+  return group === owner2 || group.startsWith(`${owner2}/`);
 }
 function stageHasIntercomAccess(_stageOptions) {
   return true;
 }
 function stageCanUseWorkflowPendingStageRoute(stageOptions, workflowGroup) {
-  if (!stageHasIntercomAccess(stageOptions) || stageOptions?.group === true)
-    return false;
-  return normalizeGroup(resolveStageGroup(stageOptions, workflowGroup)) === normalizeGroup(workflowGroup);
+  return stageHasIntercomAccess(stageOptions) && workflowInvocationOwnsGroup(workflowGroup, resolveStageGroup(stageOptions, workflowGroup));
 }
 
 // dist/builtin/workflows/src/shared/budget-meter.ts
@@ -73200,6 +73356,7 @@ function stripWorkflowOnlyOptions(options, defaultSessionDir, meta2, pendingStag
     durableReplayKey: _durableReplayKey,
     durableAccumulatedDurationMs: _durableAccumulatedDurationMs,
     durableStageId: _durableStageId,
+    durableIntercomGroup: _durableIntercomGroup,
     durableParentIds: _durableParentIds,
     sessionDir,
     gitWorktreeDir: _gitWorktreeDir,
@@ -75322,15 +75479,18 @@ function createWorkflowStageFactory(input) {
     const replaySource = replayDecision.kind === "replay" ? replayDecision.source : undefined;
     const executeReplaySource = replayDecision.kind === "execute" ? replayDecision.source : undefined;
     const shouldReplay = replaySource !== undefined;
-    const stageOptionsForContext = executeReplaySource?.sessionFile === undefined ? options : {
+    const replayStageOptions = executeReplaySource?.sessionFile === undefined ? options : {
       ...options ?? {},
       context: options?.context ?? "fork",
       forkFromSessionFile: options?.forkFromSessionFile ?? executeReplaySource.sessionFile
     };
+    const intercomGroup = options?.durableIntercomGroup ?? resolveStageGroup(replayStageOptions, input.workflowIntercomGroup);
+    const stageOptionsForContext = replayStageOptions?.group === undefined || intercomGroup === undefined ? replayStageOptions : { ...replayStageOptions, group: intercomGroup };
     const pendingStageDeliveryAvailable = stageCanUseWorkflowPendingStageRoute(stageOptionsForContext, input.workflowIntercomGroup);
     const stageSnapshot = {
       id: stageId,
       name,
+      ...intercomGroup === undefined ? {} : { intercomGroup },
       replayKey,
       status: shouldReplay ? "completed" : "pending",
       parentIds: Object.freeze(parentIds),
@@ -75529,6 +75689,7 @@ function createWorkflowStageFactory(input) {
         name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
+        ...intercomGroup === undefined ? {} : { intercomGroup },
         pendingStageDeliveryAvailable,
         ts: stageSnapshot.startedAt ?? Date.now()
       });
@@ -76210,11 +76371,16 @@ async function run(def, inputs, opts = {}) {
     completedStageReplayKeys,
     sourceToReplayedNodeIds: sourceToContinuationNodeIds
   });
+  const durableIntercomGroup = (replayKey, stageId) => {
+    const stages = activeStore.runs().find((candidate) => candidate.id === runId)?.stages ?? [];
+    return stages.find((stage) => stageId !== undefined && stage.id === stageId || stage.replayKey === replayKey)?.intercomGroup;
+  };
   let observedTaskTailQuit;
   const durableTask = createDurableTaskPrimitive({
     workflowId: runId,
     backend: durableBackend,
     nextReplayKey: (stageName3) => stageReplayKeyGenerator(stageName3),
+    durableIntercomGroup,
     task: taskRunners.task,
     recordCachedTask: cachedStage.record,
     signal: ownController.signal,
@@ -76263,6 +76429,7 @@ async function run(def, inputs, opts = {}) {
       workflowId: runId,
       backend: durableBackend,
       nextReplayKey: (stageName3) => stageReplayKeyGenerator(stageName3),
+      durableIntercomGroup,
       recordCachedStage: cachedStage.record,
       stage: (name, options, replayKey) => {
         const stage = runtime.stage(name, options);
@@ -79172,7 +79339,15 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
       pi.events?.emit?.(PENDING_STAGE_ROUTE_EVENT, {
         runId: run2.id,
         group: workflowInvocationIntercomGroup(rootRunId),
-        capability: workflowPendingStageRouteCapability(activeStore, run2.id)
+        capability: workflowPendingStageRouteCapability(activeStore, run2.id),
+        stages: run2.stages.filter((stage) => stage.pendingStageDeliveryAvailable === true && (stage.status === "pending" || stage.status === "running" || stage.status === "awaiting_input" || stage.status === "paused" || stage.status === "blocked")).map((stage) => ({
+          stageId: stage.id,
+          stageName: stage.name,
+          target: `${run2.id}:${stage.id}`,
+          lifecycle: stage.sessionId === undefined && stage.sessionFile === undefined ? "pending" : "running",
+          routeEligible: true,
+          group: stage.intercomGroup ?? workflowInvocationIntercomGroup(rootRunId)
+        }))
       });
     }
     sweepPromise = sweepPromise.then(() => settleUndeliverablePendingStageMessages(activeStore, notifyUndeliverable)).then(() => {
@@ -79268,7 +79443,8 @@ async function queueAndPersist(activeStore, event, runGroup, pendingStageDeliver
   const backend = durableBackendForRun(rootBackend, activeStore.runs(), event.runId);
   if (backend === undefined)
     return { outcome: "refused", reason: "Session not found" };
-  const result = await activeStore.queueStageMessage(request, event.from.group, runGroup, backend);
+  const senderGroup = event.from.groups?.includes(runGroup) === true ? runGroup : event.from.group;
+  const result = await activeStore.queueStageMessage(request, senderGroup, runGroup, backend);
   if (result === undefined)
     return { outcome: "refused", reason: "Session not found" };
   if (!result.ok) {
@@ -81642,7 +81818,8 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
       const inspected = inspectRun(resolved.runId, { toolControlRegistry });
       if (!inspected.ok)
         return fail(`Run not found: ${target}`);
-      emitChatSurface(pi, { kind: "detail", detail: inspected.detail });
+      const owningRunStatuses = Object.fromEntries(store.graphSnapshot().runs.map((run2) => [run2.id, run2.status]));
+      emitChatSurface(pi, { kind: "detail", detail: inspected.detail, owningRunStatuses });
       return;
     }
     const capturedRuns = store.graphSnapshot().runs;
@@ -81861,6 +82038,7 @@ function summarizeRunSnapshot(run2, now = Date.now(), options) {
       name: stage.name,
       status: stage.status
     })),
+    pendingStages: pendingWorkflowStageStatuses(run2, options?.owningRunStatus),
     tools: (run2.toolNodes ?? []).map((tool) => {
       const owner2 = tool;
       return {
@@ -82056,6 +82234,7 @@ function compactWorkflowToolMessage(result) {
   return `${result.action}:${target ? ` ${target}` : ""} ${result.status} — ${result.message}`;
 }
 var STATUS_MESSAGE_CHAR_LIMIT = 120;
+var STATUS_PENDING_STAGE_LIMIT = 10;
 function truncateStatusText(text) {
   const flattened = text.replace(/\s+/g, " ").trim();
   return flattened.length > STATUS_MESSAGE_CHAR_LIMIT ? `${flattened.slice(0, STATUS_MESSAGE_CHAR_LIMIT - 1)}…` : flattened;
@@ -82093,6 +82272,9 @@ function statusAwaitingInputLine(entry) {
   const message = entry.message !== undefined ? ` — "${truncateStatusText(entry.message)}"` : "";
   return `    awaiting input: ${target}${prompt}${message}`;
 }
+function statusPendingStageLine(stage) {
+  return `    pending stage: ${stage.name} (${stage.stageId}) lifecycle=${stage.lifecycle} pendingStageDeliveryAvailable=${stage.pendingStageDeliveryAvailable} Intercom target=${stage.target ?? "unavailable"}`;
+}
 function statusRunIcon(run2, snapshot, allRuns) {
   if (snapshot === undefined)
     return statusIcon(run2.status);
@@ -82127,8 +82309,15 @@ function renderStatusToolContent(result) {
     lines.push(`    runId: ${run2.runId}`);
     for (const entry of run2.awaitingInput)
       lines.push(statusAwaitingInputLine(entry));
+    for (const stage of run2.pendingStages.slice(0, STATUS_PENDING_STAGE_LIMIT)) {
+      lines.push(statusPendingStageLine(stage));
+    }
+    if (run2.pendingStages.length > STATUS_PENDING_STAGE_LIMIT) {
+      const omitted = run2.pendingStages.length - STATUS_PENDING_STAGE_LIMIT;
+      lines.push(`    … ${omitted} more pending stage${omitted === 1 ? "" : "s"}; use status with runId`);
+    }
   });
-  lines.push("hint: status with runId returns full run detail; workflow answer answers pending prompts using runId/stageId/promptId; workflow resume controls paused runs; pause/interrupt/quit also accept runId. Ordinary Intercom handles free-form workflow-stage communication at <runId>:<stageKey>: live delivery is immediate, known unstarted stages queue before their first model turn. Use Intercom ask once a reply-capable live session exists.");
+  lines.push("hint: status with runId returns full run detail; workflow answer answers pending prompts using runId/stageId/promptId; workflow resume controls paused runs; pause/interrupt/quit also accept runId. Ordinary Intercom handles free-form workflow-stage communication at <runId>:<stageKey>: live stage delivery is immediate; a known pending stage `send` queues before its first model turn; `ask` requires a live reply-capable stage.");
   return lines.join(`
 `);
 }
@@ -83119,11 +83308,23 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
             const durable = await awaitRequest(getRuntime().inspectDurableWorkflow(target));
             return durable.kind === "found" ? { action: "statusDetail", runId: target, detail: durable.detail } : { action: "statusDetail", runId: target, error: durable.message };
           }
-          const result2 = inspectRun(resolved.runId, { toolControlRegistry });
-          return result2.ok ? { action: "statusDetail", runId: result2.runId, detail: result2.detail } : { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+          const inspected = inspectRun(resolved.runId, { toolControlRegistry });
+          if (!inspected.ok) {
+            return { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+          }
+          const detailResult = {
+            action: "statusDetail",
+            runId: inspected.runId,
+            detail: inspected.detail
+          };
+          setWorkflowStatusRenderRuns(detailResult, store.graphSnapshot().runs);
+          return detailResult;
         }
+        const capturedRuns = store.graphSnapshot().runs;
+        const statusByRunId = new Map(capturedRuns.map((run2) => [run2.id, run2.status]));
         const listing = buildWorkflowStatusListing(topLevelExpandedSnapshots(), args.statusFilter ?? "all", Date.now(), {
-          toolControlRegistry
+          toolControlRegistry,
+          owningRunStatus: (owningRunId) => statusByRunId.get(owningRunId)
         });
         const result = {
           action: "status",
@@ -83131,7 +83332,7 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
           runs: listing.runs,
           snapshots: listing.snapshots
         };
-        setWorkflowStatusRenderRuns(result, store.graphSnapshot().runs);
+        setWorkflowStatusRenderRuns(result, capturedRuns);
         return result;
       }
       case "stages":
@@ -83306,11 +83507,14 @@ function renderResult(result, opts) {
     }
     case "status": {
       const r = result;
+      const allRuns = opts?.allRuns ?? getWorkflowStatusRenderRuns(r) ?? r.snapshots;
+      const statusByRunId = new Map(allRuns.map((run2) => [run2.id, run2.status]));
       return renderStatusList(r.snapshots, {
         theme: themed ? deriveGraphTheme({}) : undefined,
         width: opts?.width,
         now: opts?.now,
-        allRuns: opts?.allRuns ?? getWorkflowStatusRenderRuns(r) ?? r.snapshots
+        allRuns,
+        owningRunStatus: (runId) => statusByRunId.get(runId)
       });
     }
     case "statusDetail": {
@@ -83319,10 +83523,13 @@ function renderResult(result, opts) {
         return renderNotice("WORKFLOW STATUS", `id=${r2.runId}: ${r2.error}`, opts, themed);
       }
       const r = result;
+      const allRuns = opts?.allRuns ?? getWorkflowStatusRenderRuns(r);
+      const statusByRunId = new Map(allRuns?.map((run2) => [run2.id, run2.status]) ?? []);
       return renderRunDetail(r.detail, {
         theme: themed ? deriveGraphTheme({}) : undefined,
         width: opts?.width,
-        now: opts?.now
+        now: opts?.now,
+        owningRunStatus: (runId) => statusByRunId.get(runId)
       });
     }
     case "inputs": {
@@ -83493,8 +83700,10 @@ var DEFAULT_PROMPT_GUIDANCE = [
   `**Workflow authoring and handoffs**:
   - When a user asks to create or edit a workflow, clarify only unresolved requirements that materially affect its purpose, inputs, stages, handoffs, validation, success criteria, or starter pattern. Read the workflow docs/examples, implement the TypeScript definition with normal coding tools, reload it, and run representative test inputs before presenting it. Use the create-spec skill when it adds value; it is not mandatory when context is already sufficient.
   - After creating and reloading a newly authored custom workflow, close the loop by stating the folder containing the workflow file just written, for example \`.atomic/workflows/\`, in this shape: \`Custom workflow created. You can inspect its code at: <workflow-folder-path>\`. Do this only for newly created custom workflows, never builtin or pre-existing workflows.
-  - Keep a small, readable workflow in one entry file. Do not split short one-use prompts, create one file per stage, add wrapper-only modules, hide the graph across files, or use line counts alone as a module boundary.
+  - Keep a small, readable workflow in one entry file and write it for human maintainers. Keep the graph and control flow visible in the top-level workflow entry file, use stage names that state each stage's responsibility, and make its inputs, outputs, evidence, and success contract explicit. A developer reading the entry file from top to bottom should be able to identify the graph, branches, gates, artifacts, and stop conditions. Avoid both monolithic prompt blobs and gratuitous fragmentation. Do not split short one-use prompts, create one file per stage, add wrapper-only modules, hide the graph across files, or use line counts alone as a module boundary.
   - When a meaningful source boundary improves clarity, reuse, ownership, or testability, keep the graph and control flow in the top-level workflow entry file and extract cohesive concerns such as long or reused prompt builders, shared TypeBox schemas and workflow-specific types, model-policy constants shared by several stages, deterministic helpers with their own testable behavior, or reusable child workflow definitions into a subdirectory below the top-level discovery directory — either one owned by a single workflow or a shared support directory. Project and user discovery scans only top-level \`.ts\`/\`.js\`/\`.mjs\`/\`.cjs\` files in the workflow directory, so those support modules are not scanned as extra top-level workflow candidates; use \`.js\` import extensions from TypeScript source.
+  - Evaluate Atomic extension hooks when a workflow needs fine-grained, cross-cutting tool or session event control. Workflow TypeScript owns the inspectable DAG, stages, handoffs, durable \`ctx.tool\` side effects, and gates; extension hooks own cross-cutting session and model-tool policy such as \`tool_call\` interception, input mutation, or blocking, \`tool_result\` transformation, context and provider hooks, lifecycle observation, or reusable custom tools. Use hooks only when cross-stage or cross-workflow event control is materially clearer than embedding the policy in each stage; do not prescribe a companion extension for ordinary workflow logic. Consult \`packages/coding-agent/docs/extensions.md#events\` for the authoritative hook contracts.
+  - When a workflow depends on a companion extension, make the dependency explicit, package and document it with the workflow, include any extension-provided custom tools in stage \`tools\` allowlists, and document hook-driven behavior so the workflow remains inspectable.
   - When creating or editing a workflow that pins an explicit stage \`model\` or \`fallbackModels\`, consult \`packages/coding-agent/docs/models/model-selection.md\` for role-based recommendations, treating benchmark thinking levels as measurement configurations rather than universal workflow defaults, then call \`workflow({ action: "models" })\` to see the models actually present in the user's configured catalog. Use only the catalog's returned \`fullId\` values as model strings, and append a thinking suffix only when that exact level appears in the entry's \`availableThinkingLevels\`; apply the stage role and failure-cost policy independently to the primary and every fallback; treat an absent or empty \`availableThinkingLevels\` as no suffix support rather than inferring one. If a guide-recommended model for the role is unavailable, try another guide-recommended model that is present in the catalog. If the selected model does not support the role's level, choose another catalog model that does or leave the stage unpinned rather than inventing or silently promoting a level. An explicit user request for a level overrides the role default, but never fabricate an unsupported catalog level. If no recommendation intersects with the catalog, leave the stage unpinned rather than inventing a substitute, and mention the limitation, asking the user only if the workflow requires an explicit model choice. If the catalog is empty, continue with unpinned stages, state that no configured models were returned, and do not fabricate model IDs. Do not inspect or infer credentials, environment variables, auth files, token validity, entitlements, or the reason a model is absent; \`isCurrent\` marks the active selection, not a quality recommendation.
   - Consult docs/workflows.md and its starter patterns (Classify-and-act, Fan-out-and-synthesize, Adversarial verification, Generate-and-filter, Tournament, Loop until done, and Stacked implementation slices) when designing a stage graph.
   - Treat workflow composition as a first-class authoring option. Before duplicating stages, inspect reusable workflow modules and builtin exports; import their definitions and invoke them with \`ctx.workflow(...)\`, mapping typed inputs and consuming only declared outputs. Nested workflows can themselves import children, so combine small reusable graphs into a richer parent while respecting \`maxDepth\`.
@@ -83505,7 +83714,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - Cyclic workflow graphs are unsupported. Workflow authors and coding agents MUST NOT create self-edges or dependency edges from the current frontier to an existing ancestor. Every materialized execution topology must remain a DAG. Redesign or stop before launch if a cycle cannot be removed.
   - Bounded loops must create distinct tracked work for every iteration; never reopen an ancestor below its downstream work. Stacked implementation slices are unrolled, not looped: each slice gets a fresh child boundary and distinct tracked nodes, and no slice may add an edge back to the current frontier, itself, or an ancestor. If a retained session receives follow-up without new dependency work, keep it as non-topological activity metadata rather than adding a back-edge. Before launch, sketch nodes and dependencies for every branch and loop and reject any proposed parent edge to the node itself or an ancestor.
   - Treat dynamic graph validation during execution, replay, and DBOS hydration as the authoritative cycle boundary. If runtime topology code changes, require incremental edge checks and DBOS hydration validation; prompt guidance and TypeScript types cannot replace those runtime checks.
-  - Every workflow invocation automatically receives one stable, non-default Intercom group named \`workflow:<rootRunId>\`. Every model stage inherits it because ordinary \`intercom\` is mandatory even under tool and extension restrictions; nested workflows keep the top-level invocation group, and subagents inherit their launching stage's group. Do not mint or thread group names through ordinary workflow definitions. Use an explicit \`group\` only for an intentional override: a named group or \`group: true\` creates a subgroup, while \`group: "default"\` opts into the shared default group. \`contact_supervisor\` still crosses group boundaries only for authorized subagent escalation.
+  - Every workflow invocation receives the stable control group \`workflow:<rootRunId>\`. Stages inherit it unless an intentional explicit group is authored. Named groups and \`group: true\` become invocation-owned subgroups under \`workflow:<rootRunId>/...\`, so repeated names cannot collide across runs. The invocation context may list and exactly send/ask live stages in its owned subgroups and queue send to known pending stages; this authority is directional and does not let subgroup siblings see or reach each other. Pending ask remains unsupported. \`group: "default"\` is the explicit non-owned shared-group escape and does not receive pending invocation routing. Do not mint root group names manually.
   - Prefer \`ctx.tool(name, args, fn)\` for workflow-owned TypeScript operations with side effects, such as filesystem writes, network mutations, and external API actions. It creates a tracked, non-attachable durable graph node before invoking \`fn\`; it may be used before, between, after, or without model stages. A completed \`ctx.tool\` call is durably checkpointed with its serializable result, so resume replays that result without rerunning \`fn\`. For checks that may fail during a bounded repair loop, opt into \`failureMode: "return"\`, branch on the typed outcome, and pass only the needed error fields to the repair stage or artifact yourself; Atomic does not inject failure evidence into later prompts. Retries do not bound a hung callback, so every \`ctx.tool\` callback that starts a child process or performs network I/O MUST set an explicit positive finite \`timeoutMs\` and forward the supplied \`signal\` to cancellable work. A timeout applies per attempt, aborts that attempt's signal, and gives retries a fresh deadline and signal. Cancellation and storage faults still throw. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately; this rule applies to side effects orchestrated directly by the workflow definition.
   - Pass large stage context through files/artifacts and \`reads\` with an explicit \`Read the file at <path>...\` prompt rather than large \`previous\` payloads or injected session history.
   - Wrap critical stage-prompt content in \`<keepContext>\` / \`</keepContext>\`. Tagged content survives compression verbatim regardless of the compression ratio, and every line of the span including the tag lines is protected. A long-running stage will be compacted, and compaction ranks lines individually: an objective is verbose and restated while the constraint that narrows it is usually one line, so the constraint is the cheaper deletion and what survives reads as broader permission than intended. Tag role constraints that bound a stage to part of the work, acceptance criteria and immutable contracts, explicit prohibitions, and identifiers a stage must not lose such as a target branch, worktree path, or run ID. Do not tag bulk context: protected lines count against the keep target rather than raising it, so a large protected span makes the surrounding transcript compress harder — tag the constraint, not the material it applies to.