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

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/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.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/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 };

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

@@ -90,32 +90,34 @@ export class SessionListOverlay implements Component {
 
   invalidate(): void {}
 
-  handleInput(data: string): void {
+  handleInput(data: string): boolean {
     if (this.keybindings.matches(data, "tui.select.cancel")) {
       this.done(undefined);
-      return;
+      return true;
     }
 
     if (this.sessions.length === 0) {
-      return;
+      return false;
     }
 
     if (this.keybindings.matches(data, "tui.select.up")) {
       this.selectedIndex = this.selectedIndex === 0 ? this.sessions.length - 1 : this.selectedIndex - 1;
-      return;
+      return true;
     }
 
     if (this.keybindings.matches(data, "tui.select.down")) {
       this.selectedIndex = this.selectedIndex === this.sessions.length - 1 ? 0 : this.selectedIndex + 1;
-      return;
+      return true;
     }
 
     if (this.keybindings.matches(data, "tui.select.confirm")) {
       const session = this.sessions[this.selectedIndex];
       if (session) {
         this.onSessionSelect(session.id);
+        return true;
       }
     }
+    return false;
   }
 
   render(width: number): string[] {

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.13-alpha.2] - 2026-08-12
+
+### Changed
+
+- MCP server processes and npm/Glimpse resolver probes now receive `AI_AGENT=atomic` for generic child-process attribution; the reserved marker overrides a configured `AI_AGENT` value.
+
+### Fixed
+
+- Fixed image blocks returned by MCP tools bypassing the host's `images.autoResize` processing before they enter session history.
+- Fixed deferred MCP initialization's stale-context check by consuming the host's exported predicate instead of copying its error-message marker.
+
+- Restored credential-resolved endpoints for MCP sampling requests, so GitHub Copilot Business and Enterprise accounts keep their own endpoint alongside dynamic API keys and request headers ([#7579](https://github.com/earendil-works/pi/issues/7579)).
+
 ## [0.9.13-alpha.1] - 2026-08-05
 
 ### Changed

package/dist/builtin/mcp/glimpse-ui.ts

@@ -3,6 +3,7 @@ import { execFileSync } from "node:child_process";
 import { join, dirname } from "node:path";
 import { platform } from "node:os";
 import { createRequire } from "node:module";
+import { createChildProcessEnvironment } from "@bastani/atomic";
 
 let glimpseAvailable: boolean | null = null;
 let resolvedBinaryPath: string | null = null;
@@ -35,7 +36,7 @@ function getGlimpseBinaryPath(): string | null {
 
   // Global npm install
   try {
-    const globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
+    const globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8", env: createChildProcessEnvironment() }).trim();
     const binaryPath = join(globalRoot, "glimpseui", "src", "glimpse");
     if (existsSync(binaryPath)) return binaryPath;
   } catch {}

package/dist/builtin/mcp/index.ts

@@ -1,4 +1,4 @@
-import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, SubagentChildPolicy, ToolInfo } from "@bastani/atomic";
+import { isStaleExtensionContextError, type AgentToolUpdateCallback, type ExtensionAPI, type ExtensionContext, type SubagentChildPolicy, type ToolInfo } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.js";
 import type { McpConfig } from "./types.ts";
 import type { MetadataCache } from "./metadata-cache.js";
@@ -12,12 +12,6 @@ import { loadMcpConfig } from "./config.ts";
 import { getConfigPathFromArgv } from "./utils.js";
 import { renderMcpToolResult } from "./tool-result-renderer.js";
 
-/**
- * Marker substring from the host's stale-context error (see ExtensionRunner.invalidate).
- * A captured `pi`/`ctx` becomes stale when its backing session is disposed (e.g. a
- * workflow child stage session, or a reload/replace) without emitting `session_shutdown`.
- */
-const STALE_EXTENSION_CONTEXT_MARKER = "extension ctx is stale";
 const STALE_INITIALIZATION_PREFIX = "Stale MCP session initialization cancelled";
 
 interface ActiveMcpSession {
@@ -26,10 +20,6 @@ interface ActiveMcpSession {
   readonly cleanup: Promise<void>;
 }
 
-function isStaleExtensionContextError(error: unknown): boolean {
-  return error instanceof Error && error.message.includes(STALE_EXTENSION_CONTEXT_MARKER);
-}
-
 /** Probe the host guard to determine whether a captured context remains active. */
 function isContextActive(ctx: ExtensionContext): boolean {
   try {