@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/tools/bash.ts

@@ -30,6 +30,11 @@ import {
 	truncateHeadBytes,
 	truncateTailBytes,
 } from "../session/streaming-output";
+import {
+	lookupOwnedRegistration,
+	registerOwnedIfLineaged,
+	unregisterOwnedRegistration,
+} from "../session/terminal-abort";
 
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock, getOutputBlockContentWidth } from "../tui/output-block";
@@ -42,6 +47,7 @@ import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-intera
 import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
 import { expandInternalUrls, type InternalUrlExpansionOptions } from "./bash-skill-urls";
+import { longSleepAdvisory } from "./bash-sleep-advisory";
 import { checkComposerBashPolicy } from "./composer-bash-policy";
 import {
 	formatArtifactReference,
@@ -598,6 +604,23 @@ function formatTimeoutClampNotice(requestedTimeoutSec: number, effectiveTimeoutS
  *
  * Executes bash commands with optional timeout and working directory.
  */
+/** Remove the owned registration of a FOREGROUND bash job whose delivery was
+ *  synchronously acknowledged: the tuple is settled and must not occupy the
+ *  registry, otherwise old retained policies are treated as occupied and the
+ *  tombstone FIFO fallback can evict a genuinely live work's policy (review
+ *  thread P2). */
+function unregisterForegroundOwnedBash(
+	manager: { getJob?(id: string): { generation?: string } | undefined },
+	jobId: string,
+	endpointId?: string,
+): void {
+	const generation = manager.getJob?.(jobId)?.generation;
+	if (!generation) return;
+	// The endpoint disambiguates concurrent sessions' same job ids (review P1).
+	const registration = lookupOwnedRegistration(jobId, generation, endpointId);
+	if (registration) unregisterOwnedRegistration(registration);
+}
+
 export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	readonly name = "bash";
 	readonly label = "Bash";
@@ -751,8 +774,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		resolvedEnv?: Record<string, string>;
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>;
 		startBackgrounded: boolean;
+		/** Immutable attempt-scoped tool call id, when executed via a tool call. */
+		toolCallId?: string;
 	}): ManagedBashJobHandle {
-		const manager = AsyncJobManager.instance();
+		const manager = this.#resolveOwnedJobManager();
 		if (!manager) {
 			throw new ToolError("Background job manager unavailable for this session.");
 		}
@@ -840,6 +865,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				},
 			},
 		);
+		registerOwnedIfLineaged(manager, options.toolCallId, jobId, this.session.getSessionId?.() ?? undefined);
 
 		return {
 			jobId,
@@ -852,6 +878,24 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		};
 	}
 
+	/**
+	 * The session's ENDPOINT-owned AsyncJobManager, falling back to the
+	 * process-global instance. Concurrent top-level sessions each register
+	 * their manager under their endpoint (sdk/session.ts), so a job created
+	 * by THIS session must be stored in THIS session's manager — otherwise a
+	 * Bash launched by session A lands in the last-created session B's
+	 * manager while registering as A-owned, an A scope:"owned" abort then
+	 * consults A's endpoint manager and cannot cancel the actual job, and a
+	 * later missing-job settlement can retire the tuple while the job keeps
+	 * running (review thread P1).
+	 */
+	#resolveOwnedJobManager(): AsyncJobManager | undefined {
+		const endpointId = this.session.getSessionId?.() ?? undefined;
+		return (
+			this.session.getAsyncJobManager?.() ?? AsyncJobManager.forEndpoint(endpointId) ?? AsyncJobManager.instance()
+		);
+	}
+
 	async #waitForManagedBashJob(
 		job: ManagedBashJobHandle,
 		thresholdMs: number,
@@ -1024,12 +1068,28 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					),
 				)
 			: undefined;
+		// Spawned workflow commands must resolve the SESSION's agent
+		// profile: the child's getAgentDir() reads GJC_CODING_AGENT_DIR at
+		// module load. Injected per-command (session-scoped), never
+		// mutating the host process; an explicit tool-call env wins. The
+		// session's REQUESTED directory (getSessionAgentDir) takes
+		// precedence over the global Settings singleton, which may belong
+		// to an earlier session.
+		const sessionAgentDir = this.session.getSessionAgentDir?.() ?? this.session.settings?.getAgentDir?.();
+		// An EXPLICIT tool-call env that supplies either supported spelling of
+		// the agent-directory override wins over the session injection: the
+		// child's getAgentDir() prefers GJC_CODING_AGENT_DIR, so injecting it
+		// while the caller only set the legacy PI_CODING_AGENT_DIR alias would
+		// silently ignore the caller's override.
+		const explicitAgentDirOverride =
+			expandedEnv?.GJC_CODING_AGENT_DIR !== undefined || expandedEnv?.PI_CODING_AGENT_DIR !== undefined;
 		const resolvedEnv = {
 			...buildGjcRuntimeSessionEnv({
 				sessionFile: null,
 				sessionId: this.session.getSessionId?.(),
 				cwd: this.session.cwd,
 			}),
+			...(sessionAgentDir && !explicitAgentDirOverride ? { GJC_CODING_AGENT_DIR: sessionAgentDir } : {}),
 			...expandedEnv,
 			...(this.session.bashRestrictionProfile === "read-only" ? READ_ONLY_BASH_ENV : {}),
 			...(allowedPrefixes && allowedPrefixes.length > 0 ? { [GJC_RESTRICTED_ROLE_AGENT_BASH_ENV]: "1" } : {}),
@@ -1059,6 +1119,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const notices: string[] = [];
 		const timeoutClampNotice = formatTimeoutClampNotice(requestedTimeoutSec, timeoutSec);
 		if (timeoutClampNotice) notices.push(timeoutClampNotice);
+		const sleepAdvisory = longSleepAdvisory(command, timeoutSec);
+		if (sleepAdvisory) notices.push(sleepAdvisory);
 
 		return { command, commandCwd, resolvedEnv, requestedTimeoutSec, timeoutSec, timeoutMs, notices };
 	}
@@ -1078,12 +1140,13 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			ownerId?: string;
 			label?: string;
 			ctx?: AgentToolContext;
+			toolCallId?: string;
 			onRawLine?: (line: string, jobId: string) => void;
 			shouldAcceptRawLine?: (jobId: string) => boolean;
 			lifecycle?: import("../async").AsyncJobLifecycleCleanup;
 		} = {},
 	): Promise<{ jobId: string; label: string; commandCwd: string }> {
-		const manager = AsyncJobManager.instance();
+		const manager = this.#resolveOwnedJobManager();
 		if (!manager) {
 			throw new ToolError("Async job manager unavailable for this session.");
 		}
@@ -1181,12 +1244,16 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			},
 			{ ownerId, metadata: { monitor: true }, lifecycle: opts.lifecycle },
 		);
+		// Monitor jobs are exact owned background work of the turn that started
+		// them: register the five-tuple so scope:"owned" terminal abort stops the
+		// monitor too (review thread P2).
+		registerOwnedIfLineaged(manager, opts.toolCallId, jobId, this.session.getSessionId?.() ?? undefined);
 		currentJobId = jobId;
 		return { jobId, label, commandCwd: prepared.commandCwd };
 	}
 
 	async execute(
-		_toolCallId: string,
+		toolCallId: string,
 		{
 			command: rawCommand,
 			env: rawEnv,
@@ -1222,7 +1289,11 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		} = prepared;
 
 		if (asyncRequested) {
-			if (!AsyncJobManager.instance()) {
+			// Availability is endpoint-first: a concurrent top-level session
+			// that was the process-global instance may have been disposed,
+			// clearing instance() while THIS session's manager stays
+			// registered by endpoint (review thread P1).
+			if (!this.#resolveOwnedJobManager()) {
 				throw new ToolError("Async job manager unavailable for this session.");
 			}
 			const job = this.#startManagedBashJob({
@@ -1236,6 +1307,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				resolvedEnv,
 				onUpdate,
 				startBackgrounded: true,
+				toolCallId,
 			});
 			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
 				requestedTimeoutSec,
@@ -1249,11 +1321,15 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			this.session.bashRestrictionProfile === "read-only" ? undefined : this.session.getClientBridge?.();
 		const clientTerminalActive = Boolean(clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty);
 
-		const autoBgManager = AsyncJobManager.instance();
 		// Run non-PTY bash through the managed job path so Ctrl+B-twice fold-on-demand works
 		// even when auto-background is disabled. When a client terminal will handle the
 		// command, keep the existing bridge path unless auto-background is enabled.
-		if (!pty && autoBgManager && (this.#autoBackgroundEnabled || !clientTerminalActive)) {
+		// The manager is resolved ONCE from the session's endpoint (same instance the
+		// job was created in) and reused for creation, acknowledgement, cancellation,
+		// and unregistering — the process-global instance may belong to a different
+		// concurrent top-level session (review thread P1).
+		const ownedManager = this.#resolveOwnedJobManager();
+		if (!pty && ownedManager && (this.#autoBackgroundEnabled || !clientTerminalActive)) {
 			// With auto-background off, wait past the command's own timeout so the job only
 			// leaves the foreground on an explicit Ctrl+B fold, never on an auto-background timer.
 			const autoBackgroundWaitMs = this.#autoBackgroundEnabled
@@ -1271,6 +1347,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				resolvedEnv,
 				onUpdate,
 				startBackgrounded,
+				toolCallId,
 			});
 			if (startBackgrounded) {
 				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec, {
@@ -1295,17 +1372,20 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				unregisterBackgroundRequest?.();
 			}
 			if (waitResult.kind === "completed") {
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
+				ownedManager.acknowledgeDeliveries([job.jobId]);
+				unregisterForegroundOwnedBash(ownedManager, job.jobId, this.session.getSessionId?.() ?? "local");
 				return waitResult.result;
 			}
 			if (waitResult.kind === "failed") {
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
+				ownedManager.acknowledgeDeliveries([job.jobId]);
+				unregisterForegroundOwnedBash(ownedManager, job.jobId, this.session.getSessionId?.() ?? "local");
 				throw waitResult.error;
 			}
 			if (waitResult.kind === "aborted") {
-				autoBgManager.cancel(job.jobId);
+				ownedManager.cancel(job.jobId);
 				const terminal = await job.completion;
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
+				ownedManager.acknowledgeDeliveries([job.jobId]);
+				unregisterForegroundOwnedBash(ownedManager, job.jobId, this.session.getSessionId?.() ?? "local");
 				if (terminal.kind === "failed") {
 					throw new ToolAbortError(
 						formatManagedAbortFailure(terminal.error, terminal.result, job.getLatestText()),
@@ -1585,20 +1665,20 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					disableShellSnapshot: this.session.bashRestrictionProfile === "read-only",
 				});
 		if (result.cancelled) {
-			const failureText = formatBashFailureMessage(
-				result,
-				normalizeResultOutput(result) || "Command aborted",
-				signal?.aborted ? "Command aborted" : undefined,
-			);
+			const noticeSuffix = pendingNotices.length > 0 ? `\n\n${pendingNotices.join("\n")}` : "";
+			const baseCancelledText = normalizeResultOutput(result) || "Command aborted";
 			if (signal?.aborted) {
-				throw new ToolAbortError(failureText);
+				throw new ToolAbortError(formatBashFailureMessage(result, baseCancelledText, "Command aborted"));
 			}
-			throw new ToolError(failureText);
+			const failureText = `${baseCancelledText}${noticeSuffix}`;
+			throw new ToolError(formatBashFailureMessage(result, failureText));
 		}
 		if (isInteractiveResult(result) && result.timedOut) {
 			const timeoutMessage = `Command timed out after ${timeoutSec} seconds`;
 			const output = normalizeResultOutput(result);
-			const failureText = output ? `${output}\n\n${timeoutMessage}` : timeoutMessage;
+			const noticeSuffix = pendingNotices.length > 0 ? `\n\n${pendingNotices.join("\n")}` : "";
+			const baseText = output ? `${output}\n\n${timeoutMessage}` : timeoutMessage;
+			const failureText = `${baseText}${noticeSuffix}`;
 			throw new ToolError(formatBashFailureMessage(result, failureText, timeoutMessage));
 		}
 		return this.#buildCompletedResult(result, timeoutSec, {

package/src/tools/browser/attach.ts

@@ -1,8 +1,10 @@
+import * as fs from "node:fs/promises";
 import * as net from "node:net";
 import * as path from "node:path";
 import { nativeProcessBindings } from "@gajae-code/utils/native-process";
 import type { Browser, Page } from "puppeteer-core";
 import { ToolError, throwIfAborted } from "../tool-errors";
+import { isChromeProfileExecutable } from "./launch";
 
 const ATTACH_TARGET_SKIP_PATTERN =
 	/request[\s_-]?handler|devtools|background[\s_-]?(?:page|host)|service[\s_-]?worker/i;
@@ -133,8 +135,10 @@ async function probeCdpAt(port: number, signal?: AbortSignal): Promise<boolean>
 	try {
 		const res = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: probeSignal });
 		await res.body?.cancel();
+		throwIfAborted(signal);
 		return res.ok;
 	} catch {
+		throwIfAborted(signal);
 		return false;
 	}
 }
@@ -181,6 +185,7 @@ export async function findReusableCdp(
 		if (await probeCdpAt(port, signal)) {
 			return { cdpUrl: `http://127.0.0.1:${port}`, pid: proc.pid };
 		}
+		throwIfAborted(signal);
 	}
 	return null;
 }
@@ -196,10 +201,64 @@ export async function findRunningChromeProfile(
 	profile: { userDataDir: string; profileDirectory: string },
 	signal?: AbortSignal,
 ): Promise<RunningChromeProfile | null> {
-	const candidates = nativeProcessBindings()
-		.Process.fromPath(exe)
-		.filter(p => p.status() === nativeProcessBindings().ProcessStatus.Running);
+	return findRunningChromeProfileWithOptions(exe, profile, signal, {});
+}
+
+interface ProfileProcessScanOptions {
+	platform?: NodeJS.Platform;
+	linuxPids?: readonly number[];
+	linuxExecutablePaths?: ReadonlyMap<number, string>;
+	signal?: AbortSignal;
+}
+
+async function liveLinuxPids(): Promise<number[]> {
+	try {
+		const entries = await fs.readdir("/proc", { withFileTypes: true });
+		return entries
+			.filter(entry => entry.isDirectory() && /^\d+$/.test(entry.name))
+			.map(entry => Number.parseInt(entry.name, 10));
+	} catch {
+		return [];
+	}
+}
+
+async function linuxExecutablePath(pid: number, options: ProfileProcessScanOptions): Promise<string | null> {
+	const injected = options.linuxExecutablePaths?.get(pid);
+	if (injected) return injected;
+	try {
+		return await fs.readlink(`/proc/${pid}/exe`);
+	} catch {
+		return null;
+	}
+}
+
+async function findRunningChromeProfileWithOptions(
+	exe: string,
+	profile: { userDataDir: string; profileDirectory: string },
+	signal: AbortSignal | undefined,
+	options: ProfileProcessScanOptions,
+): Promise<RunningChromeProfile | null> {
+	const bindings = nativeProcessBindings();
+	const candidates = bindings.Process.fromPath(exe).filter(p => p.status() === bindings.ProcessStatus.Running);
+	const seenPids = new Set(candidates.map(candidate => candidate.pid));
+	if ((options.platform ?? process.platform) === "linux" && candidates.length === 0) {
+		throwIfAborted(signal);
+		const linuxPids = options.linuxPids ?? (await liveLinuxPids());
+		throwIfAborted(signal);
+		for (const pid of linuxPids) {
+			throwIfAborted(signal);
+			if (seenPids.has(pid)) continue;
+			const candidate = bindings.Process.fromPid(pid);
+			if (!candidate || candidate.status() !== bindings.ProcessStatus.Running) continue;
+			const executablePath = await linuxExecutablePath(pid, options);
+			throwIfAborted(signal);
+			if (!executablePath || !isChromeProfileExecutable(executablePath)) continue;
+			seenPids.add(pid);
+			candidates.push(candidate);
+		}
+	}
 	for (const proc of candidates) {
+		throwIfAborted(signal);
 		let args: string[];
 		try {
 			args = proc.args();
@@ -216,12 +275,21 @@ export async function findRunningChromeProfile(
 			if (await probeCdpAt(port, signal)) {
 				return { pid: proc.pid, cdpUrl: `http://127.0.0.1:${port}` };
 			}
+			throwIfAborted(signal);
 		}
 		return { pid: proc.pid, cdpUrl: null };
 	}
 	return null;
 }
 
+export function findRunningChromeProfileForTest(
+	exe: string,
+	profile: { userDataDir: string; profileDirectory: string },
+	options: ProfileProcessScanOptions,
+): Promise<RunningChromeProfile | null> {
+	return findRunningChromeProfileWithOptions(exe, profile, options.signal, options);
+}
+
 /**
  * Pick the best page target on an attached browser. Without a matcher, prefer
  * a page that doesn't look like a helper window (devtools, request handler,

package/src/tools/browser/launch.ts

@@ -108,12 +108,18 @@ export function resolveBrowserEnvOverridesForTest(): {
 	proxy: string | undefined;
 	proxyBypassLoopback: boolean;
 	ignoreCertErrors: boolean;
+	programFiles: string | undefined;
+	programFilesX86: string | undefined;
+	localAppData: string | undefined;
 } {
 	return {
 		executablePath: trustedBrowserEnv("PUPPETEER_EXECUTABLE_PATH"),
 		proxy: trustedBrowserEnv("PUPPETEER_PROXY"),
 		proxyBypassLoopback: browserLaunchFlagEnabled("PUPPETEER_PROXY_BYPASS_LOOPBACK"),
 		ignoreCertErrors: browserLaunchFlagEnabled("PUPPETEER_PROXY_IGNORE_CERT_ERRORS"),
+		programFiles: trustedBrowserEnv("ProgramFiles"),
+		programFilesX86: trustedBrowserEnv("ProgramFiles(x86)"),
+		localAppData: trustedBrowserEnv("LOCALAPPDATA"),
 	};
 }
 
@@ -208,7 +214,16 @@ function systemChromiumCandidates(): string[] {
 			break;
 		}
 		case "linux": {
-			const names = ["google-chrome-stable", "google-chrome", "chromium", "chromium-browser", "chrome"];
+			const names = [
+				"google-chrome-stable",
+				"google-chrome",
+				"google-chrome-beta",
+				"google-chrome-unstable",
+				"google-chrome-canary",
+				"chromium",
+				"chromium-browser",
+				"chrome",
+			];
 			for (const name of names) {
 				const found = $which(name);
 				if (found) candidates.push(found);
@@ -216,6 +231,9 @@ function systemChromiumCandidates(): string[] {
 			candidates.push(
 				"/usr/bin/google-chrome-stable",
 				"/usr/bin/google-chrome",
+				"/usr/bin/google-chrome-beta",
+				"/usr/bin/google-chrome-unstable",
+				"/usr/bin/google-chrome-canary",
 				"/usr/bin/chromium",
 				"/usr/bin/chromium-browser",
 				"/snap/bin/chromium",
@@ -232,13 +250,20 @@ function systemChromiumCandidates(): string[] {
 			break;
 		}
 		case "win32": {
-			const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
-			const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-			const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData\\Local");
+			const programFiles = trustedBrowserEnv("ProgramFiles") ?? "C:\\Program Files";
+			const programFilesX86 = trustedBrowserEnv("ProgramFiles(x86)") ?? "C:\\Program Files (x86)";
+			const localAppData = trustedBrowserEnv("LOCALAPPDATA") ?? path.join(home, "AppData\\Local");
 			candidates.push(
 				path.join(programFiles, "Google\\Chrome\\Application\\chrome.exe"),
 				path.join(programFilesX86, "Google\\Chrome\\Application\\chrome.exe"),
 				path.join(localAppData, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(programFiles, "Google\\Chrome Beta\\Application\\chrome.exe"),
+				path.join(programFilesX86, "Google\\Chrome Beta\\Application\\chrome.exe"),
+				path.join(localAppData, "Google\\Chrome Beta\\Application\\chrome.exe"),
+				path.join(programFiles, "Google\\Chrome Dev\\Application\\chrome.exe"),
+				path.join(programFilesX86, "Google\\Chrome Dev\\Application\\chrome.exe"),
+				path.join(localAppData, "Google\\Chrome Dev\\Application\\chrome.exe"),
+				path.join(localAppData, "Google\\Chrome SxS\\Application\\chrome.exe"),
 				path.join(programFiles, "Chromium\\Application\\chrome.exe"),
 				path.join(localAppData, "Chromium\\Application\\chrome.exe"),
 				path.join(programFiles, "Microsoft\\Edge\\Application\\msedge.exe"),
@@ -250,22 +275,70 @@ function systemChromiumCandidates(): string[] {
 	return candidates;
 }
 
-function resolveSystemChromium(): string | undefined {
-	if (resolvedChromium !== undefined) return resolvedChromium ?? undefined;
+function firstExecutableCandidate(candidates: string[], accept: (candidate: string) => boolean): string | undefined {
 	const seen = new Set<string>();
-	for (const candidate of systemChromiumCandidates()) {
+	for (const candidate of candidates) {
 		if (!candidate || seen.has(candidate)) continue;
 		seen.add(candidate);
-		if (isExecutableFile(candidate)) {
-			resolvedChromium = candidate;
-			logger.debug("Using system Chrome/Chromium", { path: candidate });
-			return candidate;
-		}
+		if (accept(candidate) && isExecutableFile(candidate)) return candidate;
 	}
-	resolvedChromium = null;
 	return undefined;
 }
 
+function resolveSystemChromium(): string | undefined {
+	if (resolvedChromium !== undefined) return resolvedChromium ?? undefined;
+	const found = firstExecutableCandidate(systemChromiumCandidates(), () => true);
+	resolvedChromium = found ?? null;
+	if (found) logger.debug("Using system Chrome/Chromium", { path: found });
+	return found;
+}
+
+/** Edge is Chromium-based but keeps its own profile format under its own user data root. */
+const EDGE_EXECUTABLE_PATTERN =
+	/(?:^|[/\\])(?:msedge(?:\.exe)?|microsoft-edge(?:-(?:stable|beta|dev|canary))?|com\.microsoft\.Edge|Microsoft Edge(?: Beta| Dev| Canary)?)$/i;
+
+/** True for a Microsoft Edge executable path (excluded from Chrome profile mode). */
+export function isEdgeExecutable(candidate: string): boolean {
+	return EDGE_EXECUTABLE_PATTERN.test(candidate);
+}
+
+const CHROME_PROFILE_EXECUTABLE_PATTERN =
+	/(?:^|[/\\])(?:google-chrome(?:-(?:stable|beta|unstable|canary))?|chromium(?:-browser)?|chrome(?:\.exe)?|Google Chrome(?: Beta| Dev| Canary)?|Chromium|com\.google\.Chrome|org\.chromium\.Chromium)$/i;
+
+/** True only for executable names owned by Google Chrome or Chromium. */
+export function isChromeProfileExecutable(candidate: string): boolean {
+	return CHROME_PROFILE_EXECUTABLE_PATTERN.test(candidate);
+}
+
+/**
+ * Validate the executable identity used for profile mode. Most symlinks are
+ * judged by their resolved target so a renamed cross-brand browser cannot pass
+ * by alias. Snap's canonical `/snap/bin/chromium` launcher is the exception:
+ * it resolves to the generic `/usr/bin/snap` dispatcher by design.
+ */
+export function isChromeProfileExecutableForLaunch(candidate: string, resolvedCandidate: string): boolean {
+	return (
+		(path.posix.normalize(candidate) === "/snap/bin/chromium" &&
+			path.posix.normalize(resolvedCandidate) === "/usr/bin/snap") ||
+		isChromeProfileExecutable(resolvedCandidate)
+	);
+}
+
+let resolvedProfileChrome: string | null | undefined; // undefined = unchecked; null = not found
+
+/**
+ * Installed Chrome/Chromium executable for saved-profile mode, or undefined when
+ * none is present. Edge is excluded on purpose: a discovered Chrome user data
+ * directory must never be opened by a different browser brand.
+ */
+export function resolveSystemChromeForProfile(): string | undefined {
+	if (resolvedProfileChrome !== undefined) return resolvedProfileChrome ?? undefined;
+	const found = firstExecutableCandidate(systemChromiumCandidates(), isChromeProfileExecutable);
+	resolvedProfileChrome = found ?? null;
+	if (found) logger.debug("Using system Chrome/Chromium for profile mode", { path: found });
+	return found;
+}
+
 export interface LaunchHeadlessOptions {
 	headless: boolean;
 	viewport?: { width: number; height: number; deviceScaleFactor?: number };

package/src/tools/browser/profile-discovery.ts

@@ -10,6 +10,7 @@
 
 import * as os from "node:os";
 import * as path from "node:path";
+import { $credentialEnv } from "@gajae-code/utils/env";
 
 export interface DiscoveryEnv {
 	platform: NodeJS.Platform;
@@ -18,19 +19,55 @@ export interface DiscoveryEnv {
 	exists: (p: string) => boolean;
 	/** Windows LOCALAPPDATA override (tests / non-default installs). */
 	localAppData?: string;
+	/** Linux Chrome-specific default user-data override. */
+	chromeUserDataDir?: string;
+	/** Linux Chrome config-home override (takes precedence over XDG_CONFIG_HOME). */
+	chromeConfigHome?: string;
+	/** Linux XDG config-home override. */
+	xdgConfigHome?: string;
+}
+
+function discoveryPath(env: DiscoveryEnv): typeof path.posix {
+	return env.platform === "win32" ? path.win32 : path.posix;
 }
 
 /** Candidate Chrome user-data roots for the platform (most common first). */
 export function chromeUserDataRoots(env: DiscoveryEnv): string[] {
+	const platformPath = discoveryPath(env);
 	switch (env.platform) {
 		case "darwin":
-			return [path.join(env.home, "Library", "Application Support", "Google", "Chrome")];
+			return [
+				platformPath.join(env.home, "Library", "Application Support", "Google", "Chrome"),
+				platformPath.join(env.home, "Library", "Application Support", "Google", "Chrome Beta"),
+				platformPath.join(env.home, "Library", "Application Support", "Google", "Chrome Dev"),
+				platformPath.join(env.home, "Library", "Application Support", "Google", "Chrome Canary"),
+				platformPath.join(env.home, "Library", "Application Support", "Chromium"),
+			];
 		case "win32": {
-			const localAppData = env.localAppData ?? path.join(env.home, "AppData", "Local");
-			return [path.join(localAppData, "Google", "Chrome", "User Data")];
+			const localAppData = env.localAppData ?? platformPath.join(env.home, "AppData", "Local");
+			return [
+				platformPath.join(localAppData, "Google", "Chrome", "User Data"),
+				platformPath.join(localAppData, "Google", "Chrome Beta", "User Data"),
+				platformPath.join(localAppData, "Google", "Chrome Dev", "User Data"),
+				platformPath.join(localAppData, "Google", "Chrome SxS", "User Data"),
+				platformPath.join(localAppData, "Chromium", "User Data"),
+			];
+		}
+		default: {
+			const configHome = env.chromeConfigHome ?? env.xdgConfigHome ?? platformPath.join(env.home, ".config");
+			return [
+				...(env.chromeUserDataDir ? [env.chromeUserDataDir] : []),
+				platformPath.join(configHome, "google-chrome"),
+				platformPath.join(configHome, "google-chrome-beta"),
+				platformPath.join(configHome, "google-chrome-unstable"),
+				platformPath.join(configHome, "google-chrome-canary"),
+				platformPath.join(configHome, "chromium"),
+				platformPath.join(env.home, ".var", "app", "com.google.Chrome", "config", "google-chrome"),
+				platformPath.join(env.home, ".var", "app", "org.chromium.Chromium", "config", "chromium"),
+				platformPath.join(env.home, "snap", "chromium", "common", "chromium"),
+				platformPath.join(env.home, "snap", "chromium", "current", ".config", "chromium"),
+			];
 		}
-		default:
-			return [path.join(env.home, ".config", "google-chrome"), path.join(env.home, ".config", "chromium")];
 	}
 }
 
@@ -48,8 +85,9 @@ export function discoverDefaultChromeProfile(
 	env: DiscoveryEnv,
 	profileDirectory = "Default",
 ): DiscoveredProfile | null {
+	const platformPath = discoveryPath(env);
 	for (const userDataDir of chromeUserDataRoots(env)) {
-		const profileDir = path.join(userDataDir, profileDirectory);
+		const profileDir = platformPath.join(userDataDir, profileDirectory);
 		if (env.exists(profileDir)) {
 			return { userDataDir, profileDirectory, profileDir };
 		}
@@ -59,5 +97,17 @@ export function discoverDefaultChromeProfile(
 
 /** Convenience wrapper using the live OS environment + fs. */
 export function defaultDiscoveryEnv(exists: (p: string) => boolean): DiscoveryEnv {
-	return { platform: process.platform, home: os.homedir(), exists };
+	const localAppData = $credentialEnv("LOCALAPPDATA");
+	const chromeUserDataDir = $credentialEnv("CHROME_USER_DATA_DIR");
+	const chromeConfigHome = $credentialEnv("CHROME_CONFIG_HOME");
+	const xdgConfigHome = $credentialEnv("XDG_CONFIG_HOME");
+	return {
+		platform: process.platform,
+		home: os.homedir(),
+		exists,
+		...(localAppData ? { localAppData } : {}),
+		...(chromeUserDataDir ? { chromeUserDataDir } : {}),
+		...(chromeConfigHome ? { chromeConfigHome } : {}),
+		...(xdgConfigHome ? { xdgConfigHome } : {}),
+	};
 }

package/src/tools/browser/render.ts

@@ -42,7 +42,7 @@ interface BrowserRenderContext {
 
 function describeBrowser(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string | undefined {
 	if (args.app?.cdp_url) return `connected ${args.app.cdp_url}`;
-	if (args.app?.browser === "chrome") return `Chrome profile ${args.app.profile_directory ?? "<profile>"}`;
+	if (args.app?.browser === "chrome") return `Chrome profile ${args.app.profile_directory ?? "Default"}`;
 	if (args.app?.path) return `spawned ${shortenPath(args.app.path)}`;
 	switch (details?.browser) {
 		case "headless":
@@ -56,6 +56,13 @@ function describeBrowser(args: BrowserRenderArgs, details: BrowserToolDetails |
 	}
 }
 
+export function describeBrowserForTest(
+	args: BrowserRenderArgs,
+	details: BrowserToolDetails | undefined,
+): string | undefined {
+	return describeBrowser(args, details);
+}
+
 function tabLabel(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string {
 	const name = details?.name ?? args.name ?? "main";
 	return `tab ${JSON.stringify(name)}`;