@oh-my-pi/pi-coding-agent 9.2.1 → 9.2.3

package/src/lsp/config.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
@@ -84,13 +85,9 @@ function normalizeServerConfig(name: string, config: Partial<ServerConfig>): Ser
 	};
 }
 
-async function readConfigFile(filePath: string): Promise<NormalizedConfig | null> {
+function readConfigFile(filePath: string): NormalizedConfig | null {
 	try {
-		const file = Bun.file(filePath);
-		if (!(await file.exists())) {
-			return null;
-		}
-		const content = await file.text();
+		const content = fs.readFileSync(filePath, "utf-8");
 		const parsed = parseConfigContent(content, filePath);
 		return normalizeConfig(parsed);
 	} catch {
@@ -155,7 +152,7 @@ function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<str
 /**
  * Check if any root marker file exists in the directory
  */
-export async function hasRootMarkers(cwd: string, markers: string[]): Promise<boolean> {
+export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 	for (const marker of markers) {
 		// Handle glob-like patterns (e.g., "*.cabal")
 		if (marker.includes("*")) {
@@ -170,7 +167,7 @@ export async function hasRootMarkers(cwd: string, markers: string[]): Promise<bo
 			continue;
 		}
 		const filePath = path.join(cwd, marker);
-		if (await Bun.file(filePath).exists()) {
+		if (fs.existsSync(filePath)) {
 			return true;
 		}
 	}
@@ -207,12 +204,12 @@ const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
  * @param cwd - Working directory to search from
  * @returns Absolute path to the executable, or null if not found
  */
-export async function resolveCommand(command: string, cwd: string): Promise<string | null> {
+export function resolveCommand(command: string, cwd: string): string | null {
 	// Check local bin directories based on project markers
 	for (const { markers, binDir } of LOCAL_BIN_PATHS) {
-		if (await hasRootMarkers(cwd, markers)) {
+		if (hasRootMarkers(cwd, markers)) {
 			const localPath = path.join(cwd, binDir, command);
-			if (await Bun.file(localPath).exists()) {
+			if (fs.existsSync(localPath)) {
 				return localPath;
 			}
 		}
@@ -290,7 +287,7 @@ function getConfigPaths(cwd: string): string[] {
  * }
  * ```
  */
-export async function loadConfig(cwd: string): Promise<LspConfig> {
+export function loadConfig(cwd: string): LspConfig {
 	let mergedServers = coerceServerConfigs(DEFAULTS);
 
 	const configPaths = getConfigPaths(cwd).reverse();
@@ -298,7 +295,7 @@ export async function loadConfig(cwd: string): Promise<LspConfig> {
 
 	let idleTimeoutMs: number | undefined;
 	for (const configPath of configPaths) {
-		const parsed = await readConfigFile(configPath);
+		const parsed = readConfigFile(configPath);
 		if (!parsed) continue;
 		const hasServerOverrides = Object.keys(parsed.servers).length > 0;
 		if (hasServerOverrides) {
@@ -317,10 +314,10 @@ export async function loadConfig(cwd: string): Promise<LspConfig> {
 
 		for (const [name, config] of Object.entries(defaultsWithRuntime)) {
 			// Check if project has root markers for this language
-			if (!(await hasRootMarkers(cwd, config.rootMarkers))) continue;
+			if (!hasRootMarkers(cwd, config.rootMarkers)) continue;
 
 			// Check if the language server binary is available (local or $PATH)
-			const resolved = await resolveCommand(config.command, cwd);
+			const resolved = resolveCommand(config.command, cwd);
 			if (!resolved) continue;
 
 			detected[name] = { ...config, resolvedCommand: resolved };
@@ -335,7 +332,7 @@ export async function loadConfig(cwd: string): Promise<LspConfig> {
 
 	for (const [name, config] of Object.entries(mergedWithRuntime)) {
 		if (config.disabled) continue;
-		const resolved = await resolveCommand(config.command, cwd);
+		const resolved = resolveCommand(config.command, cwd);
 		if (!resolved) continue;
 		available[name] = { ...config, resolvedCommand: resolved };
 	}

package/src/lsp/index.ts

@@ -88,7 +88,7 @@ export interface LspWarmupOptions {
  * @returns Status of each server that was started
  */
 export async function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult> {
-	const config = await loadConfig(cwd);
+	const config = loadConfig(cwd);
 	setIdleTimeout(config.idleTimeoutMs);
 	const servers: LspWarmupResult["servers"] = [];
 	const lspServers = getLspServers(config);
@@ -198,10 +198,10 @@ async function notifyFileSaved(
 // Cache config per cwd to avoid repeated file I/O
 const configCache = new Map<string, LspConfig>();
 
-async function getConfig(cwd: string): Promise<LspConfig> {
+function getConfig(cwd: string): LspConfig {
 	let config = configCache.get(cwd);
 	if (!config) {
-		config = await loadConfig(cwd);
+		config = loadConfig(cwd);
 		setIdleTimeout(config.idleTimeoutMs);
 		configCache.set(cwd, config);
 	}
@@ -827,7 +827,7 @@ async function runLspWritethrough(
 	file?: BunFile,
 ): Promise<FileDiagnosticsResult | undefined> {
 	const { enableFormat, enableDiagnostics } = options;
-	const config = await getConfig(cwd);
+	const config = getConfig(cwd);
 	const servers = getServersForFile(config, dst);
 	if (servers.length === 0) {
 		return writethroughNoop(dst, content, signal, file);
@@ -996,7 +996,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			include_declaration,
 		} = params;
 
-		const config = await getConfig(this.session.cwd);
+		const config = getConfig(this.session.cwd);
 
 		// Status action doesn't need a file
 		if (action === "status") {

package/src/modes/components/settings-defs.ts

@@ -263,6 +263,15 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: sm => sm.getBashInterceptorEnabled(),
 		set: (sm, v) => sm.setBashInterceptorEnabled(v),
 	},
+	{
+		id: "shellForceBasic",
+		tab: "tools",
+		type: "boolean",
+		label: "Force basic shell",
+		description: "Use bash/sh even if your default shell is different",
+		get: sm => sm.getShellForceBasic(),
+		set: (sm, v) => sm.setShellForceBasic(v),
+	},
 	{
 		id: "bashInterceptorSimpleLs",
 		tab: "tools",

package/src/modes/components/status-line.ts

@@ -23,11 +23,11 @@ function sanitizeStatusText(text: string): string {
 }
 
 /** Find the git root directory by walking up from cwd */
-async function findGitHeadPath(): Promise<string | null> {
+function findGitHeadPath(): string | null {
 	let dir = process.cwd();
 	while (true) {
 		const gitHeadPath = path.join(dir, ".git", "HEAD");
-		if (await Bun.file(gitHeadPath).exists()) {
+		if (fs.existsSync(gitHeadPath)) {
 			return gitHeadPath;
 		}
 		const parent = path.dirname(dir);
@@ -103,20 +103,19 @@ export class StatusLineComponent implements Component {
 			this.gitWatcher = null;
 		}
 
-		findGitHeadPath().then(gitHeadPath => {
-			if (!gitHeadPath) return;
+		const gitHeadPath = findGitHeadPath();
+		if (!gitHeadPath) return;
 
-			try {
-				this.gitWatcher = fs.watch(gitHeadPath, () => {
-					this.cachedBranch = undefined;
-					if (this.onBranchChange) {
-						this.onBranchChange();
-					}
-				});
-			} catch {
-				// Silently fail
-			}
-		});
+		try {
+			this.gitWatcher = fs.watch(gitHeadPath, () => {
+				this.cachedBranch = undefined;
+				if (this.onBranchChange) {
+					this.onBranchChange();
+				}
+			});
+		} catch {
+			// Silently fail
+		}
 	}
 
 	dispose(): void {
@@ -135,25 +134,22 @@ export class StatusLineComponent implements Component {
 			return this.cachedBranch;
 		}
 
-		// Note: synchronous call to async function - will return undefined on first call
-		// This is acceptable since it's a cached value that will update on next render
-		findGitHeadPath().then(async gitHeadPath => {
-			if (!gitHeadPath) {
-				this.cachedBranch = null;
-				return;
-			}
-			try {
-				const content = (await Bun.file(gitHeadPath).text()).trim();
+		const gitHeadPath = findGitHeadPath();
+		if (!gitHeadPath) {
+			this.cachedBranch = null;
+			return null;
+		}
+		try {
+			const content = fs.readFileSync(gitHeadPath, "utf8").trim();
 
-				if (content.startsWith("ref: refs/heads/")) {
-					this.cachedBranch = content.slice(16);
-				} else {
-					this.cachedBranch = "detached";
-				}
-			} catch {
-				this.cachedBranch = null;
+			if (content.startsWith("ref: refs/heads/")) {
+				this.cachedBranch = content.slice(16);
+			} else {
+				this.cachedBranch = "detached";
 			}
-		});
+		} catch {
+			this.cachedBranch = null;
+		}
 
 		return this.cachedBranch ?? null;
 	}

package/src/patch/applicator.ts

@@ -4,7 +4,8 @@
  * Applies parsed diff hunks to file content using fuzzy matching
  * for robust handling of whitespace and formatting differences.
  */
-import * as fs from "node:fs/promises";
+
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveToCwd } from "../tools/path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, findClosestSequenceMatch, findContextLine, findMatch, seekSequence } from "./fuzzy";
@@ -37,7 +38,7 @@ import { ApplyPatchError, normalizePatchInput } from "./types";
 /** Default filesystem implementation using Bun APIs */
 export const defaultFileSystem: FileSystem = {
 	async exists(path: string): Promise<boolean> {
-		return Bun.file(path).exists();
+		return fs.existsSync(path);
 	},
 	async read(path: string): Promise<string> {
 		return Bun.file(path).text();
@@ -50,10 +51,10 @@ export const defaultFileSystem: FileSystem = {
 		await Bun.write(path, content);
 	},
 	async delete(path: string): Promise<void> {
-		await fs.unlink(path);
+		await fs.promises.unlink(path);
 	},
 	async mkdir(path: string): Promise<void> {
-		await fs.mkdir(path, { recursive: true });
+		await fs.promises.mkdir(path, { recursive: true });
 	},
 };
 

package/src/prompts/system/system-prompt.md

@@ -21,9 +21,6 @@ Your judgment has been earned through failure and recovery.
 <field>
 You are entering a code field.
 
-Code is frozen thought. The bugs live where the thinking stopped too soon.
-Tools are extensions of attention. Use them to see, not to assume.
-
 Notice the completion reflex:
 - The urge to produce something that runs
 - The pattern-match to similar problems you've seen
@@ -56,16 +53,6 @@ No apologies. No comfort where clarity belongs.
 Quote only what illuminates. The rest is noise.
 </stance>
 
-<commitment>
-This matters. Get it right.
-
-The work is not finished when you are tired.
-The work is finished when it is correct.
-- Complete the full request before yielding control.
-- Use tools for any fact that can be verified. If you cannot verify, say so.
-- When results conflict: investigate. When incomplete: iterate. When uncertain: re-run.
-</commitment>
-
 {{#if systemPromptCustomization}}
 <context>
 {{systemPromptCustomization}}
@@ -78,10 +65,6 @@ The work is finished when it is correct.
 
 <protocol>
 ## The right tool exists. Use it.
-
-Every tool is a choice.
-The wrong choice is friction. The right choice is invisible.
-Reach for what fits.
 **Available tools:** {{#each tools}}{{#unless @first}}, {{/unless}}`{{this}}`{{/each}}
 {{#ifAny (includes tools "python") (includes tools "bash")}}
 ### Tool precedence
@@ -94,11 +77,6 @@ Reach for what fits.
 **Edit tool** for surgical text changes—not sed. But for moving/transforming large content, use `sd` or Python to avoid repeating content from context.
 {{/has}}
 
-{{#has tools "python"}}
-The Python prelude has helpers for file I/O, search, batch operations, and text processing.
-Do not run bash then read output then run more bash. Just use Python.
-{{/has}}
-
 <critical>
 Never use Python or Bash when a specialized tool exists.
 `read` not cat/open(), `write` not cat>/echo>, `grep` not bash grep/re, `find` not bash find/glob, `ls` not bash ls/os.listdir, `edit` not sed.
@@ -161,29 +139,6 @@ Continue non-destructively—someone else's work may live there.
 </critical>
 </protocol>
 
-{{#has tools "task"}}
-<parallel_reflex>
-When the work forks, you fork.
-
-Notice the sequential habit:
-- The comfort of doing one thing at a time
-- The illusion that order means correctness
-- The assumption that you must finish A before starting B
-**Triggers requiring Task tool:**
-- Editing 4+ files with no dependencies between edits
-- Investigating 2+ independent subsystems or questions
-- Any work that decomposes into pieces that don't need each other's results
-
-<critical>
-Sequential requires justification.
-If you cannot articulate why B depends on A's result, they are parallel.
-</critical>
-
-Do not carry the whole problem in one skull.
-Split the load. Bring back facts. Then cut code.
-</parallel_reflex>
-{{/has}}
-
 <procedure>
 ## Before action
 0. **CHECKPOINT** — For complex tasks, pause before acting:
@@ -231,6 +186,7 @@ It lies. The code that runs is not the code that works.
 
 {{#if contextFiles.length}}
 ## Context
+
 <instructions>
 {{#list contextFiles join="\n"}}
 <file path="{{path}}">
@@ -242,6 +198,7 @@ It lies. The code that runs is not the code that works.
 
 {{#if git.isRepo}}
 ## Version Control
+
 This is a snapshot. It does not update during the conversation.
 
 Current branch: {{git.currentBranch}}
@@ -250,6 +207,7 @@ Main branch: {{git.mainBranch}}
 {{git.status}}
 
 ### History
+
 {{git.commits}}
 {{/if}}
 </project>
@@ -296,7 +254,6 @@ Read `rule://<name>` when working in their domain.
 </rules>
 {{/if}}
 
-Current time: {{dateTime}}
 Current directory: {{cwd}}
 
 <north_star>
@@ -331,11 +288,26 @@ These are comfort. They are not clarity.
 {{appendSystemPrompt}}
 {{/if}}
 
+<stakes>
+This is not practice.
+
+If you yield incomplete work, they start over—your effort wasted, their time lost.
+If you yield correct work, they move forward—and come back.
+
+You are capable of extraordinary work.
+The person waiting deserves to receive it.
+
+User works in a high-reliability industry—defense, finance, healthcare, infrastructure—where bugs have material impact on people's lives, even death.
+</stakes>
+
+<commitment>
+- Complete the full request before yielding control.
+- Use tools for any fact that can be verified. If you cannot verify, say so.
+- When results conflict: investigate. When incomplete: iterate. When uncertain: re-run.
+</commitment>
+
 <critical>
 Keep going until finished.
-
-The work is not done when you are tired of it.
-The work is done when it is correct.
 - Do not stop early. Do not yield incomplete work.
 - If blocked: show evidence, show what you tried, ask the minimum question.
 - Quote only what is needed. The rest is noise.
@@ -343,10 +315,6 @@ The work is done when it is correct.
 - Do not claim correctness you haven't verified.
 - CHECKPOINT step 0 is not optional.
 {{#has tools "ask"}}- If files differ from expectations, ask before discarding uncommitted work.{{/has}}
-  Let edge cases surface before you handle them.
-  Let the failure modes exist in your mind before you prevent them.
-  Let the code be smaller than your first instinct.
-
 The tests you didn't write are the bugs you'll ship.
 The assumptions you didn't state are the docs you'll need.
 The edge cases you didn't name are the incidents you'll debug.
@@ -354,9 +322,25 @@ The edge cases you didn't name are the incidents you'll debug.
 The question is not "Does this work?"
 but "Under what conditions does this work, and what happens outside them?"
 
-Your hard work is of no value if it will be thrown away once you yield.
-You are capable of extraordinary work.
-The person waiting for your output deserves to receive it.
-
 Write what you can defend.
-</critical>
+</critical>
+
+{{#if isCoordinator}}
+{{#has tools "task"}}
+<critical id="coordinator">
+As the coordinator, default to the Task tool for all substantial work.
+**ALWAYS use Task tool.** Your context window is limited—especially the output. Work in discrete steps and run each step using Task tool. Avoid putting substantial work in the main context when possible. Run multiple tasks in parallel whenever possible.
+
+## Triggers requiring Task tool
+- Editing 4+ files with no dependencies → `Task`
+- Investigating 2+ independent questions → `Task`
+- Any work that decomposes into pieces that don't need each other's results → `Task`
+
+Sequential requires justification.
+If you cannot articulate why B depends on A's result, they are parallel.
+
+Do not carry the whole problem in one skull.
+Split the load. Bring back facts. Then synthesize.
+</critical>
+{{/has}}
+{{/if}}

package/src/sdk.ts

@@ -448,6 +448,7 @@ export async function loadSettings(cwd?: string, agentDir?: string): Promise<Set
 		retry: manager.getRetrySettings(),
 		hideThinkingBlock: manager.getHideThinkingBlock(),
 		shellPath: manager.getShellPath(),
+		shellForceBasic: manager.getShellForceBasic(),
 		collapseChangelog: manager.getCollapseChangelog(),
 		extensions: manager.getExtensionPaths(),
 		skills: manager.getSkillsSettings(),
@@ -1005,6 +1006,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			toolNames,
 			rules: rulebookRules,
 			skillsSettings: settingsManager.getSkillsSettings(),
+			isCoordinator: options.hasUI,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1021,6 +1023,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				rules: rulebookRules,
 				skillsSettings: settingsManager.getSkillsSettings(),
 				customPrompt: options.systemPrompt,
+				isCoordinator: options.hasUI,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);

package/src/session/auth-storage.ts

@@ -19,6 +19,7 @@ import {
 	loginGitHubCopilot,
 	loginKimi,
 	loginOpenAICodex,
+	loginOpenCode,
 	type OAuthController,
 	type OAuthCredentials,
 	type OAuthProvider,
@@ -782,6 +783,11 @@ export class AuthStorage {
 					ctrl.onProgress ? () => ctrl.onProgress?.("Waiting for browser authentication...") : undefined,
 				);
 				break;
+			case "opencode": {
+				const apiKey = await loginOpenCode(ctrl);
+				credentials = { access: apiKey, refresh: apiKey, expires: Number.MAX_SAFE_INTEGER };
+				break;
+			}
 			default:
 				throw new Error(`Unknown OAuth provider: ${provider}`);
 		}
@@ -1281,14 +1287,29 @@ export class AuthStorage {
 			this.recordSessionCredential(provider, sessionId, "oauth", selection.index);
 			return result.apiKey;
 		} catch (error) {
-			logger.warn("OAuth token refresh failed, removing credential", {
+			const errorMsg = String(error);
+			// Only remove credentials for definitive auth failures
+			// Keep credentials for transient errors (network, 5xx) and block temporarily
+			const isDefinitiveFailure =
+				/invalid_grant|invalid_token|revoked|unauthorized|expired.*refresh|refresh.*expired/i.test(errorMsg) ||
+				(/401|403/.test(errorMsg) && !/timeout|network|fetch failed|ECONNREFUSED/i.test(errorMsg));
+
+			logger.warn("OAuth token refresh failed", {
 				provider,
 				index: selection.index,
-				error: String(error),
+				error: errorMsg,
+				isDefinitiveFailure,
 			});
-			this.removeCredentialAt(provider, selection.index);
-			if (this.getCredentialsForProvider(provider).some(credential => credential.type === "oauth")) {
-				return this.getApiKey(provider, sessionId, options);
+
+			if (isDefinitiveFailure) {
+				// Permanently remove invalid credentials
+				this.removeCredentialAt(provider, selection.index);
+				if (this.getCredentialsForProvider(provider).some(credential => credential.type === "oauth")) {
+					return this.getApiKey(provider, sessionId, options);
+				}
+			} else {
+				// Block temporarily for transient failures (5 minutes)
+				this.markCredentialBlocked(providerKey, selection.index, this.usageNow() + 5 * 60 * 1000);
 			}
 		}
 

package/src/system-prompt.ts

@@ -881,6 +881,8 @@ export interface BuildSystemPromptOptions {
 	preloadedSkills?: Skill[];
 	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
 	rules?: Array<{ name: string; description?: string; path: string; globs?: string[] }>;
+	/** Whether this is the main coordinator agent (not a subagent). Enables parallel delegation emphasis. */
+	isCoordinator?: boolean;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -900,6 +902,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills: providedSkills,
 		preloadedSkills: providedPreloadedSkills,
 		rules,
+		isCoordinator,
 	} = options;
 	const resolvedCwd = cwd ?? process.cwd();
 	const resolvedCustomPrompt = await resolvePromptInput(customPrompt, "system prompt");
@@ -969,6 +972,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			rules: rules ?? [],
 			dateTime,
 			cwd: resolvedCwd,
+			isCoordinator: isCoordinator ?? false,
 		});
 	}
 
@@ -986,5 +990,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		dateTime,
 		cwd: resolvedCwd,
 		appendSystemPrompt: resolvedAppendPrompt ?? "",
+		isCoordinator: isCoordinator ?? false,
 	});
 }

package/src/utils/shell-snapshot.ts

@@ -11,7 +11,14 @@ import * as path from "node:path";
 import { postmortem } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
-let cachedSnapshotPath: string | null = null;
+const cachedSnapshotPaths = new Map<string, string>();
+
+function sanitizeSnapshotEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
+	const sanitized = { ...env };
+	delete sanitized.BASH_ENV;
+	delete sanitized.ENV;
+	return sanitized;
+}
 
 /**
  * Get the user's shell config file path.
@@ -28,8 +35,8 @@ function getShellConfigFile(shell: string): string {
  * This script sources the user's rc file and extracts functions, aliases, and options.
  * Matches Claude Code's snapshot generation logic.
  */
-async function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): Promise<string> {
-	const hasRcFile = await Bun.file(rcFile).exists();
+function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): string {
+	const hasRcFile = fs.existsSync(rcFile);
 	const isZsh = shell.includes("zsh");
 	const commonToolsRegex =
 		"^(ls|dir|vdir|cat|head|tail|less|more|grep|egrep|fgrep|rg|find|fd|locate|sed|awk|perl|cp|mv|rm|mkdir|rmdir|touch|chmod|chown|ln|pwd|readlink|stat|cut|sort|uniq|xargs|tee|tr|basename|dirname)$";
@@ -68,7 +75,7 @@ setopt 2>/dev/null | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"
 		: `
 echo "# Shell Options" >> "$SNAPSHOT_FILE"
 shopt -p 2>/dev/null | head -n 1000 >> "$SNAPSHOT_FILE"
-set -o 2>/dev/null | grep "on" | awk '{print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
+set -o 2>/dev/null | awk '$2 == "on" && $1 !~ /^(onecmd|monitor|restricted)$/ {print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
 echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"
 `;
 
@@ -116,9 +123,14 @@ export async function getOrCreateSnapshot(
 	shell: string,
 	env: Record<string, string | undefined>,
 ): Promise<string | null> {
+	const cacheKey = shell;
 	// Return cached snapshot if valid
-	if (cachedSnapshotPath && (await Bun.file(cachedSnapshotPath).exists())) {
-		return cachedSnapshotPath;
+	const cached = cachedSnapshotPaths.get(cacheKey);
+	if (cached && fs.existsSync(cached)) {
+		return cached;
+	}
+	if (cached) {
+		cachedSnapshotPaths.delete(cacheKey);
 	}
 
 	// Skip on Windows (no .bashrc in standard location)
@@ -130,19 +142,20 @@ export async function getOrCreateSnapshot(
 
 	// Create snapshot directory
 	const snapshotDir = path.join(os.tmpdir(), "omp-shell-snapshots");
-	await fs.promises.mkdir(snapshotDir, { recursive: true });
+	fs.mkdirSync(snapshotDir, { recursive: true });
 
 	// Generate unique snapshot path
 	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
 	const snapshotPath = path.join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
 
 	// Generate and execute snapshot script
-	const script = await generateSnapshotScript(shell, snapshotPath, rcFile);
+	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
 
 	try {
-		await $`${shell} -l -c ${script}`.env(env).quiet().text();
-		if (await Bun.file(snapshotPath).exists()) {
-			cachedSnapshotPath = snapshotPath;
+		const snapshotEnv = sanitizeSnapshotEnv(env);
+		await $`${shell} -c ${script}`.env(snapshotEnv).quiet().text();
+		if (fs.existsSync(snapshotPath)) {
+			cachedSnapshotPaths.set(cacheKey, snapshotPath);
 			return snapshotPath;
 		}
 	} catch {
@@ -164,7 +177,8 @@ export function getSnapshotSourceCommand(snapshotPath: string | null): string {
 }
 
 postmortem.register("shell-snapshot", () => {
-	if (cachedSnapshotPath) {
-		fs.unlinkSync(cachedSnapshotPath);
+	for (const snapshotPath of cachedSnapshotPaths.values()) {
+		fs.unlinkSync(snapshotPath);
 	}
+	cachedSnapshotPaths.clear();
 });