pi-agent-browser-native 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.5 - 2026-04-14
+
+### Changed
+- refreshed the development and release-verification baseline to `@mariozechner/pi-coding-agent` `0.67.2` and `@types/node` `25.6.0`, keeping local typechecking and package verification aligned with the latest stable pi release used for this extension
+- re-locked the compatible transitive development dependency set pulled by the updated pi toolchain without changing the published `agent_browser` runtime contract
+
+## 0.2.4 - 2026-04-13
+
+### Fixed
+- wrapper-spawned local Unix `agent-browser` runs now use a short private socket directory under `/tmp`, so extension-generated session names no longer fail the upstream Unix socket-path length limit in longer cwd/session-name combinations
+- once the wrapper knows which tab a session should stay on, later active-tab commands like `click` and `snapshot -i` now best-effort pin that same tab inside the same upstream invocation instead of letting reconnect drift send the action to a restored/background tab
+- persisted `sessionTabTarget` state now survives `/reload` / `/resume` for both managed and explicit sessions, so the reconnect-time tab pinning behavior can continue after restart/resume flows
+- README, requirements, architecture notes, and tool-contract docs now describe the socket-path mitigation and the follow-up-command tab-pinning behavior
+
 ## 0.2.3 - 2026-04-13
 
 ### Fixed

package/README.md

@@ -192,8 +192,10 @@ Current cautions:
 - startup-scoped flags like `--profile`, `--session-name`, and `--cdp` are for the first command that launches a session; if the implicit session is already active, retry that call with `sessionMode: "fresh"` or provide an explicit `--session ...` for the new launch
 - implicit `piab-*` sessions are extension-managed convenience sessions; they stay alive across `pi` shutdown/reload so later default calls can keep following the active managed browser on `/reload` or `/resume`, rely on the configured idle timeout to reduce stale background daemons, store persisted-session large snapshot spill files under a private session-scoped artifact directory with a bounded per-session budget so `details.fullOutputPath` survives reload/resume without unbounded growth, and still clean up process-private temp spill artifacts on shutdown
 - `sessionMode: "fresh"` without an explicit `--session` rotates that extension-managed session to the new browser so later auto calls keep using it
+- for local Unix launches, the wrapper uses a short private socket directory under `/tmp` so extension-generated session names do not trip upstream Unix socket-path limits in longer cwd/session-name combinations
 - for direct headless local Chrome launches to `chatgpt.com` and `chat.openai.com`, the extension injects a normal Chrome user agent when the caller did not explicitly provide `--user-agent`; this keeps the default headless workflow usable without forcing `--headed` or `--auto-connect`
 - after profiled `open` calls, the extension best-effort re-selects the tab that matches the returned page URL when restored profile tabs steal focus during launch
+- after a target tab is known, later active-tab commands like `click` and `snapshot -i` best-effort pin that same tab inside the same upstream invocation when a reconnect would otherwise drift to a restored tab
 - explicit caller-provided `--session` values are treated as user-managed and are not auto-closed by the extension
 - explicit caller-provided `--user-agent` values win over the ChatGPT/OpenAI compatibility workaround
 - tool progress/details redact sensitive invocation values such as `--headers`, proxy credentials, and auth-bearing URL parameters before echoing them back into Pi

package/docs/ARCHITECTURE.md

@@ -88,6 +88,8 @@ Practical policy:
 - if an unnamed fresh launch replaces an active extension-managed session, best-effort close the old managed session after the switch succeeds
 - leave explicit caller-provided `--session` choices alone unless the caller closes them explicitly
 - after profiled `open` / `goto` / `navigate` calls, verify the active tab still matches the returned page URL and best-effort switch back when restored profile tabs steal focus
+- once the wrapper knows which tab the agent is operating on, later active-tab commands may synthesize a tiny upstream `batch` that re-selects that tab and then runs the requested command in the same upstream invocation; this stays thin while avoiding reconnect-time drift on profile-restored sessions
+- for local Unix launches, set a short private socket directory so extension-generated session names do not fail on the upstream Unix socket-path length limit
 
 This is primarily about ownership clarity and avoiding surprise, not adding a heavy safety wrapper. If the extension invented the session, the extension should own its lifecycle without breaking reload/resume semantics. If the caller explicitly chose the upstream session model, the extension should stay out of the way.
 

package/docs/REQUIREMENTS.md

@@ -98,6 +98,8 @@ The design should comfortably support workflows such as:
 - Keep mitigations for legacy-skill coexistence simple; do not add extra moving parts unless observed behavior justifies them.
 - Prefer narrow, evidence-backed compatibility mitigations over broad stealth layers when a specific upstream site starts rejecting the default headless launch fingerprint.
 - Preserve the page that a profiled `open` just navigated to; if restored profile tabs steal focus during launch, the wrapper should best-effort switch back to the returned page URL before handing control back to the agent.
+- Once a tab target is known for a session, later active-tab commands should best-effort pin that same tab inside the same upstream invocation when reconnect drift would otherwise land on a restored/background tab.
+- On local Unix launches, extension-generated session names should not fail just because the upstream default socket path is too long; the wrapper should choose a shorter socket directory when needed.
 
 ## Open design questions
 

package/docs/TOOL_CONTRACT.md

@@ -183,6 +183,8 @@ If `agent-browser` is not on `PATH`, fail with a message that:
 - treat explicit caller-provided `--session` choices as user-managed
 - pass explicit `--profile` straight through to upstream `agent-browser`; no profile-cloning or isolation layer is added in v1
 - after profiled `open` / `goto` / `navigate`, if upstream leaves a restored profile tab active instead of the page that was just opened, best-effort switch back to the tab whose URL matches the returned open result before returning control to the agent
+- once the wrapper has a known tab target for a session, later active-tab commands may best-effort pin that tab inside the same upstream invocation so reconnect drift does not send a `click`, `snapshot`, or similar action to a restored/background tab instead
+- on local Unix launches, set a short private socket directory for wrapper-spawned `agent-browser` processes so extension-generated session names do not fail the upstream Unix socket-path length limit in longer cwd/session-name combinations
 - treat successful plain-text inspection commands like `--help` and `--version` as stateless: do not inject the implicit managed session and do not let those calls claim the managed-session slot
 - if startup-scoped flags like `--profile`, `--session-name`, or `--cdp` are supplied after the implicit session is already active while `sessionMode` is `"auto"`, return a validation error with a structured recovery hint that recommends `sessionMode: "fresh"`
 - for direct headless local Chrome launches to `chatgpt.com` / `chat.openai.com`, allow a narrow compatibility fallback that injects a normal Chrome `--user-agent` only when the caller did not explicitly provide one and did not choose `--headed`, `--cdp`, `--auto-connect`, or a provider-backed launch

package/extensions/agent-browser/index.ts

@@ -12,7 +12,13 @@ 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,
@@ -20,6 +26,7 @@ import {
 	createEphemeralSessionSeed,
 	createFreshSessionName,
 	createImplicitSessionName,
+	extractCommandTokens,
 	getImplicitSessionCloseTimeoutMs,
 	getImplicitSessionIdleTimeoutMs,
 	getLatestUserPrompt,
@@ -314,6 +321,185 @@ function extractStringResultField(data: unknown, fieldName: "title" | "url"): st
 	return text.length > 0 ? text : undefined;
 }
 
+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;
@@ -393,6 +579,26 @@ async function collectOpenResultTabCorrection(options: {
 	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;
@@ -493,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);
@@ -501,10 +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 () => {
 		managedSessionActive = false;
+		sessionTabTargets = new Map<string, SessionTabTarget>();
 		await cleanupSecureTempArtifacts();
 	});
 
@@ -582,22 +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: {
 					compatibilityWorkaround,
-					effectiveArgs: redactedEffectiveArgs,
+					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")) {
@@ -607,8 +850,9 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					details: {
 						args: redactedArgs,
 						compatibilityWorkaround,
-						effectiveArgs: redactedEffectiveArgs,
+						effectiveArgs: redactedProcessArgs,
 						sessionMode,
+						sessionTabCorrection,
 						spawnError: processResult.spawnError.message,
 					},
 					isError: true,
@@ -620,27 +864,37 @@ 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;
@@ -652,8 +906,8 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 						executionPlan.commandInfo.command === "navigate" ||
 						executionPlan.commandInfo.command === "open")
 				) {
-					const targetTitle = extractStringResultField(parsed.envelope?.data, "title");
-					const targetUrl = extractStringResultField(parsed.envelope?.data, "url");
+					const targetTitle = extractStringResultField(presentationEnvelope?.data, "title");
+					const targetUrl = extractStringResultField(presentationEnvelope?.data, "url");
 					const plannedTabCorrection = await collectOpenResultTabCorrection({
 						cwd: ctx.cwd,
 						sessionName: executionPlan.sessionName,
@@ -671,6 +925,20 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					}
 				}
 
+				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);
+					}
+				}
+
 				const priorManagedSessionCwd = managedSessionCwd;
 				const managedSessionState = resolveManagedSessionState({
 					command: executionPlan.commandInfo.command,
@@ -686,6 +954,7 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 					managedSessionCwd = ctx.cwd;
 				}
 				if (replacedManagedSessionName) {
+					sessionTabTargets.delete(replacedManagedSessionName);
 					await closeManagedSession({
 						cwd: priorManagedSessionCwd,
 						sessionName: replacedManagedSessionName,
@@ -695,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,
@@ -736,18 +1005,20 @@ export default function agentBrowserExtension(pi: ExtensionAPI) {
 						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),
 						openResultTabCorrection: redactSensitiveValue(openResultTabCorrection),
-						effectiveArgs: redactedEffectiveArgs,
+						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,

package/extensions/agent-browser/lib/process.ts

@@ -7,7 +7,8 @@
  */
 
 import { spawn } from "node:child_process";
-import { env as processEnv } from "node:process";
+import { chmod, mkdir } from "node:fs/promises";
+import { env as processEnv, platform as processPlatform } from "node:process";
 
 import { openSecureTempFile, writeSecureTempChunk } from "./temp.js";
 
@@ -15,6 +16,8 @@ const MAX_BUFFERED_STDOUT_BYTES = 512 * 1_024;
 const MAX_BUFFERED_STDERR_CHARS = 32_000;
 const MAX_BUFFERED_STDOUT_TAIL_CHARS = 32_000;
 const PROCESS_STDOUT_SPILL_FILE_PREFIX = "process-stdout";
+const AGENT_BROWSER_SOCKET_DIR_ENV = "AGENT_BROWSER_SOCKET_DIR";
+const DEFAULT_AGENT_BROWSER_SOCKET_DIR_PREFIX = "/tmp/piab";
 const httpProxyEnvName = "http_proxy";
 const httpsProxyEnvName = "https_proxy";
 const allProxyEnvName = "all_proxy";
@@ -81,6 +84,26 @@ function appendTail(text: string, addition: string, maxChars: number): string {
 	return combined.length <= maxChars ? combined : combined.slice(combined.length - maxChars);
 }
 
+export function getAgentBrowserSocketDir(
+	platform: NodeJS.Platform = processPlatform,
+	uid: number | undefined = typeof process.getuid === "function" ? process.getuid() : undefined,
+): string | undefined {
+	if (platform === "win32") {
+		return undefined;
+	}
+	return `${DEFAULT_AGENT_BROWSER_SOCKET_DIR_PREFIX}${typeof uid === "number" ? `-${uid}` : ""}`;
+}
+
+async function ensureAgentBrowserSocketDir(socketDir: string): Promise<boolean> {
+	try {
+		await mkdir(socketDir, { recursive: true, mode: 0o700 });
+		await chmod(socketDir, 0o700).catch(() => undefined);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 export function buildAgentBrowserProcessEnv(
 	baseEnv: NodeJS.ProcessEnv = processEnv,
 	overrides: NodeJS.ProcessEnv | undefined = undefined,
@@ -117,6 +140,11 @@ export async function runAgentBrowserProcess(options: {
 	stdin?: string;
 }): Promise<ProcessRunResult> {
 	const { args, cwd, env, signal, stdin } = options;
+	let effectiveEnv = env;
+	const requestedSocketDir = env?.[AGENT_BROWSER_SOCKET_DIR_ENV] ?? getAgentBrowserSocketDir();
+	if (requestedSocketDir && (await ensureAgentBrowserSocketDir(requestedSocketDir))) {
+		effectiveEnv = { ...env, [AGENT_BROWSER_SOCKET_DIR_ENV]: requestedSocketDir };
+	}
 
 	return await new Promise<ProcessRunResult>((resolve) => {
 		let aborted = false;
@@ -191,7 +219,7 @@ export async function runAgentBrowserProcess(options: {
 
 		const child = spawn("agent-browser", args, {
 			cwd,
-			env: buildAgentBrowserProcessEnv(processEnv, env),
+			env: buildAgentBrowserProcessEnv(processEnv, effectiveEnv),
 			stdio: ["pipe", "pipe", "pipe"],
 		});
 

package/extensions/agent-browser/lib/runtime.ts

@@ -768,8 +768,11 @@ export function chooseOpenResultTabCorrection(options: {
 }
 
 export function parseCommandInfo(args: string[]): CommandInfo {
-	const commands: string[] = [];
+	const commandTokens = extractCommandTokens(args);
+	return { command: commandTokens[0], subcommand: commandTokens[1] };
+}
 
+export function extractCommandTokens(args: string[]): string[] {
 	for (let index = 0; index < args.length; index += 1) {
 		const token = args[index];
 		if (token.startsWith("--session=")) {
@@ -782,11 +785,7 @@ export function parseCommandInfo(args: string[]): CommandInfo {
 			}
 			continue;
 		}
-		commands.push(token);
-		if (commands.length === 2) {
-			break;
-		}
+		return args.slice(index);
 	}
-
-	return { command: commands[0], subcommand: commands[1] };
+	return [];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-browser-native",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "pi extension that exposes agent-browser as a native tool for browser automation",
   "type": "module",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
@@ -46,9 +46,9 @@
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "@mariozechner/pi-coding-agent": "^0.67.2",
     "@sinclair/typebox": "^0.34.49",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2"
   },