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

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,20 +52,26 @@ 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')",
+        description: "Exact session name or exact full session ID (for 'send', 'ask', or targeted 'reply')",
       })),
       message: Type.Optional(Type.String({
         description: "Message to send (for 'send', 'ask', or 'reply' action)",
@@ -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

@@ -345,9 +345,6 @@ export function duplicateSessionNames(sessions: SessionInfo[]): Set<string> {
       .filter((name, index, names) => names.indexOf(name) !== index)
   );
 }
-function shortSessionId(sessionId: string): string {
-  return sessionId.slice(0, 8);
-}
 export function parseSubagentIntercomPayload(payload: unknown): { to: string; message: string; requestId?: string } | null {
   if (typeof payload !== "object" || payload === null) {
     return null;
@@ -394,7 +391,7 @@ export function resolveIntercomPresenceName(sessionName: string | undefined, ses
     return trimmedName;
   }
   const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-  return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
+  return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId}`;
 }
 export function buildPresenceIdentity(pi: ExtensionAPI, sessionId: string): { name: string } {
   return {
@@ -406,7 +403,7 @@ export function formatSessionLabel(session: SessionInfo, duplicates: Set<string>
     return session.id;
   }
   return duplicates.has(session.name.toLowerCase())
-    ? `${session.name} (${shortSessionId(session.id)})`
+    ? `${session.name} (${session.id})`
     : session.name;
 }
 export function formatSessionListRow(session: SessionInfo, currentCwd: string, isSelf: boolean): string {
@@ -416,7 +413,7 @@ export function formatSessionListRow(session: SessionInfo, currentCwd: string, i
   const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, groupTag]
     .filter((tag): tag is string => Boolean(tag));
   const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
-  return `• ${name} (${shortSessionId(session.id)}) — ${session.cwd} (${session.model})${suffix}`;
+  return `• ${name} (${session.id}) — ${session.cwd} (${session.model})${suffix}`;
 }
 export function previewText(value: unknown, maxLength = 72): string | undefined {
   if (typeof value !== "string") {

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.13-alpha.1",
+  "version": "0.9.13-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": [
@@ -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/result-renderers.ts

@@ -55,7 +55,7 @@ export const renderIntercomResult: ToolResultRenderer = (result, { isPartial },
 	let text = failed ? theme.fg("error", "✗ ") : theme.fg("success", "✓ ");
 	text += theme.fg(failed ? "error" : "text", firstTextContent(result));
 	if (details?.messageId && !context.expanded) {
-		text += theme.fg("dim", ` (${details.messageId.slice(0, 8)})`);
+		text += theme.fg("dim", ` (${details.messageId})`);
 	}
 	if (details?.reason && context.expanded) {
 		text += "\n" + theme.fg("dim", `Reason: ${details.reason}`);

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/session-target.ts

@@ -3,10 +3,9 @@ import type { SessionInfo } from "./types.js";
 export type SessionTargetResolution =
   | { kind: "resolved"; session: SessionInfo }
   | { kind: "ambiguous_name"; matches: readonly SessionInfo[] }
-  | { kind: "ambiguous_prefix"; matches: readonly SessionInfo[] }
   | { kind: "not_found" };
 
-/** Resolve an Intercom session by exact ID, exact case-insensitive name, or unique ID prefix. */
+/** Resolve an Intercom session by exact ID or exact case-insensitive name. */
 export function resolveSessionTarget(
   sessions: readonly SessionInfo[],
   nameOrId: string,
@@ -26,13 +25,6 @@ export function resolveSessionTarget(
     return { kind: "ambiguous_name", matches: exactNames };
   }
 
-  const prefixedIds = sessions.filter((session) => session.id.startsWith(target));
-  if (prefixedIds.length === 1) {
-    return { kind: "resolved", session: prefixedIds[0]! };
-  }
-  if (prefixedIds.length > 1) {
-    return { kind: "ambiguous_prefix", matches: prefixedIds };
-  }
   return { kind: "not_found" };
 }
 
@@ -43,12 +35,6 @@ export function sessionTargetFailureReason(
   if (resolution.kind === "ambiguous_name") {
     return `Multiple sessions named "${target}" are connected. Use the session ID instead.`;
   }
-  if (resolution.kind === "ambiguous_prefix") {
-    const labels = resolution.matches
-      .map((session) => `${session.name ?? "Unnamed session"} (${session.id})`)
-      .join(", ");
-    return `Ambiguous session ID prefix "${target}" matches: ${labels}. Use a longer ID or an exact session name.`;
-  }
   return "Session not found";
 }
 

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

@@ -67,15 +67,30 @@ intercom({
 
 ### Pattern 2: Quick Status Check
 
-Before sending, verify who's connected. The short ID printed by `list` is directly usable by `send`, `ask`, and targeted `reply`:
+Before sending, verify who's connected. The full session ID printed by `list` is directly usable by `send`, `ask`, and targeted `reply`:
 
 ```typescript
 intercom({ action: "list" })
-// → • planner (6332faab) — /workspace (model) [idle]
-intercom({ action: "ask", to: "6332faab", message: "Which option should I use?" })
+// → • planner (6332faab-1111-4222-8333-123456789abc) — /workspace (model) [idle]
+intercom({ action: "ask", to: "6332faab-1111-4222-8333-123456789abc", 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.
+Intercom accepts only an exact full session ID or an exact case-insensitive session name. Use the full ID printed by `list` or the session's exact name.
+
+### 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
 
@@ -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 |
+| `reply` | Responds to the active or pending inbound ask; `to` accepts an exact full session ID or exact session name | 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 full session 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/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";
 
@@ -20,7 +20,7 @@ export interface TerminalOrderingBarrier {
   runId: string;
   terminalId: string;
   terminalAt: number;
-  source: "background-notify" | "result-relay";
+  source: "detached-notify" | "result-relay";
   owner?: object;
   sourceSessionTargets: string[];
   dispatch?(prefix: OrderedTerminalPreludeMessage[]): unknown;
@@ -39,7 +39,7 @@ function parseBarrier(value: unknown): TerminalOrderingBarrier | null {
   const record = value as Record<string, unknown>;
   if (typeof record.runId !== "string" || !record.runId) return null;
   if (typeof record.terminalAt !== "number" || !Number.isFinite(record.terminalAt)) return null;
-  if (record.source !== "background-notify" && record.source !== "result-relay") return null;
+  if (record.source !== "detached-notify" && record.source !== "result-relay") return null;
   if (!Array.isArray(record.sourceSessionTargets)) return null;
   const sourceSessionTargets = record.sourceSessionTargets
     .filter((target): target is string => typeof target === "string")
@@ -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 };

package/dist/builtin/intercom/ui/compose.ts

@@ -60,35 +60,37 @@ export class ComposeOverlay implements Component {
 
   invalidate(): void {}
 
-  handleInput(data: string): void {
-    if (this.sending) return;
+  handleInput(data: string): boolean {
+    if (this.sending) return false;
     if (this.keybindings.matches(data, "tui.select.cancel")) {
       this.done({ sent: false });
-      return;
+      return true;
     }
 
     if (data.startsWith("\x1b")) {
-      return;
+      return false;
     }
 
     if (this.keybindings.matches(data, "tui.select.confirm")) {
       if (this.inputBuffer.trim()) {
         this.sendMessage();
       }
-      return;
+      return true;
     }
 
     if (this.keybindings.matches(data, "tui.editor.deleteCharBackward")) {
       this.inputBuffer = [...this.inputBuffer].slice(0, -1).join("");
       this.tui.requestRender();
-      return;
+      return true;
     }
 
     const printable = [...data].filter(c => c >= " ").join("");
     if (printable) {
       this.inputBuffer += printable;
       this.tui.requestRender();
+      return true;
     }
+    return false;
   }
 
   private async sendMessage(): Promise<void> {

package/dist/builtin/intercom/ui/inline-message.ts

@@ -24,13 +24,14 @@ export class InlineMessageComponent implements Component {
     const lines: string[] = [];
     const borderChar = "─";
     if (width < 3) {
-      return [truncateToWidth(`From ${this.from.name || this.from.id.slice(0, 8)}`, width)];
+      return [truncateToWidth(`From ${this.from.name || this.from.id}`, width)];
     }
     const bodyWidth = Math.max(1, width - 2);
 
-    const senderName = this.from.name || this.from.id.slice(0, 8);
+    const senderName = this.from.name || this.from.id;
     const header = ` 📨 From: ${senderName} (${this.from.cwd}) `;
-    const headerText = truncateToWidth(header, bodyWidth, "");
+    // An empty ellipsis silently clips full sender IDs; keep header overflow visible.
+    const headerText = truncateToWidth(header, bodyWidth, "…");
     const headerPadding = Math.max(0, bodyWidth - visibleWidth(headerText));
     lines.push(this.theme.fg("accent", `╭${headerText}${borderChar.repeat(headerPadding)}╮`));
 
@@ -63,8 +64,9 @@ export class InlineMessageComponent implements Component {
 
     if (this.message.replyTo && !this.message.expectsReply) {
       lines.push(this.theme.fg("accent", `│${" ".repeat(bodyWidth)}│`));
-      const reply = this.theme.fg("dim", ` ↳ Reply to ${this.message.replyTo.slice(0, 8)}`);
-      const text = truncateToWidth(reply, bodyWidth, "");
+      // An empty ellipsis silently clips full reply-to IDs; keep overflow visible.
+      const reply = this.theme.fg("dim", ` ↳ Reply to ${this.message.replyTo}`);
+      const text = truncateToWidth(reply, bodyWidth, "…");
       const padding = Math.max(0, bodyWidth - visibleWidth(text));
       lines.push(this.theme.fg("accent", `│${text}${" ".repeat(padding)}│`));
     }