@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.9

package/dist/builtin/mcp/direct-tools.ts

@@ -72,6 +72,37 @@ async function attemptDirectAutoAuth(
   }
 }
 
+interface DirectToolSelection {
+  readonly servers: ReadonlySet<string>;
+  readonly toolsByServer: ReadonlyMap<string, ReadonlySet<string>>;
+}
+
+function parseDirectToolSelection(items: readonly string[] | undefined): DirectToolSelection {
+  const servers = new Set<string>();
+  const toolsByServer = new Map<string, Set<string>>();
+  for (const rawItem of items ?? []) {
+    const item = rawItem.replace(/\/+$/, "");
+    if (!item) continue;
+    if (!item.includes("/")) {
+      servers.add(item);
+      continue;
+    }
+    const [server, tool] = item.split("/", 2);
+    if (!server) continue;
+    if (!tool) {
+      servers.add(server);
+      continue;
+    }
+    if (!toolsByServer.has(server)) toolsByServer.set(server, new Set());
+    toolsByServer.get(server)!.add(tool);
+  }
+  return { servers, toolsByServer };
+}
+
+function directToolSelectionIncludes(selection: DirectToolSelection, serverName: string): boolean {
+  return selection.servers.has(serverName) || selection.toolsByServer.has(serverName);
+}
+
 export function resolveDirectTools(
   config: McpConfig,
   cache: MetadataCache | null,
@@ -83,24 +114,7 @@ export function resolveDirectTools(
 
   const seenNames = new Set<string>();
 
-  const envServers = new Set<string>();
-  const envTools = new Map<string, Set<string>>();
-  if (envOverride) {
-    for (let item of envOverride) {
-      item = item.replace(/\/+$/, "");
-      if (item.includes("/")) {
-        const [server, tool] = item.split("/", 2);
-        if (server && tool) {
-          if (!envTools.has(server)) envTools.set(server, new Set());
-          envTools.get(server)!.add(tool);
-        } else if (server) {
-          envServers.add(server);
-        }
-      } else if (item) {
-        envServers.add(item);
-      }
-    }
-  }
+  const envSelection = parseDirectToolSelection(envOverride);
 
   const globalDirect = config.settings?.directTools;
 
@@ -111,10 +125,10 @@ export function resolveDirectTools(
     let toolFilter: true | string[] | false = false;
 
     if (envOverride) {
-      if (envServers.has(serverName)) {
+      if (envSelection.servers.has(serverName)) {
         toolFilter = true;
-      } else if (envTools.has(serverName)) {
-        toolFilter = [...envTools.get(serverName)!];
+      } else if (envSelection.toolsByServer.has(serverName)) {
+        toolFilter = [...envSelection.toolsByServer.get(serverName)!];
       }
     } else {
       if (definition.directTools !== undefined) {
@@ -182,14 +196,18 @@ export function resolveDirectTools(
 export function getMissingConfiguredDirectToolServers(
   config: McpConfig,
   cache: MetadataCache | null,
+  envOverride?: readonly string[],
 ): string[] {
   const missing: string[] = [];
   const globalDirect = config.settings?.directTools;
-
+  const envSelection = parseDirectToolSelection(envOverride);
   for (const [serverName, definition] of Object.entries(config.mcpServers)) {
-    const hasDirectTools = definition.directTools !== undefined
+    const hasConfiguredDirectTools = definition.directTools !== undefined
       ? !!definition.directTools
       : !!globalDirect;
+    const hasDirectTools = envOverride
+      ? directToolSelectionIncludes(envSelection, serverName)
+      : hasConfiguredDirectTools;
 
     if (!hasDirectTools) continue;
 

package/dist/builtin/mcp/index.ts

@@ -39,6 +39,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
   let lifecycleGeneration = 0;
   let registeredDirectToolNames = new Set<string>();
   let registeredProxyTool = false;
+  let startupWarmupCancel: (() => void) | null = null;
 
   async function registerDirectToolsFromConfig(
     config: McpConfig,
@@ -50,13 +51,14 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     ]);
     const prefix = config.settings?.toolPrefix ?? "server";
     const envRaw = process.env.MCP_DIRECT_TOOLS;
+    const envDirectTools = envRaw?.split(",").map(s => s.trim()).filter(Boolean);
     const directSpecs = envRaw === "__none__"
       ? []
       : resolveDirectTools(
           config,
           cache,
           prefix,
-          envRaw?.split(",").map(s => s.trim()).filter(Boolean),
+          envDirectTools,
         );
     for (const spec of directSpecs) {
       if (registeredDirectToolNames.has(spec.prefixedName)) continue;
@@ -75,7 +77,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     refreshTools?.();
     return {
       directToolCount: directSpecs.length,
-      missingConfiguredDirectToolServers: getMissingConfiguredDirectToolServers(config, cache),
+      missingConfiguredDirectToolServers: getMissingConfiguredDirectToolServers(config, cache, envDirectTools),
     };
   }
 
@@ -129,12 +131,18 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     type: "string",
   });
 
+  function cancelStartupWarmup(): void {
+    startupWarmupCancel?.();
+    startupWarmupCancel = null;
+  }
+
   pi.on("session_start", async (_event, ctx) => {
     const generation = ++lifecycleGeneration;
     const previousState = state;
     state = null;
     initPromise = null;
     registeredDirectToolNames = new Set<string>();
+    cancelStartupWarmup();
 
     try {
       const config = loadMcpConfig(earlyConfigPath, ctx.cwd);
@@ -168,7 +176,10 @@ export default function mcpAdapter(pi: ExtensionAPI) {
         throw new Error("Stale MCP session initialization cancelled before startup");
       }
 
-      const { initializeMcp, updateStatusBar } = await import("./init.ts");
+      const [{ initializeMcp, updateStatusBar }, { scheduleMcpStartupWarmup }] = await Promise.all([
+        import("./init.ts"),
+        import("./startup-warmup.ts"),
+      ]);
       if (generation !== lifecycleGeneration || !isContextActive(ctx)) {
         throw new Error("Stale MCP session initialization cancelled before startup");
       }
@@ -193,6 +204,21 @@ export default function mcpAdapter(pi: ExtensionAPI) {
       ) {
         registerProxyTool();
       }
+      let cancelWarmup: (() => void) | null = null;
+      const warmup = scheduleMcpStartupWarmup(nextState, {
+        shouldContinue: () => generation === lifecycleGeneration && state === nextState,
+        onDirectToolsChanged: async () => {
+          if (generation !== lifecycleGeneration || state !== nextState) return;
+          await registerDirectTools(nextState);
+        },
+        onSettled: () => {
+          if (generation === lifecycleGeneration && state === nextState && startupWarmupCancel === cancelWarmup) {
+            startupWarmupCancel = null;
+          }
+        },
+      });
+      cancelWarmup = () => warmup.cancel();
+      startupWarmupCancel = cancelWarmup;
       if (initPromise === promiseRef.current) {
         initPromise = null;
       }
@@ -226,6 +252,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
     state = null;
     initPromise = null;
     registeredDirectToolNames = new Set<string>();
+    cancelStartupWarmup();
 
     try {
       await Promise.all([
@@ -409,7 +436,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
           return executeConnect(state, params.connect);
         }
         if (params.describe) {
-          return executeDescribe(state, params.describe);
+          return executeDescribe(state, params.describe, params.server);
         }
         if (params.search) {
           return executeSearch(state, params.search, params.regex, params.server, params.includeSchemas);

package/dist/builtin/mcp/init.ts

@@ -21,7 +21,6 @@ import { buildToolMetadata, totalToolCount } from "./tool-metadata.ts";
 import { UiResourceHandler } from "./ui-resource-handler.ts";
 import { openUrl, parallelLimit } from "./utils.ts";
 import { logger } from "./logger.ts";
-import { getMissingConfiguredDirectToolServers } from "./direct-tools.ts";
 
 const FAILURE_BACKOFF_MS = 60 * 1000;
 
@@ -75,10 +74,7 @@ export async function initializeMcp(
   const cachePath = getMetadataCachePath();
   const cacheFileExists = existsSync(cachePath);
   let cache = loadMetadataCache();
-  let bootstrapAll = false;
-
   if (!cacheFileExists) {
-    bootstrapAll = true;
     saveMetadataCache({ version: 1, servers: {} });
   } else if (!cache) {
     cache = { version: 1, servers: {} };
@@ -105,12 +101,10 @@ export async function initializeMcp(
     }
   }
 
-  const startupServers = bootstrapAll
-    ? serverEntries
-    : serverEntries.filter(([, definition]) => {
-        const mode = definition.lifecycle ?? "lazy";
-        return mode === "keep-alive" || mode === "eager";
-      });
+  const startupServers = serverEntries.filter(([, definition]) => {
+    const mode = definition.lifecycle ?? "lazy";
+    return mode === "keep-alive" || mode === "eager";
+  });
 
   if (ctx.hasUI && startupServers.length > 0) {
     ctx.ui.setStatus("mcp", `MCP: connecting to ${startupServers.length} servers...`);
@@ -160,39 +154,6 @@ export async function initializeMcp(
     ctx.ui.notify(msg, "info");
   }
 
-  const envDirect = process.env.MCP_DIRECT_TOOLS;
-  if (envDirect !== "__none__") {
-    const currentCache = loadMetadataCache();
-    const missingCacheServers = getMissingConfiguredDirectToolServers(config, currentCache);
-
-    if (missingCacheServers.length > 0) {
-      const bootstrapResults = await parallelLimit(
-        missingCacheServers.filter(name => !results.some(r => r.name === name && r.connection)),
-        10,
-        async (name) => {
-          const definition = config.mcpServers[name];
-          try {
-            const connection = await manager.connect(name, definition);
-            if (connection.status === "needs-auth") {
-              return { name, ok: false };
-            }
-            const { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
-            toolMetadata.set(name, metadata);
-            updateMetadataCache(state, name);
-            return { name, ok: true };
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger.debug(`MCP: direct-tools bootstrap failed for ${name}: ${message}`);
-            return { name, ok: false };
-          }
-        },
-      );
-      const bootstrapped = bootstrapResults.filter(r => r.ok).map(r => r.name);
-      if (bootstrapped.length > 0 && ctx.hasUI) {
-        ctx.ui.notify(`MCP: direct tools for ${bootstrapped.join(", ")} will be available after restart`, "info");
-      }
-    }
-  }
 
   lifecycle.setReconnectCallback((serverName) => {
     updateServerMetadata(state, serverName);

package/dist/builtin/mcp/metadata-hydration.ts

@@ -0,0 +1,37 @@
+import type { McpExtensionState } from "./state.ts";
+import { lazyConnect, updateMetadataCache, updateServerMetadata } from "./init.ts";
+import { parallelLimit } from "./utils.ts";
+
+export async function hydrateServerMetadata(
+  state: McpExtensionState,
+  serverName: string,
+): Promise<boolean> {
+  if (state.toolMetadata.has(serverName)) return true;
+  if (!state.config.mcpServers[serverName]) return false;
+
+  const connection = state.manager.getConnection(serverName);
+  if (connection?.status === "connected") {
+    updateServerMetadata(state, serverName);
+    updateMetadataCache(state, serverName);
+    return state.toolMetadata.has(serverName);
+  }
+
+  return lazyConnect(state, serverName);
+}
+
+export async function hydrateMissingMetadata(
+  state: McpExtensionState,
+  options?: { server?: string },
+): Promise<void> {
+  if (options?.server) {
+    await hydrateServerMetadata(state, options.server);
+    return;
+  }
+
+  const missingServers = Object.keys(state.config.mcpServers).filter(
+    (serverName) => !state.toolMetadata.has(serverName),
+  );
+  await parallelLimit(missingServers, 10, async (serverName) => {
+    await hydrateServerMetadata(state, serverName);
+  });
+}

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.5-alpha.7",
+  "version": "0.9.5-alpha.9",
   "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/mcp/proxy-info-modes.ts

@@ -1,9 +1,10 @@
 import type { McpExtensionState } from "./state.ts";
 import type { ToolMetadata } from "./types.ts";
-import { parseUiPromptHandoff } from "./types.ts";
+import { getServerPrefix, parseUiPromptHandoff } from "./types.ts";
 import { getFailureAgeSeconds } from "./init.ts";
 import { findToolByName, formatSchema } from "./tool-metadata.ts";
 import { truncateAtWord } from "./utils.ts";
+import { hydrateMissingMetadata } from "./metadata-hydration.ts";
 import type { ProxyToolResult } from "./proxy-types.ts";
 
 export function executeUiMessages(state: McpExtensionState): ProxyToolResult {
@@ -140,26 +141,73 @@ export function executeStatus(state: McpExtensionState): ProxyToolResult {
   };
 }
 
-export function executeDescribe(state: McpExtensionState, toolName: string): ProxyToolResult {
-  let serverName: string | undefined;
-  let toolMeta: ToolMetadata | undefined;
+function findToolMetadata(
+  state: McpExtensionState,
+  toolName: string,
+  server?: string,
+): { serverName: string; toolMeta: ToolMetadata } | null {
+  for (const [serverName, metadata] of state.toolMetadata.entries()) {
+    if (server && serverName !== server) continue;
+    const toolMeta = findToolByName(metadata, toolName);
+    if (toolMeta) return { serverName, toolMeta };
+  }
+  return null;
+}
 
-  for (const [server, metadata] of state.toolMetadata.entries()) {
-    const found = findToolByName(metadata, toolName);
-    if (found) {
-      serverName = server;
-      toolMeta = found;
-      break;
+function normalizeToolAlias(value: string): string {
+  return value.replace(/-/g, "_");
+}
+
+function prefixHydrationCandidates(state: McpExtensionState, toolName: string): string[] {
+  const prefixMode = state.config.settings?.toolPrefix ?? "server";
+  if (prefixMode === "none") return [];
+  const normalizedToolName = normalizeToolAlias(toolName);
+  return Object.keys(state.config.mcpServers)
+    .map((serverName) => ({ serverName, prefix: normalizeToolAlias(getServerPrefix(serverName, prefixMode)) }))
+    .filter(({ prefix }) => prefix.length > 0 && normalizedToolName.startsWith(`${prefix}_`))
+    .sort((a, b) => b.prefix.length - a.prefix.length)
+    .map(({ serverName }) => serverName);
+}
+
+async function hydrateDescribeMetadata(state: McpExtensionState, toolName: string, server?: string): Promise<void> {
+  if (server) {
+    await hydrateMissingMetadata(state, { server });
+    return;
+  }
+
+  const candidates = prefixHydrationCandidates(state, toolName);
+  if (candidates.length > 0) {
+    for (const candidate of candidates) {
+      await hydrateMissingMetadata(state, { server: candidate });
+      if (findToolMetadata(state, toolName, candidate)) return;
     }
+    return;
+  }
+
+  if (findToolMetadata(state, toolName)) return;
+  await hydrateMissingMetadata(state);
+}
+
+export async function executeDescribe(
+  state: McpExtensionState,
+  toolName: string,
+  server?: string,
+): Promise<ProxyToolResult> {
+  let found = findToolMetadata(state, toolName, server);
+  if (!found) {
+    await hydrateDescribeMetadata(state, toolName, server);
+    found = findToolMetadata(state, toolName, server);
   }
 
-  if (!serverName || !toolMeta) {
+  if (!found) {
     return {
       content: [{ type: "text" as const, text: `Tool "${toolName}" not found. Use mcp({ search: "..." }) to search.` }],
       details: { mode: "describe", error: "tool_not_found", requestedTool: toolName },
     };
   }
 
+  const { serverName, toolMeta } = found;
+
   let text = `${toolMeta.name}\n`;
   text += `Server: ${serverName}\n`;
   if (toolMeta.resourceUri) {
@@ -181,13 +229,13 @@ export function executeDescribe(state: McpExtensionState, toolName: string): Pro
   };
 }
 
-export function executeSearch(
+export async function executeSearch(
   state: McpExtensionState,
   query: string,
   regex?: boolean,
   server?: string,
   includeSchemas?: boolean,
-): ProxyToolResult {
+): Promise<ProxyToolResult> {
   const showSchemas = includeSchemas !== false;
 
   const matches: Array<{ server: string; tool: ToolMetadata }> = [];
@@ -213,6 +261,7 @@ export function executeSearch(
       details: { mode: "search", error: "invalid_pattern", query },
     };
   }
+  await hydrateMissingMetadata(state, { server });
 
   for (const [serverName, metadata] of state.toolMetadata.entries()) {
     if (server && serverName !== server) continue;
@@ -270,7 +319,7 @@ export function executeSearch(
   };
 }
 
-export function executeList(state: McpExtensionState, server: string): ProxyToolResult {
+export async function executeList(state: McpExtensionState, server: string): Promise<ProxyToolResult> {
   if (!state.config.mcpServers[server]) {
     return {
       content: [{ type: "text" as const, text: `Server "${server}" not found. Use mcp({}) to see available servers.` }],
@@ -278,6 +327,10 @@ export function executeList(state: McpExtensionState, server: string): ProxyTool
     };
   }
 
+  if (!state.toolMetadata.has(server)) {
+    await hydrateMissingMetadata(state, { server });
+  }
+
   const metadata = state.toolMetadata.get(server);
   const toolNames = metadata?.map(m => m.name) ?? [];
   const connection = state.manager.getConnection(server);

package/dist/builtin/mcp/startup-warmup.ts

@@ -0,0 +1,98 @@
+import type { McpExtensionState } from "./state.ts";
+import { getMissingConfiguredDirectToolServers } from "./direct-tools.ts";
+import { loadMetadataCache } from "./metadata-cache.ts";
+import { buildToolMetadata } from "./tool-metadata.ts";
+import { parallelLimit } from "./utils.ts";
+import { logger } from "./logger.ts";
+import { updateMetadataCache, updateStatusBar } from "./init.ts";
+
+export interface McpStartupWarmupOptions {
+  shouldContinue?: () => boolean;
+  onDirectToolsChanged?: () => void | Promise<void>;
+  onSettled?: () => void;
+}
+
+export interface McpStartupWarmupHandle {
+  readonly promise: Promise<void>;
+  cancel(): void;
+}
+
+function deferToMacrotask(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+export function scheduleMcpStartupWarmup(
+  state: McpExtensionState,
+  options: McpStartupWarmupOptions = {},
+): McpStartupWarmupHandle {
+  let cancelled = false;
+  const shouldContinue = (): boolean => !cancelled && (options.shouldContinue?.() ?? true);
+
+  const promise = (async () => {
+    await deferToMacrotask();
+    if (!shouldContinue()) return;
+
+    const envDirect = process.env.MCP_DIRECT_TOOLS;
+    if (envDirect === "__none__") return;
+
+    const envDirectTools = envDirect?.split(",").map((item) => item.trim()).filter(Boolean);
+    const missingCacheServers = getMissingConfiguredDirectToolServers(state.config, loadMetadataCache(), envDirectTools)
+      .filter((name) => state.manager.getConnection(name)?.status !== "connected");
+    if (missingCacheServers.length === 0) return;
+
+    const prefix = state.config.settings?.toolPrefix ?? "server";
+    const results = await parallelLimit(missingCacheServers, 10, async (name) => {
+      if (!shouldContinue()) return { name, ok: false };
+      const definition = state.config.mcpServers[name];
+      if (!definition) return { name, ok: false };
+      try {
+        const connection = await state.manager.connect(name, definition);
+        if (!shouldContinue()) {
+          if (state.manager.getConnection(name) === connection) {
+            await state.manager.close(name);
+          }
+          return { name, ok: false };
+        }
+        if (connection.status === "needs-auth") return { name, ok: false };
+        const { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+        state.toolMetadata.set(name, metadata);
+        updateMetadataCache(state, name);
+        return { name, ok: true };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.debug(`MCP: background direct-tools warmup failed for ${name}: ${message}`);
+        return { name, ok: false };
+      }
+    });
+
+    if (!shouldContinue()) return;
+    const warmed = results.filter((result) => result.ok).map((result) => result.name);
+    if (warmed.length === 0) return;
+    updateStatusBar(state);
+    if (!shouldContinue()) return;
+    await options.onDirectToolsChanged?.();
+    if (!shouldContinue()) return;
+    if (state.ui) {
+      state.ui.notify(`MCP: direct tools for ${warmed.join(", ")} are now available`, "info");
+    }
+  })()
+    .catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.debug(`MCP: background startup warmup failed: ${message}`);
+    })
+    .finally(() => {
+      try {
+        options.onSettled?.();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.debug(`MCP: background startup warmup settled callback failed: ${message}`);
+      }
+    });
+
+  return {
+    promise,
+    cancel() {
+      cancelled = true;
+    },
+  };
+}

package/dist/builtin/mcp/tool-result-renderer.ts

@@ -1,7 +1,7 @@
-import type { AgentToolResult, ToolRenderResultOptions } from "@bastani/atomic";
+import { keyText, type AgentToolResult, type ToolRenderResultOptions } from "@bastani/atomic";
 import { Text } from "@earendil-works/pi-tui";
 
-type McpToolResultDetails = Record<string, unknown> & { error?: unknown };
+export type McpToolResultDetails = Record<string, unknown> & { error?: unknown };
 type McpToolContentBlock = AgentToolResult<McpToolResultDetails>["content"][number];
 
 interface RenderTheme {
@@ -58,7 +58,7 @@ export function renderMcpToolResult(
     .map((line) => line === "…" ? theme.fg("muted", line) : theme.fg("toolOutput", line))
     .join("\n");
   const hint = display.truncated && !options.expanded
-    ? `\n${theme.fg("muted", "(CTRL+O Expand)")}`
+    ? `\n${theme.fg("muted", `(${keyText("app.tools.expand")} Expand)`)}`
     : "";
 
   return new Text(`${output}${hint}`, 0, 0);

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.9.5-alpha.9] - 2026-07-09
+
+### Changed
+
+- Improved subagent extension startup by deferring old-run cleanup scans, result watcher startup, and existing-result priming to macrotasks while preserving immediate `subagent` tool and slash-command registration.
+
+### Fixed
+
+- Fixed background async result watching on Windows to use Atomic's safe watcher path strategy and fall back to polling when native `fs.watch` would receive an unsafe or non-canonical watcher path.
+- Fixed async/background subagent status visibility while the fullscreen workflow graph is active by publishing the live async summary through the shared status surface in addition to the below-editor widget.
+- Fixed foreground and background subagent startup diagnostics so missing or invalid child `cwd` values are reported as working-directory problems before spawn, while runtime spawn failures include the attempted command and cwd instead of ambiguous `ENOENT` output.
+
+## [0.9.5-alpha.8] - 2026-07-08
+
+### Fixed
+
+- Updated async/background subagent status widgets so running job, parallel child-agent, chain-step, and nested child rows reuse the same foreground pulsing-dot glyph treatment instead of braille spinner glyphs, while preserving counts, metadata, live-detail hints, and output paths.
+
 ## [0.9.5-alpha.5] - 2026-07-06
 
 ### Changed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.5-alpha.7",
+  "version": "0.9.5-alpha.9",
   "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": [