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

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

@@ -54,7 +54,7 @@ var renderContactSupervisorResult = (result, { isPartial }, theme, context) => {
     return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
   }
   const details = result.details;
-  const failed = Boolean(context.isError || details?.error === true || details?.delivered === false);
+  const failed = Boolean(context.isError || details?.error === true || details?.delivered === false && details.queued !== true);
   let text = failed ? theme.fg("error", "✗ ") : theme.fg("success", "✓ ");
   text += theme.fg(failed ? "error" : "text", firstTextContent(result));
   if (details?.messageId && !context.expanded) {
@@ -416,6 +416,9 @@ import { randomUUID as randomUUID2 } from "crypto";
 function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
+function isWorkflowStageRosterEntries(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "object" && entry !== null && entry.kind === "workflow-stage" && typeof entry.runId === "string" && typeof entry.stageId === "string" && typeof entry.stageName === "string" && typeof entry.target === "string" && (entry.lifecycle === "pending" || entry.lifecycle === "running") && typeof entry.group === "string" && (entry.sessionId === undefined || typeof entry.sessionId === "string"));
+}
 var BROKER_SOCKET, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
@@ -636,16 +639,15 @@ var init_client = __esm(() => {
           break;
         }
         case "sessions": {
-          const { requestId, sessions } = brokerMessage;
-          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo)) {
+          const { requestId, sessions, workflowStages } = brokerMessage;
+          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages)) {
             throw new Error("Invalid sessions message");
           }
           const pending = this.pendingLists.get(requestId);
-          if (!pending) {
+          if (!pending)
             return;
-          }
           this.pendingLists.delete(requestId);
-          pending.resolve(sessions);
+          pending.resolve({ sessions, workflowStages: workflowStages ?? [] });
           break;
         }
         case "groups": {
@@ -885,7 +887,10 @@ var init_client = __esm(() => {
         }
       });
     }
-    listSessions(group) {
+    async listSessions(group) {
+      return (await this.listDirectory(group)).sessions;
+    }
+    listDirectory(group) {
       let socket;
       try {
         socket = this.requireActiveSocket();
@@ -894,21 +899,21 @@ var init_client = __esm(() => {
       }
       return new Promise((resolve, reject) => {
         const requestId = randomUUID2();
-        const wrappedResolve = (sessions) => {
-          clearTimeout(timeout);
-          resolve(sessions);
-        };
-        const wrappedReject = (error) => {
-          clearTimeout(timeout);
-          reject(error);
-        };
         const timeout = setTimeout(() => {
-          if (this.pendingLists.has(requestId)) {
-            this.pendingLists.delete(requestId);
-            wrappedReject(new Error("List sessions timeout"));
-          }
+          if (!this.pendingLists.delete(requestId))
+            return;
+          reject(new Error("List sessions timeout"));
         }, 5000);
-        this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject });
+        this.pendingLists.set(requestId, {
+          resolve: (directory) => {
+            clearTimeout(timeout);
+            resolve(directory);
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
         try {
           writeMessage(socket, group === undefined ? { type: "list", requestId } : { type: "list", requestId, group });
         } catch (error) {
@@ -1026,8 +1031,8 @@ var init_client = __esm(() => {
         }
       });
     }
-    registerPendingStageRoute(runId, group, capability) {
-      writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability });
+    registerPendingStageRoute(runId, group, capability, stages) {
+      writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability, stages });
     }
     registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
       let socket;
@@ -2574,10 +2579,58 @@ var init_contact_supervisor_tool = __esm(() => {
   init_intercom_utils();
 });
 
+// dist/builtin/intercom/broker/supervisor-channel.ts
+var DEFAULT_TTL_MS;
+var init_supervisor_channel = __esm(() => {
+  DEFAULT_TTL_MS = 10 * 60 * 1000;
+});
+
+// dist/builtin/intercom/broker/group-membership.ts
+var init_group_membership = __esm(() => {
+  init_group();
+});
+
+// dist/builtin/intercom/broker/group-isolation.ts
+var init_group_isolation = __esm(() => {
+  init_group_membership();
+});
+// dist/builtin/intercom/broker/send-handler.ts
+function parsePendingStageTarget(target) {
+  const separator = target.indexOf(":");
+  if (separator < 0)
+    return;
+  const runId = target.slice(0, separator);
+  const stageKey = target.slice(separator + 1);
+  return WORKFLOW_RUN_ID_PATTERN.test(runId) && stageKey.length > 0 ? { runId, stageKey } : undefined;
+}
+var WORKFLOW_RUN_ID_PATTERN;
+var init_send_handler = __esm(() => {
+  init_supervisor_channel();
+  init_group_isolation();
+  init_group_membership();
+  WORKFLOW_RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+});
+
 // dist/builtin/intercom/intercom-tool.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { Type as Type2 } from "typebox";
 import { Text as Text3 } from "@earendil-works/pi-tui";
+async function listDirectory(client, group) {
+  if (typeof client.listDirectory === "function")
+    return client.listDirectory(group);
+  return { sessions: await client.listSessions(group), workflowStages: [] };
+}
+async function resolveReplySender(client, logicalTarget, sendTarget) {
+  if (logicalTarget !== sendTarget)
+    return sendTarget;
+  if (parsePendingStageTarget(logicalTarget) === undefined)
+    return sendTarget;
+  const stage = (await listDirectory(client)).workflowStages.find((candidate) => candidate.sessionId !== undefined && (candidate.target === logicalTarget || `${candidate.runId}:${candidate.stageName}` === logicalTarget));
+  return stage?.sessionId ?? sendTarget;
+}
+function formatWorkflowStageRow(stage) {
+  return `- **${stage.stageName}** — workflow stage [${stage.lifecycle.toUpperCase()}] — target: \`${stage.target}\`${stage.sessionId === undefined ? "" : ` — intercom session: ${stage.sessionId}`}`;
+}
 function registerIntercomTool(pi, deps) {
   const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, beginReplyWait } = deps;
   const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
@@ -2758,7 +2811,8 @@ ${lines.join(`
         case "list": {
           try {
             const mySessionId = connectedClient.sessionId;
-            const ownSessions = await connectedClient.listSessions();
+            const ownDirectory = await listDirectory(connectedClient);
+            const ownSessions = ownDirectory.sessions;
             const currentSession = ownSessions.find((session) => session.id === mySessionId);
             if (!currentSession) {
               return {
@@ -2769,32 +2823,49 @@ ${lines.join(`
             }
             const ownGroups = resolveOwnGroups(ownSessions);
             if (requestedGroup && !isOnlyOwnGroup(requestedGroup, ownGroups)) {
-              const peeked = await connectedClient.listSessions(requestedGroup);
-              const section = peeked.length === 0 ? `**Group [${requestedGroup}] (read-only peek):**
-No sessions in this group.` : `**Group [${requestedGroup}] (read-only peek):**
-${peeked.map((session) => formatSessionListRow(session, currentSession.cwd, session.id === mySessionId)).join(`
+              const peeked = await listDirectory(connectedClient, requestedGroup);
+              const rows = [
+                ...peeked.sessions.map((session) => formatSessionListRow(session, currentSession.cwd, session.id === mySessionId)),
+                ...peeked.workflowStages.map(formatWorkflowStageRow)
+              ];
+              const section = rows.length === 0 ? `**Group [${requestedGroup}] (read-only peek):**
+No sessions or workflow stages in this group.` : `**Group [${requestedGroup}] (read-only peek):**
+${rows.join(`
 `)}`;
               return {
                 content: [{ type: "text", text: `Your groups: ${ownGroups.join(", ")}
 
 ${section}` }],
                 isError: false,
-                details: { group: ownGroups.at(-1), groups: ownGroups, peekGroup: requestedGroup }
+                details: {
+                  group: ownGroups.at(-1),
+                  groups: ownGroups,
+                  peekGroup: requestedGroup,
+                  workflowStages: peeked.workflowStages
+                }
               };
             }
             const otherSessions = ownSessions.filter((session) => session.id !== mySessionId);
             const currentSection = `**Current session** (groups: ${ownGroups.join(", ")}):
 ${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
-            const otherSection = otherSessions.length === 0 ? `**Other sessions:**
-No other sessions share any of your groups.` : `**Other visible sessions:**
-${otherSessions.map((session) => formatSessionListRow(session, currentSession.cwd, false)).join(`
+            const visibleRows = [
+              ...otherSessions.map((session) => formatSessionListRow(session, currentSession.cwd, false)),
+              ...ownDirectory.workflowStages.map(formatWorkflowStageRow)
+            ];
+            const otherSection = visibleRows.length === 0 ? `**Other sessions and workflow stages:**
+No other sessions or workflow stages share any of your groups.` : `**Other visible sessions and workflow stages:**
+${visibleRows.join(`
 `)}`;
             return {
               content: [{ type: "text", text: `${currentSection}
 
 ${otherSection}` }],
               isError: false,
-              details: { group: ownGroups.at(-1), groups: ownGroups }
+              details: {
+                group: ownGroups.at(-1),
+                groups: ownGroups,
+                ...ownDirectory.workflowStages.length === 0 ? {} : { workflowStages: ownDirectory.workflowStages }
+              }
             };
           } catch (error) {
             return {
@@ -2957,7 +3028,8 @@ ${message}${attachmentText}`);
               };
             }
             const questionId = randomUUID4();
-            const admission = beginReplyWait(sendTo, questionId, _signal);
+            const replyFrom = await resolveReplySender(connectedClient, to, sendTo);
+            const admission = beginReplyWait(replyFrom, questionId, _signal);
             if (!admission.ok) {
               const text = admission.reason === "busy" ? `Too many pending asks (${admission.limit}); reply-wait slots are full` : "Cancelled";
               return {
@@ -3166,6 +3238,7 @@ var init_intercom_tool = __esm(() => {
   init_result_renderers();
   init_intercom_utils();
   init_group();
+  init_send_handler();
 });
 
 // dist/builtin/intercom/ui/compose.ts
@@ -3358,13 +3431,15 @@ class SessionListOverlay {
   done;
   sessions;
   selectedIndex = 0;
+  workflowStages;
   maxVisible = 8;
-  constructor(theme, keybindings, currentSession, sessions, done) {
+  constructor(theme, keybindings, currentSession, sessions, done, workflowStages = []) {
     this.theme = theme;
     this.keybindings = keybindings;
     this.currentSession = currentSession;
     this.sessions = sessions;
     this.done = done;
+    this.workflowStages = workflowStages;
   }
   onSessionSelect(sessionId) {
     const session = this.sessions.find((s) => s.id === sessionId);
@@ -3448,6 +3523,18 @@ class SessionListOverlay {
         lines.push(row(this.theme.fg("dim", ` ${this.selectedIndex + 1}/${this.sessions.length}`)));
       }
     }
+    if (this.workflowStages.length > 0) {
+      const visibleStages = this.workflowStages.slice(0, this.maxVisible);
+      lines.push(row());
+      lines.push(row(this.theme.bold(" Workflow Stages")));
+      for (const stage of visibleStages) {
+        lines.push(row(`  ${stage.stageName} [${stage.lifecycle.toUpperCase()}]`));
+        lines.push(row(`  ${this.theme.fg("dim", stage.target)}`));
+      }
+      if (visibleStages.length < this.workflowStages.length) {
+        lines.push(row(this.theme.fg("dim", ` ${visibleStages.length}/${this.workflowStages.length}`)));
+      }
+    }
     lines.push(row());
     lines.push(border(`├${"─".repeat(contentWidth)}┤`));
     lines.push(row(this.theme.fg("dim", ` ${footer}`)));
@@ -3476,25 +3563,27 @@ function registerIntercomOverlay(pi, deps) {
     deps.syncPresenceIdentity(ctx.sessionManager.getSessionId());
     let currentSession;
     let sessions;
+    let workflowStages;
     let duplicates;
     try {
       const mySessionId = overlayClient.sessionId;
-      const allSessions = await overlayClient.listSessions();
+      const directory = await overlayClient.listDirectory();
       if (!deps.getLiveContext(ctx, overlayGeneration))
         return;
-      const foundCurrentSession = allSessions.find((s) => s.id === mySessionId);
+      const foundCurrentSession = directory.sessions.find((session) => session.id === mySessionId);
       if (!foundCurrentSession) {
         deps.notifyIfLive(ctx, "Current session is missing from intercom session list", "error", overlayGeneration);
         return;
       }
       currentSession = foundCurrentSession;
-      duplicates = duplicateSessionNames(allSessions);
-      sessions = allSessions.filter((s) => s.id !== mySessionId);
+      duplicates = duplicateSessionNames(directory.sessions);
+      sessions = directory.sessions.filter((session) => session.id !== mySessionId);
+      workflowStages = directory.workflowStages;
     } catch (error) {
       deps.notifyIfLive(ctx, `Failed to list sessions: ${getErrorMessage(error)}`, "error", overlayGeneration);
       return;
     }
-    const selectedSession = await ctx.ui.custom((_tui, theme, keybindings, done) => new SessionListOverlay(theme, keybindings, currentSession, sessions, done), { overlay: true }).catch(() => {
+    const selectedSession = await ctx.ui.custom((_tui, theme, keybindings, done) => new SessionListOverlay(theme, keybindings, currentSession, sessions, done, workflowStages), { overlay: true }).catch(() => {
       return;
     });
     if (!selectedSession || !deps.getLiveContext(ctx, overlayGeneration))
@@ -3662,7 +3751,7 @@ class DeliveredMessageCache {
   ttlMs;
   maxEntries;
   delivered = new Map;
-  constructor(ttlMs = DEFAULT_TTL_MS, maxEntries = DEFAULT_MAX_ENTRIES) {
+  constructor(ttlMs = DEFAULT_TTL_MS2, maxEntries = DEFAULT_MAX_ENTRIES) {
     this.ttlMs = ttlMs;
     this.maxEntries = maxEntries;
   }
@@ -3692,9 +3781,9 @@ class DeliveredMessageCache {
     }
   }
 }
-var DEFAULT_TTL_MS, DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_TTL_MS2, DEFAULT_MAX_ENTRIES = 1e4;
 var init_delivered_message_cache = __esm(() => {
-  DEFAULT_TTL_MS = 10 * 60 * 1000;
+  DEFAULT_TTL_MS2 = 10 * 60 * 1000;
 });
 
 // dist/builtin/intercom/terminal-ordering-barrier.ts
@@ -5407,10 +5496,15 @@ function piIntercomExtension(pi, testOverrides = {}) {
     };
     if (!existing)
       pendingStageRouteClients.set(runId, state);
-    if (state.client?.isConnected())
+    if (state.client?.isConnected()) {
+      state.route = route;
+      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages);
       return;
-    if (state.promise)
-      return state.promise;
+    }
+    if (state.promise) {
+      await state.promise;
+      return ensurePendingStageRouteClient(runId, route);
+    }
     const promise = (async () => {
       await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
       const nextClient = new IntercomClient(`${currentSessionId}:pending-stage-route:${runId}`);
@@ -5421,7 +5515,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
         await nextClient.disconnect();
         throw new Error("Intercom runtime no longer active");
       }
-      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability);
+      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages);
       await nextClient.listSessions();
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
@@ -5469,7 +5563,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   async function registerPendingStageRoute(activeClient, runId, route) {
     const routeGroup = normalizeGroup(route.group);
     if (clientRegistrationGroup === routeGroup) {
-      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability);
+      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages);
       return;
     }
     await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
@@ -5541,7 +5635,11 @@ function piIntercomExtension(pi, testOverrides = {}) {
   pi.events.on(PENDING_STAGE_ROUTE_EVENT, (payload) => {
     if (!isPendingStageRouteRegistrationEvent(payload))
       return;
-    pendingStageRoutes.set(payload.runId, { group: payload.group, capability: payload.capability });
+    pendingStageRoutes.set(payload.runId, {
+      group: payload.group,
+      capability: payload.capability,
+      ...payload.stages === undefined ? {} : { stages: payload.stages }
+    });
     const completion = ensureConnected("background").then((activeClient) => registerPendingStageRoute(activeClient, payload.runId, payload));
     payload.completion = completion;
     completion.catch(() => {});
@@ -5943,6 +6041,9 @@ function renderHeavyToolResult(loadedHeavy, name, args) {
     return renderer(...args);
   return renderIntercomToolResult(name, args);
 }
+function isRecoverableHeavyInitializationDisconnect(error) {
+  return error instanceof Error && error.message === "Client disconnected";
+}
 function intercom(pi, options = {}) {
   const inheritedDelegatedSessionName = readSubagentEnv("INTERCOM_SESSION_NAME");
   let heavyAttempt = null;
@@ -6096,8 +6197,10 @@ function intercom(pi, options = {}) {
     }, (error) => {
       if (heavyAttempt?.promise === promise)
         heavyAttempt = null;
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`Intercom heavy initialization failed; a later call will retry: ${message}`, error);
+      if (!isRecoverableHeavyInitializationDisconnect(error)) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Intercom heavy initialization failed; a later call will retry: ${message}`, error);
+      }
     });
     return promise;
   }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.18-alpha.1",
+  "version": "0.9.18-alpha.3",
   "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/intercom/skills/intercom/SKILL.md

@@ -75,7 +75,7 @@ intercom({ action: "list" })
 intercom({ action: "ask", to: "6332faab-1111-4222-8333-123456789abc", message: "Which option should I use?" })
 ```
 
-Live sessions accept an exact full session ID or exact case-insensitive name. Ordinary `send` to a known workflow stage whose session has not initialized uses the exact `<runId>:<stageKey>` identity. Unknown runs and stages retain the ordinary unknown-target failure.
+Live sessions accept an exact full Intercom session ID or exact case-insensitive name. For workflow stages, first use `intercom({ action: "list" })`: materialized stages appear as `PENDING` or `RUNNING` with canonical `<runId>:<stageId>` targets and actual groups. The invocation context can control owned isolated subgroups by exact target, while sibling subgroups and other runs remain isolated. Use queued `send` for `PENDING`; `ask` is supported only for `RUNNING`, where an exact correlated reply returns to the invocation asker.
 
 ### Deliver to workflow stages that have not started
 

package/dist/builtin/intercom/types.ts

@@ -13,6 +13,34 @@ export interface SessionInfo {
   group?: string;
 }
 
+export interface WorkflowStageRosterEntry {
+	readonly kind: "workflow-stage";
+	readonly runId: string;
+	readonly stageId: string;
+	readonly stageName: string;
+	readonly target: string;
+	readonly lifecycle: "pending" | "running";
+	readonly group: string;
+	/** Broker session identity, present only while the workflow stage is connected. */
+	readonly sessionId?: string;
+}
+
+export interface SessionDirectory {
+	readonly sessions: SessionInfo[];
+	readonly workflowStages: WorkflowStageRosterEntry[];
+}
+
+export interface WorkflowStageRosterAnnouncement {
+	readonly stageId: string;
+	readonly stageName: string;
+	readonly target: string;
+	readonly lifecycle: "pending" | "running";
+	readonly routeEligible: boolean;
+	/** Actual stage group after workflow invocation ownership resolution. */
+	readonly group: string;
+}
+
+
 export interface GroupSummary {
 	group: string;
 	sessionCount: number;
@@ -77,7 +105,7 @@ export type ClientMessage =
 			attemptId?: string;
 	  }
 	| { type: "pending_stage_notification_result"; requestId: string; delivered: boolean }
-  | { type: "register_pending_stage_route"; runId: string; group: string; capability: string }
+  | { type: "register_pending_stage_route"; runId: string; group: string; capability: string; stages?: WorkflowStageRosterAnnouncement[] }
   | {
       type: "register_live_workflow_stage_route";
       requestId: string;
@@ -107,7 +135,7 @@ export type ClientMessage =
 export type BrokerMessage =
   | { type: "registered"; sessionId: string; supervisorSessionId?: string }
   | { type: "registration_failed"; reason: string }
-  | { type: "sessions"; requestId: string; sessions: SessionInfo[] }
+  | { type: "sessions"; requestId: string; sessions: SessionInfo[]; workflowStages?: WorkflowStageRosterEntry[] }
 	| { type: "groups"; requestId: string; groups: GroupSummary[] }
 	| { type: "membership_ack"; requestId: string; groups: string[] }
   | { type: "supervisor_authorized"; requestId: string; capability: string; supervisorSessionId: string; childName: string }

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.18-alpha.1",
+  "version": "0.9.18-alpha.3",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.18-alpha.1",
+  "version": "0.9.18-alpha.3",
   "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.18-alpha.1",
+  "version": "0.9.18-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,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.18-alpha.3] - 2026-09-01
+
+### Added
+
+- Workflow status text, interactive list/detail views, and the persistent `BACKGROUND` panel now identify materialized pending stages by display name and canonical stage ID, show exact Intercom targets only when pre-start delivery is available, and distinguish unavailable pending delivery truthfully.
+
+### Changed
+
+- Workflow-authoring guidance now distinguishes inspectable workflow orchestration from cross-cutting extension-hook policy, requires companion-extension dependencies to remain explicit, and directs generated workflows toward readable top-level graphs with cohesive source boundaries.
+
+### Fixed
+
+- Fixed pending-stage targets in `/workflow status` cards and the persistent `BACKGROUND` panel being truncated into unusable addresses. Status cards now wrap exact targets, while widget metadata uses only bounded pending-stage forms that fit without displacing existing metadata and width-based omissions show an explicit remaining-stage count. ([#2784](https://github.com/bastani-inc/atomic/issues/2784))
+- Fixed `/workflow status` losing pending-stage delivery capability in its bounded graph projection, run detail ellipsizing exact pending targets at narrow widths, terminal runs advertising undeliverable targets, and narrow status cards truncating canonical stage IDs. Exact targets and IDs now wrap where appropriate, while ended runs report pending delivery as unavailable. ([#2784](https://github.com/bastani-inc/atomic/issues/2784))
+- Fixed projected pending stages from terminal nested child runs advertising unusable Intercom targets through their still-live root, pending widget labels exceeding their width budget and evicting tool/elapsed metadata, duplicated Intercom coaching in model-facing status hints, and singular overflow counts using a plural noun. ([#2784](https://github.com/bastani-inc/atomic/issues/2784))
+
+- Fixed explicit and automatic stage groups so they become invocation-owned, collision-free subgroups that remain controllable from the workflow invocation while preserving sibling isolation and their exact persisted identity across active durable resume; restored symmetric isolated reviewer groups for Goal and Ralph ([#2784](https://github.com/bastani-inc/atomic/issues/2784)).
+
 ## [0.9.16] - 2026-08-29
 
 Cumulative release of the `0.9.16-alpha.1` – `0.9.16-alpha.11` prereleases. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease sections below.

package/dist/builtin/workflows/README.md

@@ -86,7 +86,7 @@ Execution, replay, and DBOS hydration are the authoritative topology-validation
 
 ### Workflow source layout
 
-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.
 
 At a meaningful source boundary that improves clarity, reuse, ownership, or testability, keep the graph and control flow in the top-level workflow entry file and extract cohesive concerns: 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.
 
@@ -101,6 +101,12 @@ The existing `.atomic/workflows/release-docs.ts` keeps its graph in the entry fi
 .atomic/workflows/code-review/model-policy.ts
 ```
 
+### Workflow and extension responsibilities
+
+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 require a companion extension for ordinary workflow logic. See the authoritative [extension event documentation](../coding-agent/docs/extensions.md#events) for hook contracts and ordering.
+
+When a workflow depends on a companion extension, make that dependency explicit and package and document the extension with the workflow. If stages use `tools` allowlists, include any custom tools provided by the extension. Document the hook-driven behavior and keep the graph, stage contracts, artifacts, gates, and stop conditions visible in the workflow entry file so readers can distinguish inspectable workflow orchestration from event policy.
+
 ### Workflow-owned side effects
 
 Prefer `ctx.tool(name, args, fn)` for workflow-owned TypeScript operations with side effects, including filesystem writes, network mutations, external API actions, and similar deterministic operations orchestrated directly by the workflow definition. Each invocation creates a non-chat, non-attachable durable graph node before `fn` runs; it may appear before, between, after, or without model stages. Atomic durably caches a completed call's serializable result, so resume returns that result without rerunning `fn` or repeating the side effect. Tool-only workflows are valid tracked execution, while a normal return with no stage, child, tool, or explicit exit remains invalid. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately. The executor closes tool admission before publishing any terminal outcome; calling a retained `ctx.tool` function afterward returns a rejected native promise and creates no callback, retry, graph node, or checkpoint.
@@ -445,7 +451,7 @@ When an item configures both `schema` and `output`, its successful `structured_o
 
 `subagent` is available as a default workflow-stage tool on the same terms as main chat: a stage is a top-level session, so it can delegate once, and the children it launches cannot delegate further. Delegation is one level deep and nothing configures it. `tools` allowlists apply to bundled extension tools as well as built-ins; if a stage sets `tools`, list every non-mandatory tool it should see. Ordinary `intercom` remains registered and active in every workflow model stage even under `noTools: "all"`, restrictive allowlists, or exclusions. Restrictions on `subagent`, `web_search`, `fetch_content`, and every other tool are unchanged. Bundled `@bastani/subagents` agent definitions are available to the `subagent` tool in workflow stages, including workflows launched from a subagent child process.
 
-Send material updates through Intercom to every affected workflow stage, including stages that have not started. Address a known pending stage with ordinary `intercom send` at `<runId>:<stageKey>`; Atomic queues the message with workflow state and delivers it through the existing inbound Intercom path when the stage session initializes, before its first model turn. Live stage delivery is immediate. Use `ask` once the stage session is live and can reply. Unknown stage identities retain the ordinary unknown-target failure. Workflow `answer` handles pending human-input prompts, and workflow `resume` handles paused run control.
+Send material updates through Intercom to every affected workflow stage, including stages that have not started. Address a known pending stage on a nonterminal run with ordinary `intercom send` at `<runId>:<stageKey>`; Atomic queues the message with workflow state and delivers it through the existing inbound Intercom path when the stage session initializes, before its first model turn. Live stage delivery is immediate. Status surfaces never advertise a retained pending stage after its run terminates. Use `ask` once the stage session is live and can reply. Unknown stage identities retain the ordinary unknown-target failure. Workflow `answer` handles pending human-input prompts, and workflow `resume` handles paused run control.
 
 ### Model fallbacks
 
@@ -662,6 +668,8 @@ Named workflow launches always run as **background tasks** in interactive sessio
 
 Typing into an attached stage chat and pressing Enter steers: the message is consumed after the current assistant response finishes its tool batch and before the next model request, matching normal session steering. Ctrl+F queues a follow-up, consumed only when the agent would otherwise stop. Queued entries belong to the stage session rather than the pane, so leaving the stage and reattaching restores the pending `Steering:` / `Follow-up:` rows, and a detached stage node carries a `✉ N queued` badge in the graph.
 
+At normal widths, the persistent `BACKGROUND` panel and interactive `/workflow status` list/detail name materialized pending stages by display name and canonical ID. They show `<runId>:<stageId>` only when pre-start Intercom delivery is available on a nonterminal owning run and label unavailable delivery otherwise; retained pending stages on ended runs, including ended nested child runs projected into a live root, never advertise a target. Interactive status cards and run detail wrap a full target onto continuation rows when needed, and narrow status cards preserve the full canonical stage ID rather than ellipsizing it. The single-line panel uses only pending-stage forms that fit its remaining metadata budget; if none fit, it omits the pending label entirely so mode, progress, live-tool, and elapsed/status metadata remains intact. The narrow widget remains aggregate-only.
+
 Named launches return only after startup admission, while the admitted workflow body and stages remain background work. Pre-body setup failures (including invalid input-bound reusable worktrees) are returned immediately from the original tool call as structured failed results with the concrete error and allocated run id; Atomic does not first claim that the workflow started, and it removes the unadmitted run so corrected inputs can be retried immediately. Failures after admission continue to use normal background status and lifecycle notices.
 
 Graceful quit is idempotent for already-paused runs and preserves unresolved `ctx.ui` prompts in DBOS. Pausing or interrupting a stage also holds every queued steering and follow-up item in place: no queued turn, late context-bearing delivery, or workflow continuation starts while the stage is paused, and the existing `resume` action releases the items once in their existing per-queue order without queue release itself starting a provider turn. Stable author-callsite-and-composed-nested-scope reservations are created before prompting and released by exact current-format token generation after answer checkpoint, rejection, or abort. Answering while quit/paused cannot advance workflow code until explicit resume.
@@ -710,6 +718,7 @@ Raw stage-chat prompt answer replay is live-memory only. `StageSnapshot.promptAn
 - **`answer`** — answers one pending primitive or structured workflow prompt while the authoritative root is nonterminal. It accepts `promptId` plus `response`, `text`, or `message`, but never sends stage chat, steers work, resumes a stage, or starts a model turn.
 
 Free-form workflow-stage communication uses ordinary Intercom, not the workflow tool. Send to `<runId>:<stageKey>`; Atomic delivers immediately to live stages and queues messages for known stages that have not started.
+The concise model-facing status listing enumerates pending stages with their display name, canonical ID, literal `pending` lifecycle, `pendingStageDeliveryAvailable` value, and an exact Intercom target only when that target is usable on a nonterminal owning run. Retained pending stages on ended root or nested child runs report unavailable delivery and no target, including when a child stage is projected through a live root. Duplicate names remain distinct through canonical IDs. Live `send` delivery is immediate, a known pending-stage `send` queues before the first model turn, and `ask` requires a live reply-capable stage.
 - **`reload`** — refreshes workflow resources directly in-process instead of queuing a literal `/workflow reload` chat follow-up.
 - **`models`** — returns safe model-catalog metadata from the configured registry. Each entry contains `provider` (e.g. `openai`), `id` (e.g. `gpt-4`), `fullId` (e.g. `openai/gpt-4`), `isCurrent` (whether this is the active model), and `availableThinkingLevels`, canonically derived from the registry model's `reasoning` and `thinkingLevelMap` metadata. The result is a configured-auth snapshot: it shows which models are present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. No secrets, tokens, or authentication details are returned.
 

package/dist/builtin/workflows/builtin/{chunk-ngffz3y8.js → chunk-fghhy2a5.js}

@@ -9,7 +9,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   workflowArtifactDirectoryPath
-} from "./chunk-brerg33r.js";
+} from "./chunk-n58a7v26.js";
 import {
   fold_usage
 } from "./chunk-7at6dnkr.js";

package/dist/builtin/workflows/builtin/{chunk-6v0yv8tj.js → chunk-h3r2vkzc.js}

@@ -8,7 +8,7 @@ import {
   reverify_consolidated_batch,
   reviewerFailureText,
   summarizeReviewConvergence
-} from "./chunk-brerg33r.js";
+} from "./chunk-n58a7v26.js";
 import {
   fold_usage
 } from "./chunk-7at6dnkr.js";

package/dist/builtin/workflows/builtin/{chunk-brerg33r.js → chunk-n58a7v26.js}

@@ -700,7 +700,6 @@ function compactStage(stage) {
     inputRequest,
     notices,
     mcpScope: _mcpScope,
-    pendingStageDeliveryAvailable: _pendingStageDeliveryAvailable,
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,

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

@@ -1,7 +1,7 @@
 import {
   goal_default
-} from "./chunk-ngffz3y8.js";
-import"./chunk-brerg33r.js";
+} from "./chunk-fghhy2a5.js";
+import"./chunk-n58a7v26.js";
 import"./chunk-7at6dnkr.js";
 import"./chunk-7430zyas.js";
 import"./chunk-6fqs7c01.js";

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

@@ -1,6 +1,6 @@
 import {
   ralph_default
-} from "./chunk-6v0yv8tj.js";
+} from "./chunk-h3r2vkzc.js";
 import {
   tournament_default
 } from "./chunk-2dqb5s2q.js";
@@ -18,8 +18,8 @@ import {
 } from "./chunk-hzzn6adg.js";
 import {
   goal_default
-} from "./chunk-ngffz3y8.js";
-import"./chunk-brerg33r.js";
+} from "./chunk-fghhy2a5.js";
+import"./chunk-n58a7v26.js";
 import"./chunk-7at6dnkr.js";
 import"./chunk-7430zyas.js";
 import {