@bastani/atomic 0.8.25-alpha.1 → 0.8.26-alpha.1

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.8.25-alpha.1",
+  "version": "0.8.26-alpha.1",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/intercom/result-renderers.ts

@@ -0,0 +1,77 @@
+import type { ToolDefinition } from "@bastani/atomic";
+import { Text } from "@mariozechner/pi-tui";
+
+type ToolResultRenderer = NonNullable<ToolDefinition["renderResult"]>;
+type ToolRenderResultArgs = Parameters<ToolResultRenderer>;
+type ToolRenderResult = ReturnType<ToolResultRenderer>;
+type RenderedResult = ToolRenderResultArgs[0];
+type TextContentBlock = Extract<RenderedResult["content"][number], { type: "text" }>;
+
+type IntercomResultDetails = {
+	delivered?: boolean;
+	error?: boolean;
+	messageId?: string;
+	reason?: string;
+};
+
+type ContactSupervisorResultDetails = IntercomResultDetails & {
+	structuredReplyParseError?: string;
+};
+
+function isTextContentBlock(block: RenderedResult["content"][number]): block is TextContentBlock {
+	return block.type === "text";
+}
+
+function firstTextContent(result: RenderedResult): string {
+	return result.content.find(isTextContentBlock)?.text.replace(/\*\*/g, "") ?? "";
+}
+
+export const renderContactSupervisorResult: ToolResultRenderer = (result, { isPartial }, theme, context) => {
+	if (isPartial) {
+		return new Text(theme.fg("warning", "Waiting for supervisor..."), 0, 0);
+	}
+	const details = result.details as ContactSupervisorResultDetails | undefined;
+	const textContent = firstTextContent(result);
+	const failed = Boolean(context.isError || details?.error === true || details?.delivered === false);
+	const parseWarning = typeof details?.structuredReplyParseError === "string";
+	let text = failed
+		? theme.fg("error", "✗ ")
+		: parseWarning
+			? theme.fg("warning", "⚠ ")
+			: theme.fg("success", "✓ ");
+	text += theme.fg(failed ? "error" : "text", textContent);
+	if (parseWarning) {
+		text += "\n" + theme.fg("warning", `Structured reply parse issue: ${details.structuredReplyParseError}`);
+	}
+	return new Text(text, 0, 0);
+};
+
+export const renderIntercomResult: ToolResultRenderer = (result, { isPartial }, theme, context) => {
+	if (isPartial) {
+		return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
+	}
+	const details = result.details as IntercomResultDetails | undefined;
+	const failed = Boolean(context.isError || details?.error === true || details?.delivered === false);
+	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)})`);
+	}
+	if (details?.reason && context.expanded) {
+		text += "\n" + theme.fg("dim", `Reason: ${details.reason}`);
+	}
+	return new Text(text, 0, 0);
+};
+
+export function renderIntercomToolResult(name: string, args: ToolRenderResultArgs): ToolRenderResult {
+	switch (name) {
+		case "intercom":
+			return renderIntercomResult(...args);
+		case "contact_supervisor":
+			return renderContactSupervisorResult(...args);
+		default: {
+			const theme = args[2];
+			return new Text(theme.fg("error", `Result renderer not found: ${name}`), 0, 0);
+		}
+	}
+}

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.26-alpha.1] - 2026-06-05
+
+### Changed
+
+- Kept MCP startup registration cheap by lazily importing the heavy MCP command, initialization, proxy-mode, and OAuth/auth-flow modules (and deferring config/cache-backed direct-tool discovery) instead of loading them on the cold extension factory path, while keeping the result renderer synchronous so restored MCP tool results still render ([#1223](https://github.com/bastani-inc/atomic/issues/1223)).
+
+### Fixed
+
+- Stopped logging a spurious "MCP initialization failed: This extension ctx is stale..." error when a session backing the captured `pi`/`ctx` is disposed (e.g. a workflow child stage session) during MCP's deferred `session_start` initialization. The deferred init now liveness-checks the captured context before and after `initializeMcp()` and treats a stale-context error as a cancellation rather than a failure. The async gap that exposed this race was introduced by the lazy-load startup change ([#1223](https://github.com/bastani-inc/atomic/issues/1223)).
+
+## [0.8.25] - 2026-06-04
+
+### Changed
+
+- Promoted the 0.8.25 prerelease package version to a stable release.
+
 ## [0.8.25-alpha.1] - 2026-06-04
 
 ### Changed

package/dist/builtin/mcp/index.ts

@@ -1,20 +1,93 @@
 import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, ToolInfo } from "@bastani/atomic";
 import type { McpExtensionState } from "./state.ts";
+import type { McpConfig } from "./types.ts";
+import type { MetadataCache } from "./metadata-cache.ts";
 import { Type } from "typebox";
-import { showStatus, showTools, reconnectServers, authenticateServer, logoutServer, openMcpAuthPanel, openMcpPanel, openMcpSetup } from "./commands.ts";
 import { loadMcpConfig } from "./config.ts";
-import { buildProxyDescription, createDirectToolExecutor, getMissingConfiguredDirectToolServers, resolveDirectTools } from "./direct-tools.ts";
-import { flushMetadataCache, initializeMcp, updateStatusBar } from "./init.ts";
-import { loadMetadataCache } from "./metadata-cache.ts";
-import { executeCall, executeConnect, executeDescribe, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.ts";
-import { getConfigPathFromArgv, truncateAtWord } from "./utils.ts";
-import { shutdownOAuth } from "./mcp-auth-flow.ts";
+import { getConfigPathFromArgv } from "./utils.ts";
 import { renderMcpToolResult } from "./tool-result-renderer.ts";
 
+/**
+ * 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";
+
+function isStaleExtensionContextError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes(STALE_EXTENSION_CONTEXT_MARKER);
+}
+
+/**
+ * Probe whether a captured extension context is still active. Every `ctx` getter runs
+ * the host's `assertActive()` guard, so a cheap property read surfaces staleness without
+ * mutating anything. Returns false when the context has been invalidated by a dispose.
+ */
+function isContextActive(ctx: ExtensionContext): boolean {
+  try {
+    void ctx.cwd;
+    return true;
+  } catch (error) {
+    if (isStaleExtensionContextError(error)) return false;
+    throw error;
+  }
+}
+
 export default function mcpAdapter(pi: ExtensionAPI) {
   let state: McpExtensionState | null = null;
   let initPromise: Promise<McpExtensionState> | null = null;
   let lifecycleGeneration = 0;
+  let registeredDirectToolNames = new Set<string>();
+  let registeredProxyTool = false;
+
+  async function registerDirectToolsFromConfig(
+    config: McpConfig,
+    cache: MetadataCache | null,
+  ): Promise<{ directToolCount: number; missingConfiguredDirectToolServers: string[] }> {
+    const [{ resolveDirectTools, createDirectToolExecutor, getMissingConfiguredDirectToolServers }, { truncateAtWord }] = await Promise.all([
+      import("./direct-tools.ts"),
+      import("./utils.ts"),
+    ]);
+    const prefix = config.settings?.toolPrefix ?? "server";
+    const envRaw = process.env.MCP_DIRECT_TOOLS;
+    const directSpecs = envRaw === "__none__"
+      ? []
+      : resolveDirectTools(
+          config,
+          cache,
+          prefix,
+          envRaw?.split(",").map(s => s.trim()).filter(Boolean),
+        );
+    for (const spec of directSpecs) {
+      if (registeredDirectToolNames.has(spec.prefixedName)) continue;
+      registeredDirectToolNames.add(spec.prefixedName);
+      (pi.registerTool as (tool: unknown) => unknown)({
+        name: spec.prefixedName,
+        label: `MCP: ${spec.originalName}`,
+        description: spec.description || "(no description)",
+        promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
+        parameters: Type.Unsafe((spec.inputSchema || { type: "object", properties: {} }) as never),
+        execute: createDirectToolExecutor(() => state, () => initPromise, spec),
+        renderResult: renderMcpToolResult,
+      });
+    }
+    const refreshTools = (pi as { refreshTools?: () => void }).refreshTools;
+    refreshTools?.();
+    return {
+      directToolCount: directSpecs.length,
+      missingConfiguredDirectToolServers: getMissingConfiguredDirectToolServers(config, cache),
+    };
+  }
+
+  async function registerDirectTools(nextState: McpExtensionState): Promise<{ directToolCount: number; missingConfiguredDirectToolServers: string[] }> {
+    const { loadMetadataCache } = await import("./metadata-cache.ts");
+    return registerDirectToolsFromConfig(nextState.config, loadMetadataCache());
+  }
+
+  async function shutdownOAuthFlow(): Promise<void> {
+    const { shutdownOAuth } = await import("./mcp-auth-flow.ts");
+    await shutdownOAuth();
+  }
 
   async function shutdownState(currentState: McpExtensionState | null, reason: string): Promise<void> {
     if (!currentState) return;
@@ -26,6 +99,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
 
     let flushError: unknown;
     try {
+      const { flushMetadataCache } = await import("./init.ts");
       flushMetadataCache(currentState);
     } catch (error) {
       flushError = error;
@@ -47,36 +121,6 @@ export default function mcpAdapter(pi: ExtensionAPI) {
   }
 
   const earlyConfigPath = getConfigPathFromArgv();
-  const earlyConfig = loadMcpConfig(earlyConfigPath);
-  const earlyCache = loadMetadataCache();
-  const prefix = earlyConfig.settings?.toolPrefix ?? "server";
-
-  const envRaw = process.env.MCP_DIRECT_TOOLS;
-  const directSpecs = envRaw === "__none__"
-    ? []
-    : resolveDirectTools(
-        earlyConfig,
-        earlyCache,
-        prefix,
-        envRaw?.split(",").map(s => s.trim()).filter(Boolean),
-      );
-  const missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(earlyConfig, earlyCache);
-  const shouldRegisterProxyTool =
-    earlyConfig.settings?.disableProxyTool !== true
-    || directSpecs.length === 0
-    || missingConfiguredDirectToolServers.length > 0;
-
-  for (const spec of directSpecs) {
-    (pi.registerTool as (tool: unknown) => unknown)({
-      name: spec.prefixedName,
-      label: `MCP: ${spec.originalName}`,
-      description: spec.description || "(no description)",
-      promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
-      parameters: Type.Unsafe((spec.inputSchema || { type: "object", properties: {} }) as never),
-      execute: createDirectToolExecutor(() => state, () => initPromise, spec),
-      renderResult: renderMcpToolResult,
-    });
-  }
 
   const getPiTools = (): ToolInfo[] => pi.getAllTools();
 
@@ -90,45 +134,89 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     const previousState = state;
     state = null;
     initPromise = null;
+    registeredDirectToolNames = new Set<string>();
 
     try {
-      await Promise.all([
-        shutdownState(previousState, "session_restart"),
-        shutdownOAuth(),
-      ]);
+      const config = loadMcpConfig(earlyConfigPath, ctx.cwd);
+      const { loadMetadataCache } = await import("./metadata-cache.ts");
+      const directToolState = await registerDirectToolsFromConfig(config, loadMetadataCache());
+      if (
+        config.settings?.disableProxyTool !== true
+        || directToolState.directToolCount === 0
+        || directToolState.missingConfiguredDirectToolServers.length > 0
+      ) {
+        registerProxyTool();
+      }
     } catch (error) {
-      console.error("MCP: failed to shut down previous session state", error);
+      if (isStaleExtensionContextError(error)) return;
+      console.error("MCP: failed to register cached startup tools; enabling MCP proxy fallback", error);
+      registerProxyTool();
     }
 
-    if (generation !== lifecycleGeneration) {
-      return;
-    }
+    const promiseRef: { current: Promise<McpExtensionState> | null } = { current: null };
+    const promise = (async () => {
+      try {
+        await Promise.all([
+          shutdownState(previousState, "session_restart"),
+          shutdownOAuthFlow(),
+        ]);
+      } catch (error) {
+        console.error("MCP: failed to shut down previous session state", error);
+      }
 
-    const promise = initializeMcp(pi, ctx);
-    initPromise = promise;
+      if (generation !== lifecycleGeneration || !isContextActive(ctx)) {
+        throw new Error("Stale MCP session initialization cancelled before startup");
+      }
 
-    promise.then(async (nextState) => {
-      if (generation !== lifecycleGeneration || initPromise !== promise) {
+      const { initializeMcp, updateStatusBar } = await import("./init.ts");
+      if (generation !== lifecycleGeneration || !isContextActive(ctx)) {
+        throw new Error("Stale MCP session initialization cancelled before startup");
+      }
+
+      const nextState = await initializeMcp(pi, ctx);
+      if (generation !== lifecycleGeneration || initPromise !== promiseRef.current || !isContextActive(ctx)) {
         try {
           await shutdownState(nextState, "stale_session_start");
         } catch (error) {
           console.error("MCP: failed to clean stale session state", error);
         }
-        return;
+        throw new Error("Stale MCP session initialization cancelled after startup");
       }
 
       state = nextState;
       updateStatusBar(nextState);
-      initPromise = null;
-    }).catch(err => {
+      const directToolState = await registerDirectTools(nextState);
+      if (
+        nextState.config.settings?.disableProxyTool !== true
+        || directToolState.directToolCount === 0
+        || directToolState.missingConfiguredDirectToolServers.length > 0
+      ) {
+        registerProxyTool();
+      }
+      if (initPromise === promiseRef.current) {
+        initPromise = null;
+      }
+      return nextState;
+    })();
+    promiseRef.current = promise;
+    initPromise = promise;
+    promise.catch((err) => {
       if (generation !== lifecycleGeneration) {
         return;
       }
       if (initPromise !== promise && initPromise !== null) {
         return;
       }
-      console.error("MCP initialization failed:", err);
-      initPromise = null;
+      const message = err instanceof Error ? err.message : String(err);
+      if (
+        !message.startsWith("Stale MCP session initialization cancelled") &&
+        !isStaleExtensionContextError(err)
+      ) {
+        console.error("MCP initialization failed:", err);
+      }
+      if (initPromise === promise) {
+        initPromise = null;
+      }
     });
   });
 
@@ -137,11 +225,12 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     const currentState = state;
     state = null;
     initPromise = null;
+    registeredDirectToolNames = new Set<string>();
 
     try {
       await Promise.all([
         shutdownState(currentState, "session_shutdown"),
-        shutdownOAuth(),
+        shutdownOAuthFlow(),
       ]);
     } catch (error) {
       console.error("MCP: session shutdown cleanup failed", error);
@@ -165,6 +254,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         return;
       }
 
+      const { showStatus, showTools, reconnectServers, logoutServer, openMcpPanel, openMcpSetup } = await import("./commands.ts");
       const parts = args?.trim()?.split(/\s+/) ?? [];
       const subcommand = parts[0] ?? "";
       const targetServer = parts[1];
@@ -233,6 +323,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         return;
       }
 
+      const { authenticateServer, openMcpAuthPanel } = await import("./commands.ts");
       if (!serverName) {
         await openMcpAuthPanel(state, pi, ctx, earlyConfigPath);
         return;
@@ -242,11 +333,13 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     },
   });
 
-  if (shouldRegisterProxyTool) {
+  function registerProxyTool(): void {
+    if (registeredProxyTool) return;
+    registeredProxyTool = true;
     (pi.registerTool as (tool: unknown) => unknown)({
       name: "mcp",
       label: "MCP",
-      description: buildProxyDescription(earlyConfig, earlyCache, directSpecs),
+      description: "MCP gateway for connecting to configured MCP servers, searching tools, describing schemas, and calling tools lazily after MCP initialization.",
       promptSnippet: "MCP gateway - connect to MCP servers and call their tools",
       parameters: Type.Object({
         tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
@@ -305,6 +398,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
           };
         }
 
+        const { executeCall, executeConnect, executeDescribe, executeList, executeSearch, executeStatus, executeUiMessages } = await import("./proxy-modes.ts");
         if (params.action === "ui-messages") {
           return executeUiMessages(state);
         }

package/dist/builtin/mcp/package.json

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

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.8.26-alpha.1] - 2026-06-05
+
+### Changed
+
+- Bumped package version for the Atomic 0.8.26-alpha.1 prerelease.
+
+## [0.8.25] - 2026-06-04
+
+### Changed
+
+- Promoted the 0.8.25 prerelease package version to a stable release.
+
 ## [0.8.25-alpha.1] - 2026-06-04
 
 ### Changed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.8.25-alpha.1",
+  "version": "0.8.26-alpha.1",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/web-access/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.26-alpha.1] - 2026-06-05
+
+### Changed
+
+- Deferred heavy search, fetch, curator, summary, provider-probing, and code-search modules until the relevant web-access tool or command is invoked, reducing default CLI startup cost ([#1223](https://github.com/bastani-inc/atomic/issues/1223)).
+
+## [0.8.25] - 2026-06-04
+
+### Changed
+
+- Promoted the 0.8.25 prerelease package version to a stable release.
+
 ## [0.8.25-alpha.1] - 2026-06-04
 
 ### Changed