@bastani/atomic 0.8.25 → 0.8.26-alpha.2

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.8.25",
+  "version": "0.8.26-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": [

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.2] - 2026-06-05
+
+### Changed
+
+- Bumped package version for the Atomic 0.8.26-alpha.2 prerelease.
+
+## [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

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",
+  "version": "0.8.26-alpha.2",
   "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,19 @@
 
 ## [Unreleased]
 
+## [0.8.26-alpha.2] - 2026-06-05
+
+### Fixed
+
+- Fixed the `no-staged-files` acceptance runtime check and subagent worktree Git commands to ignore ambient Git repository environment variables, so subagents inspect the intended working tree instead of a parent hook or unrelated worktree.
+- Suppressed intermediate model fallback failure notes and live foreground failure updates from successful subagent runs while preserving final failures and raw per-attempt diagnostics ([#1226](https://github.com/bastani-inc/atomic/issues/1226)).
+
+## [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

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.8.25",
+  "version": "0.8.26-alpha.2",
   "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/subagents/src/runs/background/subagent-runner.ts

@@ -650,6 +650,7 @@ async function runSingleStep(
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];
 	const attemptNotes: string[] = [];
+	const pendingAttemptNotes: string[] = [];
 	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
 	let finalResult: RunPiStreamingResult | undefined;
 	let finalFastMode: boolean | undefined;
@@ -768,9 +769,13 @@ async function runSingleStep(
 		finalFastMode = attemptFastMode;
 		finalOutputSnapshot = outputSnapshot;
 		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput } as RunPiStreamingResult & { structuredOutput?: unknown };
-		if (attempt.success || completionGuardTriggered) break;
-		if (!isRetryableModelFailure(error) || index === candidates.length - 1) break;
-		attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
+		if (attempt.success) break;
+		if (!completionGuardTriggered && isRetryableModelFailure(error) && index < candidates.length - 1) {
+			pendingAttemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
+			continue;
+		}
+		attemptNotes.push(...pendingAttemptNotes);
+		break;
 	}
 
 	const rawOutput = finalResult?.finalOutput ?? "";

package/dist/builtin/subagents/src/runs/foreground/execution.ts

@@ -17,6 +17,7 @@ import {
 	type AgentProgress,
 	type ArtifactPaths,
 	type ControlEvent,
+	type Details,
 	type ModelAttempt,
 	type RunSyncOptions,
 	type SingleResult,
@@ -139,6 +140,29 @@ function snapshotResult(result: SingleResult, progress: AgentProgress): SingleRe
 	};
 }
 
+type RunSyncUpdate = import("@earendil-works/pi-agent-core").AgentToolResult<Details>;
+
+function extractUpdateText(update: RunSyncUpdate): string | undefined {
+	const text = update.content
+		.map((item) => item.type === "text" ? item.text : undefined)
+		.filter((item): item is string => Boolean(item?.trim()))
+		.join("\n");
+	return text || undefined;
+}
+
+export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
+	const result = update.details?.results?.[0];
+	if (!result) return false;
+	const progress = update.details?.progress?.[0];
+	const status = result.progress?.status ?? progress?.status;
+	if (status !== "failed") return false;
+	const failureText = result.error
+		?? result.progress?.error
+		?? progress?.error
+		?? extractUpdateText(update);
+	return isRetryableModelFailure(failureText);
+}
+
 async function runSingleAttempt(
 	runtimeCwd: string,
 	agent: AgentConfig,
@@ -875,6 +899,7 @@ export async function runSync(
 	const modelAttempts: ModelAttempt[] = [];
 	const aggregateUsage = emptyUsage();
 	const attemptNotes: string[] = [];
+	const pendingAttemptNotes: string[] = [];
 	let totalToolCount = 0;
 	let totalDurationMs = 0;
 
@@ -897,7 +922,18 @@ export async function runSync(
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
 		const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-		const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, options, {
+		let attemptOptions = options;
+		if (i < modelsToTry.length - 1 && options.onUpdate) {
+			const forwardUpdate = options.onUpdate;
+			attemptOptions = {
+				...options,
+				onUpdate: (update) => {
+					if (shouldSuppressIntermediateRetryableFailureUpdate(update)) return;
+					forwardUpdate(update);
+				},
+			};
+		}
+		const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, attemptOptions, {
 			sessionEnabled,
 			systemPrompt,
 			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
@@ -928,10 +964,12 @@ export async function runSync(
 		if (attemptSucceeded) {
 			break;
 		}
-		if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {
-			break;
+		if (isRetryableModelFailure(result.error) && i < modelsToTry.length - 1) {
+			pendingAttemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
+			continue;
 		}
-		attemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
+		attemptNotes.push(...pendingAttemptNotes);
+		break;
 	}
 
 	const result = lastResult ?? {

package/dist/builtin/subagents/src/runs/shared/acceptance.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { createGitEnvironment } from "@bastani/atomic";
 import type {
 	AcceptanceConfig,
 	AcceptanceEvidenceKind,
@@ -399,7 +400,7 @@ function reportEvidencePresent(report: AcceptanceReport, kind: AcceptanceEvidenc
 }
 
 function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
-	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+	const result = spawnSync("git", ["status", "--short"], { cwd, env: createGitEnvironment(), encoding: "utf-8" });
 	if (result.status !== 0) {
 		return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
 	}

package/dist/builtin/subagents/src/runs/shared/worktree.ts

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { APP_NAME } from "@bastani/atomic";
+import { APP_NAME, createGitEnvironment } from "@bastani/atomic";
 
 export interface WorktreeSetup {
 	cwd: string;
@@ -82,7 +82,7 @@ interface RepoState {
 const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 
 function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", env: createGitEnvironment() });
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",

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.2] - 2026-06-05
+
+### Changed
+
+- Bumped package version for the Atomic 0.8.26-alpha.2 prerelease.
+
+## [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