@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/intercom/index.ts

@@ -92,10 +92,10 @@ function renderHeavyToolResult(loadedHeavy: CapturedHeavy | null, name: string,
 	return renderIntercomToolResult(name, args);
 }
 export default function intercom(pi: ExtensionAPI, options: LightweightIntercomOptions = {}) {
-	const delegatedSessionName = readSubagentEnv("INTERCOM_SESSION_NAME");
-	let heavyAttempt: HeavyAttempt | null = null;
-	let loadedHeavy: IntercomHeavyHandle | null = null;
-	let sessionSnapshot: SessionSnapshot | null = null;
+  const inheritedDelegatedSessionName = readSubagentEnv("INTERCOM_SESSION_NAME");
+  let heavyAttempt: HeavyAttempt | null = null;
+  let loadedHeavy: IntercomHeavyHandle | null = null;
+  let sessionSnapshot: SessionSnapshot | null = null;
 	let lifecycleGeneration = 0;
 	let nextLeaseId = 1;
 	let activeLease = createLifecycleLease<ShutdownSnapshot>(nextLeaseId++);
@@ -229,21 +229,45 @@ export default function intercom(pi: ExtensionAPI, options: LightweightIntercomO
 		);
 		return promise;
 	}
-	pi.on("session_start", async (event, ctx) => {
-		if (delegatedSessionName && typeof pi.setSessionName === "function") pi.setSessionName(delegatedSessionName);
-		if (activeLease.retired) activeLease = createLifecycleLease<ShutdownSnapshot>(nextLeaseId++, activeLease.cleanupBarrier);
-		const lease = activeLease;
-		await waitForPriorCleanup(lease);
-		if (sessionSnapshot) {
-			activeLifecycle.turnStart = null;
-			activeLifecycle.agentStart = null;
-			activeLifecycle.activeTools.clear();
-			activeLifecycle.modelSelect = null;
-		}
-		const generation = ++lifecycleGeneration;
-		sessionSnapshot = { event, ctx, generation, lease };
-		if (loadedHeavy) await ensureSessionStartReplayed(loadedHeavy.heavy, lease);
-	});
+  let typedContactSupervisorRegistered = hasSubagentIntercomEnv();
+  const registerTypedContactSupervisor = (): void => {
+    if (typedContactSupervisorRegistered) return;
+    typedContactSupervisorRegistered = true;
+    pi.registerTool({
+      name: "contact_supervisor",
+      label: "Contact Supervisor",
+      description: "Subagent-only tool for contacting the supervisor agent that delegated this task.",
+      promptSnippet: "Subagent-only: contact the supervisor for decisions, interviews, or meaningful updates.",
+      parameters: Type.Object({
+        reason: Type.String({ enum: ["need_decision", "progress_update", "interview_request"] }),
+        message: Type.Optional(Type.String()),
+        interview: Type.Optional(Type.Unknown()),
+      }),
+      execute: (...args) => executeHeavyTool(loadHeavy, "contact_supervisor", args),
+      renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "contact_supervisor", args),
+    });
+  };
+  pi.on("session_start", async (event, ctx) => {
+    const typedIdentity = ctx.subagentPolicy?.intercom;
+    if (typedIdentity) {
+      if (typedIdentity.sessionName && typeof pi.setSessionName === "function") pi.setSessionName(typedIdentity.sessionName);
+      registerTypedContactSupervisor();
+    } else if (inheritedDelegatedSessionName && typeof pi.setSessionName === "function") {
+      pi.setSessionName(inheritedDelegatedSessionName);
+    }
+    if (activeLease.retired) activeLease = createLifecycleLease<ShutdownSnapshot>(nextLeaseId++, activeLease.cleanupBarrier);
+    const lease = activeLease;
+    await waitForPriorCleanup(lease);
+    if (sessionSnapshot) {
+      activeLifecycle.turnStart = null;
+      activeLifecycle.agentStart = null;
+      activeLifecycle.activeTools.clear();
+      activeLifecycle.modelSelect = null;
+    }
+    const generation = ++lifecycleGeneration;
+    sessionSnapshot = { event, ctx, generation, lease };
+    if (loadedHeavy) await ensureSessionStartReplayed(loadedHeavy.heavy, lease);
+  });
 	pi.on("session_shutdown", async (event, ctx) => {
 		const lease = activeLease;
 		const generation = ++lifecycleGeneration;
@@ -388,14 +412,18 @@ Sessions belong to an intercom group and can ONLY message sessions in the same g
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
+  intercom({ action: "join", group: "name" })     → Join or create a named group
+  intercom({ action: "leave" })                   → Return to your resolved home group
   intercom({ action: "send", to: "session-name", message: "..." })  → Send message (own group only)
   intercom({ action: "ask", to: "session-name", message: "..." })   → Ask and wait for reply
   intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status and your group`,
+  intercom({ action: "status" })                  → Show connection status and your group
+
+"default" is the shared group; "true" and "auto" are reserved for subagent auto-groups. Joining does not grant cross-group access; contact_supervisor remains the only cross-group path.`,
 		promptSnippet: "Use to coordinate with other local agent sessions in your intercom group: list peers, send updates, ask for help, or check intercom connectivity. Groups are isolated; you can only message sessions in your own group.",
 		parameters: Type.Object({
-			action: Type.String({ description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'" }),
+			action: Type.String({ description: "Action: 'list', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'" }),
 			to: Type.Optional(Type.String({ description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')" })),
 			message: Type.Optional(Type.String({ description: "Message to send (for 'send', 'ask', or 'reply' action)" })),
 			attachments: Type.Optional(Type.Array(Type.Object({
@@ -405,7 +433,7 @@ Usage:
 				language: Type.Optional(Type.String()),
 			}))),
 			replyTo: Type.Optional(Type.String({ description: "Message ID to reply to (for threading or responding to an 'ask')" })),
-			group: Type.Optional(Type.String({ description: "Read-only group filter for 'list'/'status'; 'send'/'ask' are locked to your own group." })),
+			group: Type.Optional(Type.String({ description: "Group name for 'join'; read-only group filter for 'list'/'status'. 'send'/'ask' are locked to your own group." })),
 		}),
 		execute: (...args) => executeHeavyTool(loadHeavy, "intercom", args),
 		renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "intercom", args),

package/dist/builtin/intercom/intercom-tool.ts

@@ -14,12 +14,15 @@ import {
 } from "./intercom-utils.js";
 import type { ReplyTracker } from "./reply-tracker.js";
 import { resolveSessionTargetId } from "./session-target.js";
-import { normalizeGroup } from "./group.js";
+import { normalizeGroup, validateRuntimeGroup } from "./group.js";
 
 interface IntercomToolDeps {
   ensureConnected(reason: "tool"): Promise<IntercomClient>;
   syncPresenceIdentity(sessionId: string): void;
   resolveSessionTarget?(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
+  homeGroup(): string;
+  setJoinedGroup(group: string): void;
+  clearJoinedGroup(): void;
   confirmSend: boolean;
   /**
    * Atomically reserve the single reply-waiter slot. Returns a structured
@@ -49,17 +52,23 @@ cross-group sends are rejected by the broker. Ungrouped sessions share the "defa
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
+  intercom({ action: "join", group: "name" })     → Join or create a named group
+  intercom({ action: "leave" })                   → Return to your resolved home group
   intercom({ action: "send", to: "session-name", message: "..." })  → Send message (own group only)
   intercom({ action: "ask", to: "session-name", message: "..." })   → Ask and wait for reply
   intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status and your group`,
+  intercom({ action: "status" })                  → Show connection status and your group
+
+The "join" action changes this session's group in place. "default" is the shared
+default group; "true" and "auto" are reserved for subagent auto-groups. Joining
+does not grant cross-group access: contact_supervisor is the only cross-group path.`,
     promptSnippet:
       "Use to coordinate with other local agent sessions in your intercom group: list peers, send updates, ask for help, or check intercom connectivity. Groups are isolated; you can only message sessions in your own group.",
 
     parameters: Type.Object({
       action: Type.String({
-        description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'",
+        description: "Action: 'list', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'",
       }),
       to: Type.Optional(Type.String({
         description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
@@ -77,7 +86,7 @@ Usage:
         description: "Message ID to reply to (for threading or responding to an 'ask')",
       })),
       group: Type.Optional(Type.String({
-        description: "Read-only group filter for 'list'/'status' (peek who is in a named group). 'send'/'ask' are always locked to your own group; passing a different group errors.",
+        description: "Group name for 'join'; read-only group filter for 'list'/'status'. 'send'/'ask' are locked to your own group.",
       })),
     }),
 
@@ -94,7 +103,6 @@ Usage:
       }
 
       syncPresenceIdentity(ctx.sessionManager.getSessionId());
-
       const { action, to, message, attachments, replyTo, group } = params;
       const requestedGroup = typeof group === "string" && group.trim() ? normalizeGroup(group) : undefined;
       const resolveOwnGroup = async (): Promise<string> => {
@@ -114,6 +122,75 @@ Usage:
       }
 
       switch (action) {
+        case "join": {
+          let targetGroup: string;
+          try {
+            targetGroup = validateRuntimeGroup(group);
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: getErrorMessage(error) }],
+              isError: true,
+              details: { error: true },
+            };
+          }
+          try {
+            const acknowledgedGroup = await connectedClient.updatePresenceAcked({ group: targetGroup });
+            if (acknowledgedGroup !== targetGroup) {
+              throw new Error(`Broker acknowledged group "${acknowledgedGroup}" instead of "${targetGroup}"`);
+            }
+            deps.setJoinedGroup(targetGroup);
+            return {
+              content: [{ type: "text", text: `Joined intercom group "${targetGroup}".` }],
+              isError: false,
+              details: { group: targetGroup },
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to join group: ${getErrorMessage(error)}` }],
+              isError: true,
+              details: { error: true },
+            };
+          }
+        }
+
+        case "leave": {
+          if (typeof group === "string" && group.trim().length > 0) {
+            return {
+              content: [{ type: "text", text: "The 'leave' action does not accept a group; it returns to the resolved home group." }],
+              isError: true,
+              details: { error: true },
+            };
+          }
+          let targetGroup: string;
+          try {
+            targetGroup = validateRuntimeGroup(deps.homeGroup());
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Cannot leave intercom group: ${getErrorMessage(error)}` }],
+              isError: true,
+              details: { error: true },
+            };
+          }
+          try {
+            const acknowledgedGroup = await connectedClient.updatePresenceAcked({ group: targetGroup });
+            if (acknowledgedGroup !== targetGroup) {
+              throw new Error(`Broker acknowledged group "${acknowledgedGroup}" instead of "${targetGroup}"`);
+            }
+            deps.clearJoinedGroup();
+            return {
+              content: [{ type: "text", text: `Returned to home intercom group "${targetGroup}".` }],
+              isError: false,
+              details: { group: targetGroup },
+            };
+          } catch (error) {
+            return {
+              content: [{ type: "text", text: `Failed to leave group: ${getErrorMessage(error)}` }],
+              isError: true,
+              details: { error: true },
+            };
+          }
+        }
+
         case "list": {
           try {
             const mySessionId = connectedClient.sessionId;

package/dist/builtin/intercom/intercom-utils.ts

@@ -1,5 +1,4 @@
-import type { ExtensionAPI } from "@bastani/atomic";
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import { type ExtensionAPI, type SubagentChildPolicy } from "@bastani/atomic";
 import type { Attachment, Message, SessionInfo, SupervisorRegistration } from "./types.js";
 import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
 
@@ -12,14 +11,6 @@ export const SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-auth
 export const INBOUND_FLUSH_DELAY_MS = 200;
 export const INBOUND_IDLE_RETRY_MS = 500;
 export const DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat";
-const ENV_PREFIX = APP_NAME.toUpperCase();
-const SUBAGENT_ORCHESTRATOR_TARGET_ENV = `${ENV_PREFIX}_SUBAGENT_ORCHESTRATOR_TARGET`;
-const SUBAGENT_RUN_ID_ENV = `${ENV_PREFIX}_SUBAGENT_RUN_ID`;
-const SUBAGENT_CHILD_AGENT_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_AGENT`;
-const SUBAGENT_CHILD_INDEX_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_INDEX`;
-const SUBAGENT_INTERCOM_SESSION_NAME_ENV = `${ENV_PREFIX}_SUBAGENT_INTERCOM_SESSION_NAME`;
-const SUBAGENT_SUPERVISOR_CAPABILITY_ENV = `${ENV_PREFIX}_SUBAGENT_SUPERVISOR_CAPABILITY`;
-const SUBAGENT_SUPERVISOR_SESSION_ID_ENV = `${ENV_PREFIX}_SUBAGENT_SUPERVISOR_SESSION_ID`;
 
 export interface ChildOrchestratorMetadata {
   orchestratorTarget: string;
@@ -76,28 +67,23 @@ export function formatAttachments(attachments: Attachment[]): string {
   }
   return text;
 }
-export function readChildOrchestratorMetadata(): ChildOrchestratorMetadata | null {
-  const orchestratorTarget = getEnvValue(SUBAGENT_ORCHESTRATOR_TARGET_ENV)?.trim();
-  const runId = getEnvValue(SUBAGENT_RUN_ID_ENV)?.trim();
-  const agent = getEnvValue(SUBAGENT_CHILD_AGENT_ENV)?.trim();
-  const index = getEnvValue(SUBAGENT_CHILD_INDEX_ENV)?.trim();
-  if (!orchestratorTarget || !runId || !agent || !index) {
-    return null;
-  }
-  const sessionName = getEnvValue(SUBAGENT_INTERCOM_SESSION_NAME_ENV)?.trim();
-  const capability = getEnvValue(SUBAGENT_SUPERVISOR_CAPABILITY_ENV)?.trim();
-  const supervisorSessionId = getEnvValue(SUBAGENT_SUPERVISOR_SESSION_ID_ENV)?.trim();
+export function childOrchestratorMetadataFromPolicy(policy?: SubagentChildPolicy): ChildOrchestratorMetadata | null {
+  const identity = policy?.intercom;
+  if (!identity) return null;
   return {
-    orchestratorTarget,
-    runId,
-    agent,
-    index,
-    ...(sessionName ? { sessionName } : {}),
-    ...(capability && supervisorSessionId
-      ? { supervisor: { capability, supervisorSessionId } }
-      : {}),
+    orchestratorTarget: identity.orchestratorTarget,
+    runId: identity.runId,
+    agent: identity.agent,
+    index: String(identity.index),
+    ...(identity.sessionName ? { sessionName: identity.sessionName } : {}),
+    ...(identity.supervisor ? { supervisor: identity.supervisor } : {}),
   };
 }
+
+/** Resolve metadata only from the admission-issued typed child identity. */
+export function readChildOrchestratorMetadata(policy?: SubagentChildPolicy): ChildOrchestratorMetadata | null {
+	return childOrchestratorMetadataFromPolicy(policy);
+}
 export function formatChildOrchestratorMessage(kind: "ask" | "update" | "interview", metadata: ChildOrchestratorMetadata, message: string): string {
   const heading = kind === "ask"
     ? "Subagent needs a supervisor decision."

package/dist/builtin/intercom/lazy-subagent-ack.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@bastani/atomic";
+import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
 
 const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
@@ -12,9 +12,14 @@ export function rejectLazyResultRelay(
   if (eventName !== SUBAGENT_RESULT_INTERCOM_EVENT || !payload || typeof payload !== "object") return;
   const requestId = (payload as { requestId?: unknown }).requestId;
   if (typeof requestId !== "string") return;
-  pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
-    requestId,
-    delivered: false,
-    error: error instanceof Error ? error.message : String(error),
-  });
+  try {
+    pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
+      requestId,
+      delivered: false,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  } catch (emitError) {
+    if (!isStaleExtensionContextError(emitError)) throw emitError;
+    // The failed relay can race extension invalidation; no acknowledgement is possible.
+  }
 }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.12",
+  "version": "0.9.13-alpha.2",
   "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": [
@@ -44,7 +44,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.83.0"
+    "@earendil-works/pi-tui": "^0.84.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {
@@ -55,7 +55,6 @@
     }
   },
   "dependencies": {
-    "tsx": "^4.23.1",
     "typebox": "^1.3.7"
   }
 }

package/dist/builtin/intercom/runtime-group.ts

@@ -0,0 +1,13 @@
+import { runtimeIntercomGroupEnvKey } from "@bastani/atomic";
+
+export { runtimeIntercomGroupEnvKey } from "@bastani/atomic";
+
+/** Register one extension instance's current runtime group for child inheritance. */
+export function setRuntimeIntercomGroup(sessionId: string, group: string): void {
+	process.env[runtimeIntercomGroupEnvKey(sessionId)] = group;
+}
+
+/** Remove one extension instance's runtime group without clobbering another session. */
+export function clearRuntimeIntercomGroup(sessionId: string): void {
+	delete process.env[runtimeIntercomGroupEnvKey(sessionId)];
+}

package/dist/builtin/intercom/skills/intercom/SKILL.md

@@ -77,6 +77,21 @@ intercom({ action: "ask", to: "6332faab", message: "Which option should I use?"
 
 Intercom resolves exact full IDs first, exact case-insensitive names second, and unique ID prefixes last. A colliding prefix returns an ambiguity error; use a longer displayed ID or an exact name rather than guessing.
 
+### Runtime named groups
+
+Plain chat sessions can create or join a group without restarting:
+
+```typescript
+// Join or create the named group. Both sessions should run this call.
+intercom({ action: "join", group: "api-review" })
+intercom({ action: "list" }) // now shows only peers in api-review
+
+// Leave the named group and return to the resolved startup home group.
+intercom({ action: "leave" })
+```
+
+Joining changes broker presence without changing the session ID. `default` is the shared group. The names `true` and `auto` are reserved for subagent auto-groups and are rejected. Subagents launched after a join inherit the joined group. Ordinary `send`/`ask` calls remain group-isolated; only an authorized `contact_supervisor` call can cross groups.
+
 ### Pattern 3: Reply Naturally
 
 When responding to an inbound ask, prefer `reply` instead of reconstructing raw IDs:
@@ -196,16 +211,29 @@ metadata get the `contact_supervisor` tool. Normal sessions use the regular
 `intercom` tool. If you see the formatted supervisor decision/progress update
 message, treat it as a `contact_supervisor` escalation.
 
+### Pattern 7: Constructive Quorum
+
+Use constructive quorum when several fresh-context reviewers judge the same artifact and a tally could hide a defect one reviewer found or preserve another reviewer's misreading.
+
+1. Each reviewer inspects independently and records a preliminary verdict before reading sibling findings or verdicts.
+2. Run exactly one bounded evidence-exchange round: share concrete findings and evidence, challenge blocking claims, surface missed defects, and correct objective/acceptance-criteria misreadings. Do not continue into a second round.
+3. Change a verdict only through evidence, never deference. Each reviewer emits its own final structured verdict and records whether the round changed it and which evidence caused the change.
+4. Let the deterministic reducer count final votes; this pattern does not change quorum counts or the `stop_review_loop` contract.
+
+In Atomic workflows, each invocation has its own Intercom group, and parallel stages and delegated subagents inherit it when Intercom is available. Sibling reviewers can therefore coordinate without custom group wiring. See the [constructive quorum workflow pattern](../../../coding-agent/docs/workflows.md#common-workflow-patterns).
+
 ## Key Differences
 
 | Action | Behavior | Use When |
 |--------|----------|----------|
+| `join` | Joins or creates a named group in place | Two plain chat sessions need a private group |
+| `leave` | Returns to the resolved home group | Restore the session's startup group |
 | `send` | Fire-and-forget | You don't need a response |
 | `ask` | Blocks until reply (10 min timeout) | You need an answer to continue |
 | `reply` | Responds to the active or pending inbound ask; `to` accepts a displayed short ID | You were asked something and need to answer naturally |
 | `pending` | Lists unresolved inbound asks | You need to see who is waiting before replying |
-| `list` | Returns all sessions with actionable short IDs and live status | You need to discover targets or choose an idle peer |
-| `status` | Returns your connection state | Troubleshooting |
+| `list` | Returns all sessions in the current group with actionable short IDs and live status | You need to discover targets or choose an idle peer |
+| `status` | Returns your connection state and current group | Troubleshooting |
 
 Inside workflows, `ask` may target a sibling stage that has already completed. If that stage retains a valid conversation, Atomic automatically schedules a post-mortem turn there and preserves the exact child-to-child reply thread; do not send a separate workflow follow-up. Missing, deleted, non-resumable, or failed-to-reopen completed targets return an actionable error. A parent or unrelated session cannot satisfy the pending ask.
 

package/dist/builtin/intercom/source-ownership.ts

@@ -1,11 +1,6 @@
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import { type SubagentChildPolicy } from "@bastani/atomic";
 import type { Message } from "./types.js";
 
-const ENV_PREFIX = APP_NAME.toUpperCase();
-const SUBAGENT_RUN_ID_ENV = `${ENV_PREFIX}_SUBAGENT_RUN_ID`;
-const SUBAGENT_CHILD_AGENT_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_AGENT`;
-const SUBAGENT_CHILD_INDEX_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_INDEX`;
-
 export function buildSubagentMessageSource(
   runIdValue: string | undefined,
   agentValue: string | undefined,
@@ -25,10 +20,12 @@ export function buildSubagentMessageSource(
   };
 }
 
-export function readSubagentMessageSource(): Message["source"] | undefined {
-  return buildSubagentMessageSource(
-    getEnvValue(SUBAGENT_RUN_ID_ENV),
-    getEnvValue(SUBAGENT_CHILD_AGENT_ENV),
-    getEnvValue(SUBAGENT_CHILD_INDEX_ENV),
-  );
+export function readSubagentMessageSource(policy?: SubagentChildPolicy): Message["source"] | undefined {
+	const identity = policy?.intercom;
+	if (!identity) return undefined;
+	return {
+		subagentRunId: identity.runId,
+		subagentAgent: identity.agent,
+		subagentIndex: identity.index,
+	};
 }

package/dist/builtin/intercom/subagent-relay.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
+import { isStaleExtensionContextError, type ExtensionAPI, type ExtensionContext } from "@bastani/atomic";
 import { randomUUID } from "crypto";
 import type { IntercomClient } from "./broker/client.js";
 import type { SessionInfo, Message } from "./types.js";
@@ -92,7 +92,11 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         },
       };
       Object.defineProperty(payload, "terminalOwner", { value: pi });
-      pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+      try {
+        pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+      } catch (error) {
+        if (!isStaleExtensionContextError(error) || dispatched) throw error;
+      }
       emitGlobalTerminalOrderingBarrier(payload);
       completion = (payload as typeof payload & { completion?: Promise<void> }).completion;
     }
@@ -108,13 +112,25 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
       timestamp: Date.now(),
     });
   }
+  function recordSubagentDeliveryErrorSafely(entryType: string, to: string, message: string, error: unknown): void {
+    try {
+      recordSubagentDeliveryError(entryType, to, message, error);
+    } catch (recordError) {
+      console.error("Failed to record local subagent relay error:", recordError);
+    }
+  }
   function emitResultDelivery(requestId: string | undefined, delivered: boolean, error?: unknown): void {
     if (!requestId) return;
-    pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
-      requestId,
-      delivered,
-      ...(error ? { error: getErrorMessage(error) } : {}),
-    });
+    try {
+      pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
+        requestId,
+        delivered,
+        ...(error ? { error: getErrorMessage(error) } : {}),
+      });
+    } catch (emitError) {
+      if (!isStaleExtensionContextError(emitError)) throw emitError;
+      // Delivery acknowledgements are best effort after a runtime replacement.
+    }
   }
   function acknowledgeResult(options: { acknowledge?: boolean }, requestId: string | undefined, delivered: boolean, error?: unknown): void {
     if (options.acknowledge) emitResultDelivery(requestId, delivered, error);
@@ -155,11 +171,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
       }
       acknowledgeResult(options, parsed.requestId, true);
     } catch (error) {
-      try {
-        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
-      } catch (recordError) {
-        console.error("Failed to record local subagent relay error:", recordError);
-      }
+      recordSubagentDeliveryErrorSafely(options.errorEntryType, parsed.to, parsed.message, error);
       try {
         acknowledgeResult(options, parsed.requestId, false, error);
       } catch (ackError) {
@@ -209,7 +221,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
           acknowledgeResult(options, parsed.requestId, false, error);
           return;
         }
-        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+        recordSubagentDeliveryErrorSafely(options.errorEntryType, parsed.to, parsed.message, error);
         acknowledgeResult(options, parsed.requestId, false, error);
         return;
       }
@@ -234,7 +246,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         }
         if (!result.delivered) {
           const error = new Error(result.reason ?? "Session may not exist or has disconnected.");
-          recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+          recordSubagentDeliveryErrorSafely(options.errorEntryType, parsed.to, parsed.message, error);
           acknowledgeResult(options, parsed.requestId, false, error);
           return;
         }
@@ -244,10 +256,14 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
           acknowledgeResult(options, parsed.requestId, false, error);
           return;
         }
-        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+        recordSubagentDeliveryErrorSafely(options.errorEntryType, parsed.to, parsed.message, error);
         acknowledgeResult(options, parsed.requestId, false, error);
       }
-    })();
+    })().catch((error) => {
+      if (!isStaleExtensionContextError(error)) {
+        console.error("Subagent intercom relay failed:", error);
+      }
+    });
   }
   pi.events.on(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, (payload) => {
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;

package/dist/builtin/intercom/terminal-ordering-barrier.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@bastani/atomic";
+import { isStaleExtensionContextError, type ExtensionAPI } from "@bastani/atomic";
 import { SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, type InboundMessageEntry } from "./intercom-utils.js";
 import type { InboundIdleQueue } from "./inbound-idle-queue.js";
 
@@ -163,6 +163,9 @@ export function registerTerminalOrderingBarrier(
         dispatched = barrier.dispatch(claim.entries.map(options.toMessage));
         dispatchedAsync = isPromiseLike(dispatched);
       } catch (error) {
+        // Owned producers follow the event path with the global fallback. Keep the failed
+        // ownership visible so the fallback observes it instead of dispatching twice.
+        if (barrier.owner) envelope.completion = ownership.promise;
         claim.rollbackFrom(terminalRollbackIndex(error, 0));
         failOwnership(error);
         throw error;
@@ -184,6 +187,9 @@ export function registerTerminalOrderingBarrier(
         delivered = options.deliver(claim.entries[index]!, "prelude");
         deliveredAsync = isPromiseLike(delivered);
       } catch (error) {
+        // Owned producers follow the event path with the global fallback. Keep the failed
+        // ownership visible so the fallback observes it instead of dispatching twice.
+        if (barrier.owner) envelope.completion = ownership.promise;
         claim.rollbackFrom(index);
         failOwnership(error);
         throw error;
@@ -207,16 +213,27 @@ export function registerTerminalOrderingBarrier(
     finish();
   };
   const globals = globalThis as Record<string, unknown>;
-  const registry = globalBarrierRegistry();
   const registration = { handle, isCurrent: () => options.isCurrent?.() !== false };
+  let unsubscribe: () => void;
+  try {
+    unsubscribe = pi.events.on(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, handle);
+  } catch (error) {
+    if (!isStaleExtensionContextError(error)) throw error;
+    return () => {};
+  }
+  const registry = globalBarrierRegistry();
   registry.push(registration);
   globals[GLOBAL_BARRIER_HANDLER] = emitGlobalTerminalOrderingBarrier;
-  const unsubscribe = pi.events.on(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, handle);
   let registered = true;
   return () => {
     if (!registered) return;
     registered = false;
-    unsubscribe();
+    try {
+      unsubscribe();
+    } catch (error) {
+      if (!isStaleExtensionContextError(error)) throw error;
+      // Stale event-bus cleanup is best effort.
+    }
     const index = registry.indexOf(registration);
     if (index >= 0) registry.splice(index, 1);
     if (registry.length === 0) {

package/dist/builtin/intercom/types.ts

@@ -48,7 +48,7 @@ export type ClientMessage =
   | { type: "list"; requestId: string; group?: string }
   | { type: "authorize_supervisor"; requestId: string; childName: string; capability?: string }
   | { type: "send" | "supervisor_send"; to: string; message: Message; attemptId?: string }
-  | { type: "presence"; name?: string; status?: string; model?: string };
+  | { type: "presence"; name?: string; status?: string; model?: string; group?: string; requestId?: string };
 
 export type BrokerMessage =
   | { type: "registered"; sessionId: string; supervisorSessionId?: string }
@@ -59,6 +59,8 @@ export type BrokerMessage =
   | { type: "presence_update"; session: SessionInfo }
   | { type: "session_joined"; session: SessionInfo }
   | { type: "session_left"; sessionId: string }
+  | { type: "presence_ack"; requestId: string; group: string }
+  | { type: "presence_failed"; requestId: string; reason: string }
   | { type: "error"; error: string }
   | { type: "delivered"; messageId: string; attemptId?: string }
   | { type: "delivery_failed"; messageId: string; reason: string; attemptId?: string };