pi-agent-browser-native 0.2.2 → 0.2.4

package/extensions/agent-browser/index.ts

@@ -12,13 +12,21 @@ import { isToolCallEventType, type ExtensionAPI } from "@mariozechner/pi-coding-
 import { Type } from "@sinclair/typebox";
 
 import { runAgentBrowserProcess } from "./lib/process.js";
-import { buildToolPresentation, getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "./lib/results.js";
+import {
+	buildToolPresentation,
+	getAgentBrowserErrorText,
+	parseAgentBrowserEnvelope,
+	type AgentBrowserBatchResult,
+	type AgentBrowserEnvelope,
+} from "./lib/results.js";
 import {
 	buildExecutionPlan,
 	buildPromptPolicy,
+	chooseOpenResultTabCorrection,
 	createEphemeralSessionSeed,
 	createFreshSessionName,
 	createImplicitSessionName,
+	extractCommandTokens,
 	getImplicitSessionCloseTimeoutMs,
 	getImplicitSessionIdleTimeoutMs,
 	getLatestUserPrompt,
@@ -30,8 +38,10 @@ import {
 	resolveManagedSessionState,
 	shouldAppendBrowserSystemPrompt,
 	validateToolArgs,
+	type CompatibilityWorkaround,
+	type OpenResultTabCorrection,
 } from "./lib/runtime.js";
-import { cleanupSecureTempArtifacts } from "./lib/temp.js";
+import { cleanupSecureTempArtifacts, type PersistentSessionArtifactStore } from "./lib/temp.js";
 
 const DEFAULT_SESSION_MODE = "auto" as const;
 
@@ -96,15 +106,184 @@ function buildInvocationPreview(effectiveArgs: string[]): string {
 	return preview.length > 120 ? `${preview.slice(0, 117)}...` : preview;
 }
 
-const AGENT_BROWSER_BASH_PREFIX = String.raw`(?:env(?:\s+[A-Za-z_][A-Za-z0-9_]*=[^\s;&|]+)*\s+)?(?:(?:npx|bunx)(?:\s+-[^\s;&|]+|\s+--[^\s;&|]+(?:=[^\s;&|]+)?)*\s+|(?:pnpm|yarn)\s+dlx(?:\s+-[^\s;&|]+|\s+--[^\s;&|]+(?:=[^\s;&|]+)?)*\s+)?`;
-const AGENT_BROWSER_BASH_EXECUTABLE = String.raw`(?:[.~]|\.\.?|\/)?(?:[^\s;&|]+\/)?agent-browser`;
-const DIRECT_AGENT_BROWSER_BASH_PATTERN = new RegExp(
-	String.raw`(^|[\s;&|])${AGENT_BROWSER_BASH_PREFIX}${AGENT_BROWSER_BASH_EXECUTABLE}(?=\s|$)`,
-);
-const HARMLESS_AGENT_BROWSER_INSPECTION_PATTERN = /(command\s+-v|which|type\s+-P)\s+agent-browser\b/;
+const DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN = /^(?:[.~]|\.\.?|\/)?(?:[^\s;&|]+\/)?agent-browser$/;
+const HARMLESS_AGENT_BROWSER_INSPECTION_PATTERN = /^\s*(?:command\s+-v|which|type\s+-P)\s+agent-browser\s*$/;
+
+type ShellQuoteState = 'double' | 'single' | undefined;
+
+function isShellAssignmentToken(token: string): boolean {
+	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+}
+
+function stripOuterQuotes(token: string): string {
+	if (token.length >= 2 && ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'")))) {
+		return token.slice(1, -1);
+	}
+	return token;
+}
+
+function segmentLaunchesAgentBrowser(tokens: string[]): boolean {
+	let index = 0;
+	while (index < tokens.length && isShellAssignmentToken(tokens[index])) {
+		index += 1;
+	}
+	if (index >= tokens.length) {
+		return false;
+	}
+
+	let executableToken = tokens[index];
+	if (executableToken === 'env') {
+		index += 1;
+		while (index < tokens.length && isShellAssignmentToken(tokens[index])) {
+			index += 1;
+		}
+		executableToken = tokens[index] ?? '';
+	}
+	if (executableToken === 'npx' || executableToken === 'bunx') {
+		index += 1;
+		while (index < tokens.length && tokens[index].startsWith('-')) {
+			index += 1;
+		}
+		executableToken = tokens[index] ?? '';
+	}
+	if (executableToken === 'pnpm' || executableToken === 'yarn') {
+		index += 1;
+		if (tokens[index] !== 'dlx') {
+			return false;
+		}
+		index += 1;
+		while (index < tokens.length && tokens[index].startsWith('-')) {
+			index += 1;
+		}
+		executableToken = tokens[index] ?? '';
+	}
+	return DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN.test(executableToken);
+}
 
+// Best-effort detection for common direct launches only. This is an ergonomics guard,
+// not a general-purpose bash parser or security boundary.
 function looksLikeDirectAgentBrowserBash(command: string): boolean {
-	return DIRECT_AGENT_BROWSER_BASH_PATTERN.test(command);
+	let currentToken = '';
+	let quoteState: ShellQuoteState;
+	let awaitingHeredocDelimiter: { stripTabs: boolean } | undefined;
+	let pendingHeredoc: { delimiter: string; stripTabs: boolean } | undefined;
+	let pendingHeredocLine = '';
+	let segmentTokens: string[] = [];
+
+	const acceptToken = (token: string) => {
+		if (token.length === 0) {
+			return;
+		}
+		if (awaitingHeredocDelimiter) {
+			pendingHeredoc = {
+				delimiter: stripOuterQuotes(token),
+				stripTabs: awaitingHeredocDelimiter.stripTabs,
+			};
+			awaitingHeredocDelimiter = undefined;
+			return;
+		}
+		segmentTokens.push(token);
+	};
+	const flushToken = () => {
+		acceptToken(currentToken);
+		currentToken = '';
+	};
+	const flushSegment = () => {
+		const launchesAgentBrowser = segmentLaunchesAgentBrowser(segmentTokens);
+		segmentTokens = [];
+		return launchesAgentBrowser;
+	};
+
+	for (let index = 0; index < command.length; index += 1) {
+		const char = command[index];
+		if (pendingHeredoc) {
+			if (char === '\n') {
+				const candidate = pendingHeredoc.stripTabs ? pendingHeredocLine.replace(/^\t+/, '') : pendingHeredocLine;
+				if (candidate === pendingHeredoc.delimiter) {
+					pendingHeredoc = undefined;
+				}
+				pendingHeredocLine = '';
+				continue;
+			}
+			pendingHeredocLine += char;
+			continue;
+		}
+
+		if (quoteState === 'single') {
+			currentToken += char;
+			if (char === "'") {
+				quoteState = undefined;
+			}
+			continue;
+		}
+		if (quoteState === 'double') {
+			currentToken += char;
+			if (char === '\\' && index + 1 < command.length) {
+				currentToken += command[index + 1];
+				index += 1;
+				continue;
+			}
+			if (char === '"') {
+				quoteState = undefined;
+			}
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			currentToken += char;
+			quoteState = char === "'" ? 'single' : 'double';
+			continue;
+		}
+		if (char === '\\' && index + 1 < command.length) {
+			currentToken += char;
+			currentToken += command[index + 1];
+			index += 1;
+			continue;
+		}
+		if (char === '\n') {
+			flushToken();
+			if (flushSegment()) {
+				return true;
+			}
+			continue;
+		}
+		if (/\s/.test(char)) {
+			flushToken();
+			continue;
+		}
+		const threeCharOperator = command.slice(index, index + 3);
+		if (threeCharOperator === '<<-') {
+			flushToken();
+			awaitingHeredocDelimiter = { stripTabs: true };
+			index += 2;
+			continue;
+		}
+		const twoCharOperator = command.slice(index, index + 2);
+		if (twoCharOperator === '<<') {
+			flushToken();
+			awaitingHeredocDelimiter = { stripTabs: false };
+			index += 1;
+			continue;
+		}
+		if (twoCharOperator === '&&' || twoCharOperator === '||') {
+			flushToken();
+			if (flushSegment()) {
+				return true;
+			}
+			index += 1;
+			continue;
+		}
+		if (char === '|' || char === ';' || char === '&') {
+			flushToken();
+			if (flushSegment()) {
+				return true;
+			}
+			continue;
+		}
+		currentToken += char;
+	}
+
+	flushToken();
+	return flushSegment();
 }
 
 function isHarmlessAgentBrowserInspectionCommand(command: string): boolean {
@@ -142,41 +321,232 @@ function extractStringResultField(data: unknown, fieldName: "title" | "url"): st
 	return text.length > 0 ? text : undefined;
 }
 
-async function collectNavigationSummary(options: {
+const SESSION_TAB_PINNING_EXCLUDED_COMMANDS = new Set(["batch", "close", "goto", "navigate", "open", "session", "tab"]);
+
+interface SessionTabTarget {
+	title?: string;
+	url: string;
+}
+
+function normalizeComparableUrl(url: string | undefined): string | undefined {
+	const normalizedUrl = url?.trim();
+	if (!normalizedUrl) {
+		return undefined;
+	}
+	try {
+		const parsedUrl = new URL(normalizedUrl);
+		parsedUrl.hash = "";
+		return parsedUrl.toString();
+	} catch {
+		return undefined;
+	}
+}
+
+function normalizeSessionTabTarget(target: { title?: string; url?: string } | undefined): SessionTabTarget | undefined {
+	if (!target) {
+		return undefined;
+	}
+	const url = normalizeComparableUrl(target.url);
+	if (!url) {
+		return undefined;
+	}
+	const title = target.title?.trim();
+	return { title: title && title.length > 0 ? title : undefined, url };
+}
+
+function extractSessionTabTargetFromData(data: unknown): SessionTabTarget | undefined {
+	const directTarget = normalizeSessionTabTarget({
+		title: extractStringResultField(data, "title"),
+		url: extractStringResultField(data, "url"),
+	});
+	if (directTarget) {
+		return directTarget;
+	}
+	if (isRecord(data) && typeof data.origin === "string") {
+		return normalizeSessionTabTarget({ url: data.origin });
+	}
+	return undefined;
+}
+
+function restoreSessionTabTargetsFromBranch(branch: unknown[]): Map<string, SessionTabTarget> {
+	const restoredTargets = new Map<string, SessionTabTarget>();
+	for (const entry of branch) {
+		if (!isRecord(entry) || entry.type !== "message") {
+			continue;
+		}
+		const message = isRecord(entry.message) ? entry.message : undefined;
+		if (!message || message.toolName !== "agent_browser") {
+			continue;
+		}
+		const details = isRecord(message.details) ? message.details : undefined;
+		if (!details) {
+			continue;
+		}
+		const sessionName = typeof details.sessionName === "string" ? details.sessionName : undefined;
+		if (!sessionName) {
+			continue;
+		}
+		const command = typeof details.command === "string" ? details.command : undefined;
+		if (command === "close" && message.isError !== true) {
+			restoredTargets.delete(sessionName);
+			continue;
+		}
+		const sessionTabTarget = isRecord(details.sessionTabTarget)
+			? normalizeSessionTabTarget({
+					title: typeof details.sessionTabTarget.title === "string" ? details.sessionTabTarget.title : undefined,
+					url: typeof details.sessionTabTarget.url === "string" ? details.sessionTabTarget.url : undefined,
+			  })
+			: undefined;
+		if (sessionTabTarget) {
+			restoredTargets.set(sessionName, sessionTabTarget);
+		}
+	}
+	return restoredTargets;
+}
+
+function shouldPinSessionTabForCommand(options: { command?: string; sessionName?: string; stdin?: string }): boolean {
+	return (
+		options.sessionName !== undefined &&
+		options.stdin === undefined &&
+		options.command !== undefined &&
+		!SESSION_TAB_PINNING_EXCLUDED_COMMANDS.has(options.command)
+	);
+}
+
+function selectSessionTargetTab(options: {
+	tabs: Array<{ active?: boolean; index?: number; title?: string; url?: string }>;
+	target: SessionTabTarget;
+}): OpenResultTabCorrection | undefined {
+	const matchingTabs = options.tabs.filter((tab) => normalizeComparableUrl(tab.url) === options.target.url);
+	if (matchingTabs.length === 0) {
+		return undefined;
+	}
+	const titledMatch =
+		typeof options.target.title === "string"
+			? matchingTabs.find((tab) => tab.title?.trim() === options.target.title)
+			: undefined;
+	const selectedTab = titledMatch ?? matchingTabs[0];
+	return typeof selectedTab.index === "number"
+		? {
+				selectedIndex: selectedTab.index,
+				targetTitle: options.target.title,
+				targetUrl: options.target.url,
+		  }
+		: undefined;
+}
+
+function deriveSessionTabTarget(options: {
+	command?: string;
+	data: unknown;
+	navigationSummary?: NavigationSummary;
+	previousTarget?: SessionTabTarget;
+}): SessionTabTarget | undefined {
+	if (options.command === "close") {
+		return undefined;
+	}
+	return (
+		normalizeSessionTabTarget(options.navigationSummary) ??
+		extractSessionTabTargetFromData(options.data) ??
+		options.previousTarget
+	);
+}
+
+function unwrapPinnedSessionBatchEnvelope(options: {
+	envelope?: AgentBrowserEnvelope;
+	includeNavigationSummary: boolean;
+}): { envelope?: AgentBrowserEnvelope; navigationSummary?: NavigationSummary; parseError?: string } {
+	if (!options.envelope) {
+		return {};
+	}
+	if (!Array.isArray(options.envelope.data)) {
+		return {
+			parseError: "agent-browser returned an unexpected response while applying the wrapper's tab-pinning batch.",
+		};
+	}
+
+	const steps = options.envelope.data.filter(isRecord) as AgentBrowserBatchResult[];
+	const tabSelectionStep = steps[0];
+	const commandStep = steps[1];
+	if (!commandStep) {
+		return {
+			envelope: {
+				success: false,
+				error: "agent-browser did not return the corrected command result.",
+			},
+		};
+	}
+	if (tabSelectionStep?.success === false) {
+		return {
+			envelope: {
+				success: false,
+				error: tabSelectionStep.error ?? "agent-browser could not re-select the intended tab before running the command.",
+			},
+		};
+	}
+
+	const titleStep = options.includeNavigationSummary ? steps[2] : undefined;
+	const urlStep = options.includeNavigationSummary ? steps[3] : undefined;
+	const navigationSummary = normalizeSessionTabTarget({
+		title: extractStringResultField(titleStep?.result, "title"),
+		url: extractStringResultField(urlStep?.result, "url"),
+	});
+	return {
+		envelope: {
+			success: commandStep.success !== false,
+			data: commandStep.result,
+			error: commandStep.success === false ? commandStep.error : undefined,
+		},
+		navigationSummary,
+	};
+}
+
+async function runSessionCommandData(options: {
+	args: string[];
 	cwd: string;
 	sessionName?: string;
 	signal?: AbortSignal;
-}): Promise<NavigationSummary | undefined> {
-	const { cwd, sessionName, signal } = options;
+}): Promise<unknown | undefined> {
+	const { args, cwd, sessionName, signal } = options;
 	if (!sessionName) return undefined;
 
-	const readField = async (fieldName: "title" | "url"): Promise<string | undefined> => {
-		const processResult = await runAgentBrowserProcess({
-			args: ["--json", "--session", sessionName, "get", fieldName],
-			cwd,
-			signal,
-		});
-		if (processResult.aborted || processResult.spawnError || processResult.exitCode !== 0) {
+	const processResult = await runAgentBrowserProcess({
+		args: ["--json", "--session", sessionName, ...args],
+		cwd,
+		signal,
+	});
+	if (processResult.aborted || processResult.spawnError || processResult.exitCode !== 0) {
+		return undefined;
+	}
+	const parsed = await parseAgentBrowserEnvelope({
+		stdout: processResult.stdout,
+		stdoutPath: processResult.stdoutSpillPath,
+	});
+	try {
+		if (parsed.parseError || parsed.envelope?.success === false) {
 			return undefined;
 		}
-		const parsed = await parseAgentBrowserEnvelope({
-			stdout: processResult.stdout,
-			stdoutPath: processResult.stdoutSpillPath,
-		});
-		try {
-			if (parsed.parseError || parsed.envelope?.success === false) {
-				return undefined;
-			}
-			return extractStringResultField(parsed.envelope?.data, fieldName);
-		} finally {
-			if (processResult.stdoutSpillPath) {
-				await rm(processResult.stdoutSpillPath, { force: true }).catch(() => undefined);
-			}
+		return parsed.envelope?.data;
+	} finally {
+		if (processResult.stdoutSpillPath) {
+			await rm(processResult.stdoutSpillPath, { force: true }).catch(() => undefined);
 		}
-	};
+	}
+}
 
-	const title = await readField("title");
-	const url = await readField("url");
+async function collectNavigationSummary(options: {
+	cwd: string;
+	sessionName?: string;
+	signal?: AbortSignal;
+}): Promise<NavigationSummary | undefined> {
+	const { cwd, sessionName, signal } = options;
+	const title = extractStringResultField(
+		await runSessionCommandData({ args: ["get", "title"], cwd, sessionName, signal }),
+		"title",
+	);
+	const url = extractStringResultField(
+		await runSessionCommandData({ args: ["get", "url"], cwd, sessionName, signal }),
+		"url",
+	);
 	if (!title && !url) return undefined;
 	return { title, url };
 }
@@ -188,6 +558,63 @@ function mergeNavigationSummaryIntoData(data: unknown, navigationSummary: Naviga
 	return { navigationSummary, result: data };
 }
 
+async function collectOpenResultTabCorrection(options: {
+	cwd: string;
+	sessionName?: string;
+	signal?: AbortSignal;
+	targetTitle?: string;
+	targetUrl?: string;
+}): Promise<OpenResultTabCorrection | undefined> {
+	const { cwd, sessionName, signal, targetTitle, targetUrl } = options;
+	const tabData = await runSessionCommandData({ args: ["tab", "list"], cwd, sessionName, signal });
+	if (!isRecord(tabData) || !Array.isArray(tabData.tabs)) {
+		return undefined;
+	}
+	const tabs = tabData.tabs.filter(isRecord).map((tab) => ({
+		active: tab.active === true,
+		index: typeof tab.index === "number" ? tab.index : undefined,
+		title: typeof tab.title === "string" ? tab.title : undefined,
+		url: typeof tab.url === "string" ? tab.url : undefined,
+	}));
+	return chooseOpenResultTabCorrection({ tabs, targetTitle, targetUrl });
+}
+
+async function collectSessionTabSelection(options: {
+	cwd: string;
+	sessionName?: string;
+	signal?: AbortSignal;
+	target: SessionTabTarget;
+}): Promise<OpenResultTabCorrection | undefined> {
+	const { cwd, sessionName, signal, target } = options;
+	const tabData = await runSessionCommandData({ args: ["tab", "list"], cwd, sessionName, signal });
+	if (!isRecord(tabData) || !Array.isArray(tabData.tabs)) {
+		return undefined;
+	}
+	const tabs = tabData.tabs.filter(isRecord).map((tab) => ({
+		active: tab.active === true,
+		index: typeof tab.index === "number" ? tab.index : undefined,
+		title: typeof tab.title === "string" ? tab.title : undefined,
+		url: typeof tab.url === "string" ? tab.url : undefined,
+	}));
+	return selectSessionTargetTab({ tabs, target });
+}
+
+async function applyOpenResultTabCorrection(options: {
+	correction: OpenResultTabCorrection;
+	cwd: string;
+	sessionName?: string;
+	signal?: AbortSignal;
+}): Promise<OpenResultTabCorrection | undefined> {
+	const { correction, cwd, sessionName, signal } = options;
+	const result = await runSessionCommandData({
+		args: ["tab", String(correction.selectedIndex)],
+		cwd,
+		sessionName,
+		signal,
+	});
+	return result === undefined ? undefined : correction;
+}
+
 function buildSharedBrowserPlaybookGuidelines(hasBraveApiKey: boolean): string[] {
 	return [
 		SHARED_BROWSER_PLAYBOOK_GUIDELINES[0],
@@ -209,6 +636,22 @@ function buildSessionDetailFields(sessionName: string | undefined, usedImplicitS
 	return sessionName ? { sessionName, usedImplicitSession } : {};
 }
 
+function getPersistentSessionArtifactStore(ctx: {
+	sessionManager: {
+		getSessionDir?: () => string;
+		getSessionFile?: () => string | undefined;
+		getSessionId: () => string | undefined;
+	};
+}): PersistentSessionArtifactStore | undefined {
+	const sessionFile = typeof ctx.sessionManager.getSessionFile === "function" ? ctx.sessionManager.getSessionFile() : undefined;
+	const sessionDir = typeof ctx.sessionManager.getSessionDir === "function" ? ctx.sessionManager.getSessionDir() : undefined;
+	const sessionId = ctx.sessionManager.getSessionId();
+	if (!sessionFile || !sessionDir || !sessionId) {
+		return undefined;
+	}
+	return { sessionDir, sessionId };
+}
+
 function redactRecoveryHint(recoveryHint: {
 	exampleArgs: string[];
 	exampleParams: { args: string[]; sessionMode: "fresh" };
@@ -256,6 +699,7 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 	let managedSessionName = managedSessionBaseName;
 	let managedSessionCwd = process.cwd();
 	let freshSessionOrdinal = 0;
+	let sessionTabTargets = new Map<string, SessionTabTarget>();
 
 	pi.on("session_start", async (_event, ctx) => {
 		managedSessionBaseName = createImplicitSessionName(ctx.sessionManager.getSessionId(), ctx.cwd, ephemeralSessionSeed);
@@ -264,17 +708,12 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 		managedSessionName = restoredState.sessionName;
 		managedSessionCwd = ctx.cwd;
 		freshSessionOrdinal = restoredState.freshSessionOrdinal;
+		sessionTabTargets = restoreSessionTabTargetsFromBranch(ctx.sessionManager.getBranch());
 	});
 
 	pi.on("session_shutdown", async () => {
-		if (managedSessionActive) {
-			await closeManagedSession({
-				cwd: managedSessionCwd,
-				sessionName: managedSessionName,
-				timeoutMs: implicitSessionCloseTimeoutMs,
-			});
-		}
 		managedSessionActive = false;
+		sessionTabTargets = new Map<string, SessionTabTarget>();
 		await cleanupSecureTempArtifacts();
 	});
 
@@ -332,6 +771,7 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 			});
 			const redactedEffectiveArgs = redactInvocationArgs(executionPlan.effectiveArgs);
 			const redactedRecoveryHint = redactRecoveryHint(executionPlan.recoveryHint);
+			const compatibilityWorkaround: CompatibilityWorkaround | undefined = executionPlan.compatibilityWorkaround;
 			if (executionPlan.managedSessionName === freshSessionName) {
 				freshSessionOrdinal += 1;
 			}
@@ -351,21 +791,56 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 				};
 			}
 
+			const priorSessionTabTarget = executionPlan.sessionName ? sessionTabTargets.get(executionPlan.sessionName) : undefined;
+			const includePinnedNavigationSummary =
+				executionPlan.commandInfo.command !== undefined && NAVIGATION_SUMMARY_COMMANDS.has(executionPlan.commandInfo.command);
+			let sessionTabCorrection: OpenResultTabCorrection | undefined;
+			let processArgs = executionPlan.effectiveArgs;
+			let processStdin = params.stdin;
+			if (
+				priorSessionTabTarget &&
+				shouldPinSessionTabForCommand({
+					command: executionPlan.commandInfo.command,
+					sessionName: executionPlan.sessionName,
+					stdin: params.stdin,
+				})
+			) {
+				const plannedSessionTabSelection = await collectSessionTabSelection({
+					cwd: ctx.cwd,
+					sessionName: executionPlan.sessionName,
+					signal,
+					target: priorSessionTabTarget,
+				});
+				const commandTokens = extractCommandTokens(params.args);
+				if (plannedSessionTabSelection && commandTokens.length > 0 && executionPlan.sessionName) {
+					sessionTabCorrection = plannedSessionTabSelection;
+					processArgs = ["--json", "--session", executionPlan.sessionName, "batch"];
+					processStdin = JSON.stringify([
+						["tab", String(plannedSessionTabSelection.selectedIndex)],
+						commandTokens,
+						...(includePinnedNavigationSummary ? [["get", "title"], ["get", "url"]] : []),
+					]);
+				}
+			}
+			const redactedProcessArgs = redactInvocationArgs(processArgs);
+
 			onUpdate?.({
-				content: [{ type: "text", text: `Running agent-browser ${buildInvocationPreview(redactedEffectiveArgs)}` }],
+				content: [{ type: "text", text: `Running agent-browser ${buildInvocationPreview(redactedProcessArgs)}` }],
 				details: {
-					effectiveArgs: redactedEffectiveArgs,
+					compatibilityWorkaround,
+					effectiveArgs: redactedProcessArgs,
 					sessionMode,
+					sessionTabCorrection,
 					...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession),
 				},
 			});
 
 			const processResult = await runAgentBrowserProcess({
-				args: executionPlan.effectiveArgs,
+				args: processArgs,
 				cwd: ctx.cwd,
 				env: executionPlan.managedSessionName ? { AGENT_BROWSER_IDLE_TIMEOUT_MS: implicitSessionIdleTimeoutMs } : undefined,
 				signal,
-				stdin: params.stdin,
+				stdin: processStdin,
 			});
 
 			if (processResult.spawnError?.message.includes("ENOENT")) {
@@ -374,8 +849,10 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					content: [{ type: "text", text: errorText }],
 					details: {
 						args: redactedArgs,
-						effectiveArgs: redactedEffectiveArgs,
+						compatibilityWorkaround,
+						effectiveArgs: redactedProcessArgs,
 						sessionMode,
+						sessionTabCorrection,
 						spawnError: processResult.spawnError.message,
 					},
 					isError: true,
@@ -387,26 +864,78 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					stdout: processResult.stdout,
 					stdoutPath: processResult.stdoutSpillPath,
 				});
+				let parseError = parsed.parseError;
 				let presentationEnvelope = parsed.envelope;
+				let navigationSummary: NavigationSummary | undefined;
+				if (sessionTabCorrection) {
+					const pinnedBatchResult = unwrapPinnedSessionBatchEnvelope({
+						envelope: parsed.envelope,
+						includeNavigationSummary: includePinnedNavigationSummary,
+					});
+					parseError = pinnedBatchResult.parseError ?? parseError;
+					presentationEnvelope = pinnedBatchResult.envelope ?? presentationEnvelope;
+					navigationSummary = pinnedBatchResult.navigationSummary;
+				}
 				const processSucceeded = !processResult.aborted && !processResult.spawnError && processResult.exitCode === 0;
 				const plainTextInspection = executionPlan.plainTextInspection && processSucceeded;
-				const parseSucceeded = plainTextInspection || parsed.parseError === undefined;
-				const envelopeSuccess = plainTextInspection ? true : parsed.envelope?.success !== false;
+				const parseSucceeded = plainTextInspection || parseError === undefined;
+				const envelopeSuccess = plainTextInspection ? true : presentationEnvelope?.success !== false;
 				const succeeded = processSucceeded && parseSucceeded && envelopeSuccess;
 				const inspectionText = plainTextInspection ? processResult.stdout.trim() : undefined;
 
-				let navigationSummary: NavigationSummary | undefined;
-				if (succeeded && shouldCaptureNavigationSummary(executionPlan.commandInfo.command, parsed.envelope?.data)) {
+				if (succeeded && !navigationSummary && shouldCaptureNavigationSummary(executionPlan.commandInfo.command, presentationEnvelope?.data)) {
 					navigationSummary = await collectNavigationSummary({
 						cwd: ctx.cwd,
 						sessionName: executionPlan.sessionName,
 						signal,
 					});
-					if (navigationSummary && presentationEnvelope) {
-						presentationEnvelope = {
-							...presentationEnvelope,
-							data: mergeNavigationSummaryIntoData(presentationEnvelope.data, navigationSummary),
-						};
+				}
+				if (navigationSummary && presentationEnvelope) {
+					presentationEnvelope = {
+						...presentationEnvelope,
+						data: mergeNavigationSummaryIntoData(presentationEnvelope.data, navigationSummary),
+					};
+				}
+
+				let openResultTabCorrection: OpenResultTabCorrection | undefined;
+				if (
+					succeeded &&
+					executionPlan.sessionName &&
+					params.args.some((token) => token === "--profile" || token.startsWith("--profile=")) &&
+					(executionPlan.commandInfo.command === "goto" ||
+						executionPlan.commandInfo.command === "navigate" ||
+						executionPlan.commandInfo.command === "open")
+				) {
+					const targetTitle = extractStringResultField(presentationEnvelope?.data, "title");
+					const targetUrl = extractStringResultField(presentationEnvelope?.data, "url");
+					const plannedTabCorrection = await collectOpenResultTabCorrection({
+						cwd: ctx.cwd,
+						sessionName: executionPlan.sessionName,
+						signal,
+						targetTitle,
+						targetUrl,
+					});
+					if (plannedTabCorrection) {
+						openResultTabCorrection = await applyOpenResultTabCorrection({
+							correction: plannedTabCorrection,
+							cwd: ctx.cwd,
+							sessionName: executionPlan.sessionName,
+							signal,
+						});
+					}
+				}
+
+				const currentSessionTabTarget = deriveSessionTabTarget({
+					command: executionPlan.commandInfo.command,
+					data: presentationEnvelope?.data,
+					navigationSummary,
+					previousTarget: priorSessionTabTarget,
+				});
+				if (executionPlan.sessionName) {
+					if (executionPlan.commandInfo.command === "close" && succeeded) {
+						sessionTabTargets.delete(executionPlan.sessionName);
+					} else if (currentSessionTabTarget) {
+						sessionTabTargets.set(executionPlan.sessionName, currentSessionTabTarget);
 					}
 				}
 
@@ -425,6 +954,7 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					managedSessionCwd = ctx.cwd;
 				}
 				if (replacedManagedSessionName) {
+					sessionTabTargets.delete(replacedManagedSessionName);
 					await closeManagedSession({
 						cwd: priorManagedSessionCwd,
 						sessionName: replacedManagedSessionName,
@@ -434,9 +964,9 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 
 				const errorText = getAgentBrowserErrorText({
 					aborted: processResult.aborted,
-					envelope: parsed.envelope,
+					envelope: presentationEnvelope,
 					exitCode: processResult.exitCode,
-					parseError: parsed.parseError,
+					parseError,
 					plainTextInspection,
 					spawnError: processResult.spawnError,
 					stderr: processResult.stderr,
@@ -459,6 +989,7 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 							cwd: ctx.cwd,
 							envelope: presentationEnvelope,
 							errorText,
+							persistentArtifactStore: getPersistentSessionArtifactStore(ctx),
 					  });
 				const redactedContent = presentation.content.map((item) =>
 					item.type === "text" ? { ...item, text: redactSensitiveText(item.text) } : item,
@@ -471,19 +1002,23 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 						batchFailure: redactSensitiveValue(presentation.batchFailure),
 						batchSteps: redactSensitiveValue(presentation.batchSteps),
 						command: executionPlan.commandInfo.command,
+						compatibilityWorkaround,
 						subcommand: executionPlan.commandInfo.subcommand,
 						data: redactSensitiveValue(presentation.data),
-						error: plainTextInspection ? undefined : redactSensitiveValue(parsed.envelope?.error),
+						error: plainTextInspection ? undefined : redactSensitiveValue(presentationEnvelope?.error),
 						inspection: plainTextInspection || undefined,
 						navigationSummary: redactSensitiveValue(navigationSummary),
-						effectiveArgs: redactedEffectiveArgs,
+						openResultTabCorrection: redactSensitiveValue(openResultTabCorrection),
+						effectiveArgs: redactedProcessArgs,
 						exitCode: processResult.exitCode,
 						fullOutputPath: presentation.fullOutputPath,
 						fullOutputPaths: presentation.fullOutputPaths,
 						imagePath: presentation.imagePath,
 						imagePaths: presentation.imagePaths,
-						parseError: plainTextInspection ? undefined : parsed.parseError,
+						parseError: plainTextInspection ? undefined : parseError,
 						sessionMode,
+						sessionTabCorrection: redactSensitiveValue(sessionTabCorrection),
+						sessionTabTarget: redactSensitiveValue(currentSessionTabTarget),
 						...buildSessionDetailFields(executionPlan.sessionName, executionPlan.usedImplicitSession),
 						sessionRecoveryHint: redactedRecoveryHint,
 						startupScopedFlags: executionPlan.startupScopedFlags,