pi-agent-browser-native 0.9.6 → 0.9.7

package/dist/extensions/agent-browser/index.js

@@ -855,6 +855,7 @@ var init_argv_grammar = __esm({
       "-q",
       "--verbose",
       "-v",
+      "--use-system-ca",
       "--webgpu"
     ]);
   }
@@ -1150,6 +1151,9 @@ var init_text = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/batch-stdin.js
+function isNativeBatchOption(token) {
+  return token === "--bail" || token === "--omit-command";
+}
 function normalizeUrlLessOpen(args, stdin, batchStep = false) {
   const { tokens, indices } = batchStep ? { tokens: args, indices: args.map((_, index) => index) } : projectUpstreamGlobalFlags(args);
   if (tokens[0] === "open" && !tokens.slice(1).some((token) => !token.startsWith("--"))) {
@@ -1159,7 +1163,7 @@ function normalizeUrlLessOpen(args, stdin, batchStep = false) {
   if (tokens[0] !== "batch") {
     return { args, stdin };
   }
-  if (tokens.slice(1).some((token) => token !== "--bail")) {
+  if (tokens.slice(1).some((token) => !isNativeBatchOption(token))) {
     return { args: normalizeRawBatchRows(args, tokens, indices), stdin };
   }
   const steps = parseUserBatchStdin(stdin).steps;
@@ -1175,7 +1179,7 @@ function normalizeUrlLessOpen(args, stdin, batchStep = false) {
 function normalizeRawBatchRows(args, tokens, indices) {
   let normalized;
   for (const [offset, token] of tokens.slice(1).entries()) {
-    if (token === "--bail") {
+    if (isNativeBatchOption(token)) {
       continue;
     }
     const step = parseBatchCommandArgument(token).step;
@@ -1251,20 +1255,37 @@ function parseUserBatchStdin(stdin) {
   return { steps };
 }
 function getUpstreamEffectiveBatchSteps(commandTokens, stdin) {
+  return getUpstreamBatchInputSteps(commandTokens, stdin).filter((step) => step.length > 0);
+}
+function getUpstreamBatchInputSteps(commandTokens, stdin) {
   if (commandTokens[0] !== "batch") {
     return [];
   }
   const argumentSteps = commandTokens.slice(1).flatMap((command) => {
-    if (command === "--bail") {
+    if (isNativeBatchOption(command)) {
       return [];
     }
     const step = parseBatchCommandArgument(command).step;
     return step ? [step] : [];
   });
-  if (commandTokens.slice(1).some((token) => token !== "--bail")) {
+  if (commandTokens.slice(1).some((token) => !isNativeBatchOption(token))) {
     return argumentSteps;
   }
-  return parseUserBatchStdin(stdin).steps?.filter((step) => step.length > 0) ?? [];
+  return parseUserBatchStdin(stdin).steps ?? [];
+}
+function resolveIndexedBatchCommands(envelope, commandTokens, stdin) {
+  if (commandTokens[0] !== "batch" || !commandTokens.slice(1).includes("--omit-command") || !Array.isArray(envelope?.data) || !envelope.data.some((row) => isRecord(row) && row.command === void 0 && row.index !== void 0)) {
+    return envelope;
+  }
+  const steps = getUpstreamBatchInputSteps(commandTokens, stdin);
+  const data = envelope.data.map((row) => {
+    if (!isRecord(row) || row.command !== void 0 || typeof row.index !== "number" || !Number.isSafeInteger(row.index) || row.index < 0) {
+      return row;
+    }
+    const command = steps.at(row.index);
+    return command !== void 0 && command.length > 0 ? { ...row, command } : row;
+  });
+  return { ...envelope, data };
 }
 var BATCH_STDIN_EXAMPLE, BatchWords;
 var init_batch_stdin = __esm({
@@ -1272,6 +1293,7 @@ var init_batch_stdin = __esm({
     "use strict";
     init_argv_grammar();
     init_shared();
+    init_parsing();
     init_text();
     BATCH_STDIN_EXAMPLE = ' Example: { "args": ["batch"], "stdin": "[[\\"get\\",\\"title\\"],[\\"get\\",\\"url\\"]]" }';
     BatchWords = class {
@@ -1711,7 +1733,7 @@ function redactBatchRows(args) {
     return replacements;
   }
   for (let index = 1; index < batch.tokens.length; index++) {
-    if (batch.tokens[index] === "--bail") {
+    if (isNativeBatchOption(batch.tokens[index])) {
       continue;
     }
     const step = parseBatchCommandArgument(batch.tokens[index]).step;
@@ -3895,15 +3917,30 @@ function snapshotDefinition(snapshot) {
 function snapshotMetadataValid(definition) {
   return (definition.target === void 0 || decodeBrowserTarget(definition.target) !== void 0) && (definition.generation === void 0 || typeof definition.generation === "string");
 }
-function snapshotFromDefinition(definition) {
-  if (!isRecord(definition) || typeof definition.id !== "string" || definition.id.length === 0 || !isRecord(definition.refs) || !snapshotMetadataValid(definition) || !Object.entries(definition.refs).every(([id, ref]) => /^e\d+$/.test(id) && isBrowserSnapshotReference(ref))) {
+function snapshotReferencesValid(refs) {
+  return Object.keys(refs).every((id) => SNAPSHOT_REF_ID.test(id) && isBrowserSnapshotReference(refs[id]));
+}
+function assertSnapshotDefinition(definition) {
+  if (!isRecord(definition) || typeof definition.id !== "string" || definition.id.length === 0 || !isRecord(definition.refs) || !snapshotMetadataValid(definition) || !snapshotReferencesValid(definition.refs)) {
     throw new Error("Missing or invalid browser snapshot definition; take a new complete snapshot before using refs.");
   }
-  const refs = Object.fromEntries(Object.entries(definition.refs).flatMap(([id, ref]) => isNamedBrowserSnapshotReference(ref) ? [[id, ref]] : []));
+}
+function snapshotFromDefinition(definition) {
+  assertSnapshotDefinition(definition);
+  const refIds = Object.keys(definition.refs);
+  const refs = {};
+  let named = false;
+  for (const id of refIds) {
+    const ref = definition.refs[id];
+    if (isNamedBrowserSnapshotReference(ref)) {
+      refs[id] = ref;
+      named = true;
+    }
+  }
   return {
     snapshotId: definition.id,
-    refIds: Object.keys(definition.refs),
-    ...Object.keys(refs).length > 0 ? { refs } : {},
+    refIds,
+    ...named ? { refs } : {},
     target: definition.target === void 0 ? void 0 : decodeBrowserTarget(definition.target),
     generation: typeof definition.generation === "string" ? definition.generation : void 0
   };
@@ -4005,7 +4042,7 @@ function applyArtifactChanges(previous, changes) {
 function appendBrowserTransition(pi, record) {
   pi.appendEntry(BROWSER_TRANSITION_ENTRY, record);
 }
-var BROWSER_EVENT_VERSION;
+var BROWSER_EVENT_VERSION, SNAPSHOT_REF_ID;
 var init_browser_transcript = __esm({
   "dist/extensions/agent-browser/lib/browser-transcript.js"() {
     "use strict";
@@ -4018,6 +4055,7 @@ var init_browser_transcript = __esm({
     init_browser_transcript_contracts();
     init_browser_transcript_validation();
     BROWSER_EVENT_VERSION = 1;
+    SNAPSHOT_REF_ID = /^e\d+$/;
   }
 });
 
@@ -4548,7 +4586,10 @@ function hasLaunchScopedFlagToken(args, flag) {
   const commandStartIndex = findCommandStartIndex(args);
   return commandStartIndex === void 0 || args[commandStartIndex] !== "wait" || args.indexOf(flag) < commandStartIndex;
 }
-var LAUNCH_SCOPED_FLAG_DEFINITIONS, LAUNCH_SCOPED_FLAGS, LAUNCH_SCOPED_FLAG_LABEL, OPEN_RESULT_TAB_CORRECTION_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_ENVS, MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS;
+function hasBrowserLaunchFlag(args) {
+  return BROWSER_LAUNCH_FLAGS.some((flag) => hasLaunchScopedFlagToken(args, flag));
+}
+var LAUNCH_SCOPED_FLAG_DEFINITIONS, LAUNCH_SCOPED_FLAGS, LAUNCH_SCOPED_FLAG_LABEL, OPEN_RESULT_TAB_CORRECTION_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_ENVS, MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS, HELPER_INHERITED_LAUNCH_FLAGS, BROWSER_LAUNCH_FLAGS;
 var init_launch_scoped_flags = __esm({
   "dist/extensions/agent-browser/lib/launch-scoped-flags.js"() {
     "use strict";
@@ -4739,6 +4780,10 @@ var init_launch_scoped_flags = __esm({
       "AGENT_BROWSER_ALLOW_FILE_ACCESS",
       "AGENT_BROWSER_WEBGPU"
     ];
+    HELPER_INHERITED_LAUNCH_FLAGS = /* @__PURE__ */ new Set(["--namespace", "--idle-timeout"]);
+    BROWSER_LAUNCH_FLAGS = [
+      .../* @__PURE__ */ new Set([...LAUNCH_SCOPED_FLAGS, ...MANAGED_RESTORE_INCOMPATIBLE_FLAGS])
+    ].filter((flag) => !HELPER_INHERITED_LAUNCH_FLAGS.has(flag));
   }
 });
 
@@ -4756,14 +4801,86 @@ var init_temp_mutation_queue = __esm({
   }
 });
 
+// dist/extensions/agent-browser/lib/browser-execution-policy-debug.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { debuglog } from "node:util";
+function debugPolicyFailure(stage, reason, error) {
+  if (!policyDebugEnabled) {
+    return;
+  }
+  const context2 = attempts?.getStore();
+  const code = nativeField(error, "code");
+  const syscall = nativeField(error, "syscall");
+  const exit = isRecord(error) && typeof error.code === "number" && Number.isSafeInteger(error.code) ? error.code : "-";
+  debug("attempt=%s phase=%s stage=%s reason=%s code=%s syscall=%s exit=%s", context2?.attempt ?? 0, context2?.phase ?? "standalone", stage, reason, code, syscall, exit);
+}
+function nativeField(error, field) {
+  const value = isRecord(error) ? error[field] : void 0;
+  if (typeof value !== "string") {
+    return "-";
+  }
+  if (field === "code") {
+    return /^(?:E[A-Z0-9]{1,24}|ABORT_ERR|ERR_[A-Z_]{1,48})$/.test(value) ? value : "unknown";
+  }
+  if (value.startsWith("spawn ")) {
+    return "spawn";
+  }
+  return syscalls.has(value) ? value : "unknown";
+}
+function withPolicyDebugAttempt(run) {
+  return attempts === void 0 ? run() : attempts.run({ attempt: ++nextAttempt, phase: "acquire" }, run);
+}
+function policyDebugPhase(phase, run) {
+  const context2 = attempts?.getStore();
+  return context2 === void 0 || attempts === void 0 ? run : () => attempts.run({ ...context2, phase }, run);
+}
+function policyDebugError(error) {
+  const code = nativeField(error, "code");
+  const syscall = nativeField(error, "syscall");
+  let normalizedCode = code === "-" ? void 0 : code;
+  if (isRecord(error) && typeof error.code === "number" && Number.isSafeInteger(error.code)) {
+    normalizedCode = error.code;
+  }
+  return { code: normalizedCode, syscall: syscall === "-" ? void 0 : syscall };
+}
+var debug, policyDebugEnabled, attempts, nextAttempt, syscalls;
+var init_browser_execution_policy_debug = __esm({
+  "dist/extensions/agent-browser/lib/browser-execution-policy-debug.js"() {
+    "use strict";
+    init_parsing();
+    debug = debuglog("pi-agent-browser-policy");
+    policyDebugEnabled = debug.enabled;
+    attempts = policyDebugEnabled ? new AsyncLocalStorage() : void 0;
+    nextAttempt = 0;
+    syscalls = /* @__PURE__ */ new Set([
+      "mkdir",
+      "lstat",
+      "stat",
+      "scandir",
+      "open",
+      "read",
+      "write",
+      "rename",
+      "rmdir",
+      "unlink",
+      "rm",
+      "kill",
+      "spawn",
+      "connect",
+      "listen"
+    ]);
+  }
+});
+
 // dist/extensions/agent-browser/lib/process-identity.js
 import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import { dirname, join, win32 } from "node:path";
 function getCurrentProcessUid() {
   return typeof process.getuid === "function" ? process.getuid() : void 0;
 }
 function buildProcessStartIdentityCommand(pid, platform = process.platform) {
-  if (!Number.isSafeInteger(pid) || pid <= 0) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || platform === "linux") {
     return void 0;
   }
   const configuredSystemRoot = process.env.SystemRoot;
@@ -4773,11 +4890,12 @@ function buildProcessStartIdentityCommand(pid, platform = process.platform) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      `$p = Get-Process -Id ${pid} -ErrorAction Stop; Write-Output ("${WINDOWS_PROCESS_START_IDENTITY_PREFIX}" + $p.StartTime.ToUniversalTime().Ticks)`
+      `$ErrorActionPreference = 'Stop'; $p = $null; try { $p = [System.Diagnostics.Process]::GetProcessById(${pid}); [long]$ticks = $p.StartTime.ToUniversalTime().Ticks; if ($ticks -le 0) { throw 'Process start ticks unavailable' }; [Console]::Out.WriteLine("${WINDOWS_PROCESS_START_IDENTITY_PREFIX}" + $ticks.ToString([Globalization.CultureInfo]::InvariantCulture)) } finally { if ($null -ne $p) { $p.Dispose() } }`
     ],
     file: win32.join(windowsSystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   } : {
     args: ["-p", String(pid), "-o", "lstart="],
+    env: { ...process.env, TZ: "UTC0", LC_ALL: "C" },
     file: platform === "android" ? join(dirname(process.execPath), "ps") : "/bin/ps"
   };
 }
@@ -4804,14 +4922,22 @@ function normalizeProcessStartIdentity(stdout) {
   }
   return trimmed.replace(/\s+/g, " ");
 }
+function debugIdentityBudget(budget) {
+  debugPolicyFailure("probe.budget", budget?.signal?.aborted === true ? "cancelled" : "deadline");
+}
 async function executeProcessStartIdentityCommand(command, budget = {}) {
-  if (budget.signal?.aborted === true || budget.deadline !== void 0 && Date.now() >= budget.deadline) {
+  if (budget.signal?.aborted === true || budget.deadline !== void 0 && performance.now() >= budget.deadline) {
+    debugIdentityBudget(budget);
     return void 0;
   }
-  const timeout = Math.max(1, Math.min(PROCESS_START_IDENTITY_TIMEOUT_MS, (budget.deadline ?? Infinity) - Date.now()));
+  const timeout = Math.max(1, Math.ceil(Math.min(PROCESS_START_IDENTITY_TIMEOUT_MS, (budget.deadline ?? Infinity) - performance.now())));
   return await new Promise((resolve19) => {
-    execFile(command.file, command.args, { timeout, signal: budget.signal }, (error, stdout) => {
-      resolve19(error ? void 0 : normalizeProcessStartIdentity(stdout));
+    execFile(command.file, command.args, { env: command.env, timeout, signal: budget.signal }, (error, stdout) => {
+      const identity = error ? void 0 : normalizeProcessStartIdentity(stdout);
+      if (identity === void 0) {
+        debugPolicyFailure("probe.execute", error ? "native-error" : "invalid-output", error);
+      }
+      resolve19(identity);
     });
   });
 }
@@ -4824,14 +4950,67 @@ async function resolveProcessStartIdentityFromCommands(commands, execute = execu
   }
   return void 0;
 }
+async function readLinuxProcfsText(path, budget) {
+  if (identityBudgetExpired(budget)) {
+    debugIdentityBudget(budget);
+    return void 0;
+  }
+  try {
+    return await readFile(path, { encoding: "latin1", signal: budget.signal });
+  } catch (error) {
+    debugPolicyFailure("probe.read", "native-error", error);
+    return void 0;
+  }
+}
+async function readLinuxBootId(budget) {
+  const bootId = (await readLinuxProcfsText(LINUX_BOOT_ID_PATH, budget))?.replace(/\n$/, "");
+  if (bootId === void 0 || !LINUX_BOOT_ID_PATTERN.test(bootId)) {
+    debugPolicyFailure("probe.boot-id", bootId === void 0 ? "unavailable" : "invalid-output");
+    return void 0;
+  }
+  return bootId;
+}
+function parseLinuxStartTicks(stat16, pid) {
+  const header = `${String(pid)} (`;
+  const commEnd = stat16.lastIndexOf(")");
+  if (!stat16.startsWith(header) || commEnd < header.length || stat16[commEnd + 1] !== " ") {
+    return void 0;
+  }
+  const ticks = stat16.slice(commEnd + 2).replace(/\n$/, "").split(" ").at(LINUX_STAT_START_TICKS_INDEX);
+  return ticks !== void 0 && /^[0-9]+$/.test(ticks) ? ticks : void 0;
+}
+async function readLinuxProcessStartIdentity(pid, budget = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return void 0;
+  }
+  const bootId = await readLinuxBootId(budget);
+  if (bootId === void 0) {
+    return void 0;
+  }
+  const stat16 = await readLinuxProcfsText(`/proc/${String(pid)}/stat`, budget);
+  if (stat16 === void 0) {
+    return void 0;
+  }
+  const ticks = parseLinuxStartTicks(stat16, pid);
+  if (ticks === void 0) {
+    debugPolicyFailure("probe.stat", "invalid-output");
+    return void 0;
+  }
+  return `${LINUX_PROCESS_START_IDENTITY_PREFIX}${bootId}:${ticks}`;
+}
 async function readUncachedProcessStartIdentity(pid, platform, budget) {
-  return await resolveProcessStartIdentityFromCommands(buildProcessStartIdentityCommands(pid, platform), (command) => executeProcessStartIdentityCommand(command, budget));
+  if (platform === "linux") {
+    return await readLinuxProcessStartIdentity(pid, budget);
+  }
+  const identity = await resolveProcessStartIdentityFromCommands(buildProcessStartIdentityCommands(pid, platform), (command) => executeProcessStartIdentityCommand(command, budget));
+  return identity === void 0 || platform === "win32" ? identity : `${POSIX_PROCESS_START_IDENTITY_PREFIX}${identity}`;
 }
 function identityBudgetExpired(budget) {
-  return budget?.signal?.aborted === true || budget?.deadline !== void 0 && Date.now() >= budget.deadline;
+  return budget?.signal?.aborted === true || budget?.deadline !== void 0 && performance.now() >= budget.deadline;
 }
 async function readProcessStartIdentity(pid, platform = process.platform, budget) {
   if (identityBudgetExpired(budget)) {
+    debugIdentityBudget(budget);
     return void 0;
   }
   if (pid !== process.pid || platform !== process.platform) {
@@ -4861,20 +5040,35 @@ async function readCachedProcessStartIdentity(pid, platform) {
   return await currentProcessStartIdentityPromise;
 }
 function processStartIdentitiesMatch(recorded, current) {
+  const format4 = PROCESS_START_IDENTITY_FORMATS.find((prefix) => current.startsWith(prefix));
+  if (format4 === void 0 || !recorded.startsWith(format4)) {
+    return void 0;
+  }
   return recorded === current;
 }
-var WINDOWS_PROCESS_START_IDENTITY_PREFIX, PROCESS_START_IDENTITY_TIMEOUT_MS, DEFAULT_WINDOWS_SYSTEM_ROOT, currentProcessStartIdentityPromise, currentProcessStartIdentity;
+var WINDOWS_PROCESS_START_IDENTITY_PREFIX, POSIX_PROCESS_START_IDENTITY_PREFIX, LINUX_PROCESS_START_IDENTITY_PREFIX, PROCESS_START_IDENTITY_FORMATS, PROCESS_START_IDENTITY_TIMEOUT_MS, DEFAULT_WINDOWS_SYSTEM_ROOT, LINUX_BOOT_ID_PATH, LINUX_BOOT_ID_PATTERN, LINUX_STAT_START_TICKS_INDEX, currentProcessStartIdentityPromise, currentProcessStartIdentity;
 var init_process_identity = __esm({
   "dist/extensions/agent-browser/lib/process-identity.js"() {
     "use strict";
+    init_browser_execution_policy_debug();
     WINDOWS_PROCESS_START_IDENTITY_PREFIX = "win32-powershell-ticks-v1:";
+    POSIX_PROCESS_START_IDENTITY_PREFIX = "posix-ps-utc-v1:";
+    LINUX_PROCESS_START_IDENTITY_PREFIX = "linux-proc-boot-ticks-v1:";
+    PROCESS_START_IDENTITY_FORMATS = [
+      WINDOWS_PROCESS_START_IDENTITY_PREFIX,
+      POSIX_PROCESS_START_IDENTITY_PREFIX,
+      LINUX_PROCESS_START_IDENTITY_PREFIX
+    ];
     PROCESS_START_IDENTITY_TIMEOUT_MS = process.platform === "win32" ? 1e4 : 5e3;
     DEFAULT_WINDOWS_SYSTEM_ROOT = "C:\\Windows";
+    LINUX_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id";
+    LINUX_BOOT_ID_PATTERN = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+    LINUX_STAT_START_TICKS_INDEX = 22 - 3;
   }
 });
 
 // dist/extensions/agent-browser/lib/temp-root-ownership.js
-import { chmod, readFile, readdir, rm, stat as stat3, writeFile } from "node:fs/promises";
+import { chmod, readFile as readFile2, readdir, rm, stat as stat3, writeFile } from "node:fs/promises";
 import { basename, dirname as dirname2, join as join2, resolve } from "node:path";
 function getCurrentProcessUid2() {
   return typeof process.getuid === "function" ? process.getuid() : void 0;
@@ -4930,7 +5124,7 @@ function validOwnershipAndChildren(value) {
 }
 async function readTempRootOwnershipMarker(tempRoot) {
   try {
-    const markerText = await readFile(join2(tempRoot, TEMP_ROOT_MARKER_FILE_NAME), "utf8");
+    const markerText = await readFile2(join2(tempRoot, TEMP_ROOT_MARKER_FILE_NAME), "utf8");
     const parsed = JSON.parse(markerText);
     return isTempRootOwnershipRecord(parsed) ? parsed : void 0;
   } catch {
@@ -5048,7 +5242,7 @@ async function refreshSecureTempRootLease(tempRoot) {
   const currentProcessStartIdentity2 = await getProcessStartIdentity(process.pid);
   if (ownershipMarker.ownerProcessStartIdentity !== void 0 && currentProcessStartIdentity2 !== void 0) {
     const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity2);
-    if (!identitiesMatch) {
+    if (identitiesMatch !== true) {
       return;
     }
   }
@@ -5083,6 +5277,9 @@ async function getMarkerOwnerLiveness(ownershipMarker) {
     return "unknown";
   }
   const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity2);
+  if (identitiesMatch === void 0) {
+    return "unknown";
+  }
   return identitiesMatch ? "alive" : "dead";
 }
 var TEMP_ROOT_MARKER_FILE_NAME, TEMP_ROOT_MARKER_KIND, TEMP_ROOT_MARKER_VERSION;
@@ -5470,7 +5667,7 @@ var init_temp = __esm({
 });
 
 // dist/extensions/agent-browser/lib/process-environment.js
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { rm as rm5 } from "node:fs/promises";
 function getAgentBrowserProcessEnvironment(baseEnv = process.env) {
   const isolatedConfig = isolatedAgentBrowserEnvironment.getStore();
@@ -5518,8 +5715,8 @@ var init_process_environment = __esm({
     "use strict";
     init_argv_grammar();
     init_temp();
-    isolatedAgentBrowserEnvironment = new AsyncLocalStorage();
-    agentBrowserProcessEnvironment = new AsyncLocalStorage();
+    isolatedAgentBrowserEnvironment = new AsyncLocalStorage2();
+    agentBrowserProcessEnvironment = new AsyncLocalStorage2();
     PROXY_ENV_NAMES = /* @__PURE__ */ new Set(["ALL_PROXY", "HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY"]);
   }
 });
@@ -5546,7 +5743,7 @@ var TARGET_AGENT_BROWSER_VERSION, TARGET_AGENT_BROWSER_VERSION_LABEL, MINIMUM_AG
 var init_agent_browser_target = __esm({
   "dist/scripts/agent-browser-target.mjs"() {
     "use strict";
-    TARGET_AGENT_BROWSER_VERSION = "0.38.1";
+    TARGET_AGENT_BROWSER_VERSION = "0.41.0";
     TARGET_AGENT_BROWSER_VERSION_LABEL = `agent-browser ${TARGET_AGENT_BROWSER_VERSION}`;
     MINIMUM_AGENT_BROWSER_VERSION = "0.35.0";
     MINIMUM_AGENT_BROWSER_VERSION_LABEL = `agent-browser ${MINIMUM_AGENT_BROWSER_VERSION}`;
@@ -6323,7 +6520,7 @@ var init_managed_session_storage = __esm({
 });
 
 // dist/extensions/agent-browser/lib/owned-managed-session-context.js
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 async function withOwnedManagedSessionContext(context2, run) {
   return await ownedManagedSessionStorage.run(context2, run);
 }
@@ -6372,7 +6569,7 @@ var init_owned_managed_session_context = __esm({
   "dist/extensions/agent-browser/lib/owned-managed-session-context.js"() {
     "use strict";
     init_argv_grammar();
-    ownedManagedSessionStorage = new AsyncLocalStorage2();
+    ownedManagedSessionStorage = new AsyncLocalStorage3();
   }
 });
 
@@ -6407,7 +6604,7 @@ function batchHasManagedSessionRestoreConflict(args, stdin) {
   if (command !== "batch") {
     return false;
   }
-  if (commandArgs.some((token) => token !== "--bail")) {
+  if (commandArgs.some((token) => !isNativeBatchOption(token))) {
     return true;
   }
   const parsed = parseUserBatchStdin(stdin);
@@ -8954,7 +9151,7 @@ __export(lookup_workspace_exports, {
   scanWorkspaceComponent: () => scanWorkspaceComponent,
   scanWorkspaceRequests: () => scanWorkspaceRequests
 });
-import { readFile as readFile2, readdir as readdir4 } from "node:fs/promises";
+import { readFile as readFile3, readdir as readdir4 } from "node:fs/promises";
 import { extname, join as join11 } from "node:path";
 async function walkWorkspaceSourceFiles(root, maxFiles) {
   const files = [];
@@ -8986,7 +9183,7 @@ async function walkWorkspaceSourceFiles(root, maxFiles) {
 }
 async function readWorkspaceText(file) {
   try {
-    return await readFile2(file, "utf8");
+    return await readFile3(file, "utf8");
   } catch {
     return void 0;
   }
@@ -9575,6 +9772,7 @@ var init_content = __esm({
       "failures",
       "artifacts",
       "artifactVerification",
+      "outputFile",
       "imageObservations",
       "fullOutputPath",
       "fullOutputPaths",
@@ -10319,7 +10517,7 @@ var init_artifact_format = __esm({
 });
 
 // dist/extensions/agent-browser/lib/results/presentation/artifact-images.js
-import { readFile as readFile3, stat as stat7 } from "node:fs/promises";
+import { readFile as readFile4, stat as stat7 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 import { inspect as inspect2 } from "node:util";
 import { getImageDimensions } from "@earendil-works/pi-tui";
@@ -10386,7 +10584,7 @@ async function attachVisibleImage(presentation, options) {
     appendPresentationNotice(presentation, `Image attachment skipped: ${formatByteCount(options.size)} exceeds the inline limit of ${formatByteCount(limit)}.`);
     return;
   }
-  const file = await readFile3(options.imagePath);
+  const file = await readFile4(options.imagePath);
   presentation.content.push({
     type: "image",
     data: file.toString("base64"),
@@ -10956,6 +11154,8 @@ function buildCompactObservation(observation2, persisted) {
     "sessionName",
     "namespace",
     "codeRun",
+    // A requested outputPath receipt is small and confirms the caller's side effect; keep it ahead of bulky fields.
+    "outputFile",
     "error",
     "failures",
     "nextActions",
@@ -10998,7 +11198,7 @@ async function renderAgentBrowserObservation(options) {
   let structuredContent = observation2;
   const images = options.content.filter((part) => part.type === "image");
   const prose = options.content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
-  const { data: _data, error: _error, summary: _summary, ...metadata } = observation2;
+  const { data: _data, error: _error, summary: _summary, outputFile: _outputFile, ...metadata } = observation2;
   let text3 = options.json ? JSON.stringify(observation2, null, 2) : `${prose}
 
 Observation: ${JSON.stringify(metadata)}`;
@@ -11984,6 +12184,7 @@ var init_process_stdout = __esm({
 // dist/extensions/agent-browser/lib/process-child.js
 import { spawn } from "node:child_process";
 import { platform as processPlatform } from "node:process";
+import { constants as constants3 } from "node:os";
 import { spawn as crossSpawn } from "cross-spawn";
 async function terminateSpawnedChild(child, signal) {
   if (processPlatform === "win32" && child.pid !== void 0 && child.pid !== 0) {
@@ -12010,6 +12211,9 @@ function resolveSpawnedChildExitCode(input) {
   if (input.useExitFallback && input.exitCode !== null && input.exitCode !== void 0) {
     return input.exitCode;
   }
+  if (input.exitSignal !== null && input.exitSignal !== void 0) {
+    return 128 + constants3.signals[input.exitSignal];
+  }
   return input.spawnError ? 127 : 0;
 }
 function destroySpawnedChildStreams(child) {
@@ -12049,21 +12253,24 @@ var init_process_child = __esm({
       context;
       exited = false;
       exitCode = null;
+      exitSignal = null;
       timer;
       completed = false;
       constructor(child, complete, context2) {
         this.complete = complete;
         this.context = context2;
-        child.once("exit", (code) => {
+        child.once("exit", (code, signal) => {
           this.exited = true;
           this.exitCode = code;
+          this.exitSignal = signal;
           this.timer = setTimeout(() => {
             destroySpawnedChildStreams(child);
             this.finish();
           }, EXIT_STDIO_GRACE_MS);
           this.timer.unref();
         });
-        child.once("close", (code) => {
+        child.once("close", (code, signal) => {
+          this.exitSignal = signal ?? this.exitSignal;
           this.finish(code);
         });
       }
@@ -12077,10 +12284,11 @@ var init_process_child = __esm({
         this.complete(resolveSpawnedChildExitCode({
           closeCode,
           exitCode: this.exitCode,
+          exitSignal: this.exitSignal,
           useExitFallback: this.exited,
           timedOut: context2.timedOut,
           spawnError: context2.spawnError
-        }));
+        }), this.exitSignal ?? void 0);
       }
       clear() {
         if (this.timer) {
@@ -12096,6 +12304,7 @@ var init_process_child = __esm({
       agentBrowserStarted = false;
       settled = false;
       spawnError;
+      exitSignal;
       stderr = "";
       stdout = new ProcessStdout();
       pendingTermination;
@@ -12142,8 +12351,8 @@ var init_process_child = __esm({
             spawnError: this.spawnError
           }));
         });
-        this.completion = new ChildCompletion(child, (code) => {
-          this.finish(code);
+        this.completion = new ChildCompletion(child, (code, signal) => {
+          this.finish(code, signal);
         }, () => ({ timedOut: this.timedOut, spawnError: this.spawnError }));
         child.stdout.on("data", (chunk) => {
           this.stdout.queue(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -12212,11 +12421,12 @@ var init_process_child = __esm({
           this.child.stdin.destroy();
         }
       }
-      finish(exitCode) {
+      finish(exitCode, exitSignal) {
         if (this.settled) {
           return;
         }
         this.settled = true;
+        this.exitSignal = exitSignal;
         if (this.abortListener) {
           this.options.signal?.removeEventListener("abort", this.abortListener);
           this.abortListener = void 0;
@@ -12250,6 +12460,7 @@ var init_process_child = __esm({
           aborted: this.aborted,
           agentBrowserStarted: this.agentBrowserStarted,
           exitCode,
+          exitSignal: this.exitSignal,
           spawnError: this.spawnError,
           stderr: this.stderr,
           stdout,
@@ -12337,7 +12548,7 @@ function getBatchCommandSteps(args, stdin) {
   if (descriptor.commandInfo.command !== "batch") {
     return { steps: [] };
   }
-  const argumentsToParse = descriptor.upstreamCommandTokens.slice(1).filter((command) => command !== "--bail");
+  const argumentsToParse = descriptor.upstreamCommandTokens.slice(1).filter((command) => !isNativeBatchOption(command));
   if (argumentsToParse.length > 0) {
     return inspectBatchArguments(argumentsToParse);
   }
@@ -12839,7 +13050,7 @@ var init_process_socket_storage = __esm({
 });
 
 // dist/extensions/agent-browser/lib/process.js
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 import { env as processEnv2 } from "node:process";
 function withChromeStartupArgs(args, run) {
   return chromeStartupArgsContext.run(args ?? chromeStartupArgsContext.getStore(), run);
@@ -13037,8 +13248,8 @@ var init_process = __esm({
     PI_AGENT_BROWSER_PROCESS_TIMEOUT_ENV = "PI_AGENT_BROWSER_PROCESS_TIMEOUT_MS";
     SAFE_AGENT_BROWSER_OPERATION_TIMEOUT_MS = 25e3;
     DEFAULT_AGENT_BROWSER_PROCESS_TIMEOUT_MS = 35e3;
-    attachedBrowserSessionContext = new AsyncLocalStorage4();
-    chromeStartupArgsContext = new AsyncLocalStorage4();
+    attachedBrowserSessionContext = new AsyncLocalStorage5();
+    chromeStartupArgsContext = new AsyncLocalStorage5();
   }
 });
 
@@ -13098,7 +13309,7 @@ var init_envelope_decoding = __esm({
 });
 
 // dist/extensions/agent-browser/lib/results/envelope.js
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 function hasStructuredBatchStepFailure(data) {
   return Array.isArray(data) && data.some((item) => isRecord(item) && item.success === false);
 }
@@ -13107,7 +13318,7 @@ async function readEnvelopeSource(options) {
     return options.stdout;
   }
   try {
-    return await readFile5(options.stdoutPath, "utf8");
+    return await readFile6(options.stdoutPath, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : stringifyUnknown(error);
     throw new Error(`agent-browser output spill file could not be read: ${message}`, {
@@ -13232,10 +13443,24 @@ function getTransportErrorText(options) {
     return options.spawnError.message;
   }
   if ((options.parseError ?? "") !== "") {
-    return options.exitCode !== 0 && options.stderr.trim().length > 0 ? options.stderr.trim() : options.parseError;
+    return malformedProcessErrorText(options);
   }
   return void 0;
 }
+function malformedProcessErrorText(options) {
+  if (options.exitCode === 0 && options.exitSignal === void 0) {
+    return options.parseError;
+  }
+  const signalText = options.exitSignal === void 0 ? void 0 : `Signal: ${options.exitSignal}.`;
+  const oomHint = options.exitSignal === "SIGKILL" || options.exitCode === 137 ? "SIGKILL may indicate an OOM kill or an external stop. Inspect the host kernel log and cgroup memory.events before retrying; the command may have executed." : void 0;
+  return [
+    buildExitCodeFallback(options),
+    signalText,
+    options.stderr.trim(),
+    options.stderr.trim().length > 0 ? void 0 : options.parseError,
+    oomHint
+  ].filter(Boolean).join("\n");
+}
 function getEnvelopeDataError(data) {
   if (typeof data === "string") {
     return data;
@@ -13286,7 +13511,7 @@ var init_envelope = __esm({
 });
 
 // dist/extensions/agent-browser/lib/webmcp-observation.js
-import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
 function getNativeWebMcpCatalog(data) {
   if (Array.isArray(data)) {
     for (let index = data.length - 1; index >= 0; index -= 1) {
@@ -13321,12 +13546,12 @@ var init_webmcp_observation = __esm({
   "dist/extensions/agent-browser/lib/webmcp-observation.js"() {
     "use strict";
     init_parsing();
-    observation = new AsyncLocalStorage5();
+    observation = new AsyncLocalStorage6();
   }
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/session-state-commands.js
-import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
 import { rm as rm6 } from "node:fs/promises";
 function withSessionCommandObservation(observer, run) {
   return sessionCommandObservation.run(observer, run);
@@ -13441,7 +13666,7 @@ var init_session_state_commands = __esm({
     init_confirmation();
     init_envelope();
     init_webmcp_observation();
-    sessionCommandObservation = new AsyncLocalStorage6();
+    sessionCommandObservation = new AsyncLocalStorage7();
   }
 });
 
@@ -15016,7 +15241,7 @@ function hasProcessExited(child, pid) {
   return child ? child.exitCode !== null || child.signalCode !== null : isPidAlive(pid) === false;
 }
 async function waitForProcessExit(child, pid, deadlineMs) {
-  while (Date.now() <= deadlineMs) {
+  while (performance.now() <= deadlineMs) {
     if (hasProcessExited(child, pid)) {
       return true;
     }
@@ -15032,7 +15257,7 @@ async function getRestoredProcessVerificationError(record) {
   if (currentIdentity === void 0) {
     return `PID ${String(record.pid)} is alive, but its current start identity could not be inspected; refusing to signal a restored PID that may have been reused.`;
   }
-  if (!processStartIdentitiesMatch(record.startIdentity, currentIdentity)) {
+  if (processStartIdentitiesMatch(record.startIdentity, currentIdentity) !== true) {
     return `PID ${String(record.pid)} is alive, but its start identity does not match the wrapper launch record; refusing to signal a restored PID that may have been reused.`;
   }
   return void 0;
@@ -15091,7 +15316,7 @@ async function cleanupRestoredProcess(record, deadlineMs) {
     return { error: killVerificationError, resource: "process", state: "failed" };
   }
   signalRestoredLaunchProcess(record, "SIGKILL");
-  if (await waitForProcessExit(void 0, record.pid, Date.now() + 1e3)) {
+  if (await waitForProcessExit(void 0, record.pid, performance.now() + 1e3)) {
     return { resource: "process", state: "removed" };
   }
   return {
@@ -15114,7 +15339,7 @@ async function cleanupTrackedProcess(record, child, deadlineMs) {
   } else {
     killPid(record.pid, "SIGKILL");
   }
-  if (await waitForProcessExit(child, record.pid, Date.now() + 1e3)) {
+  if (await waitForProcessExit(child, record.pid, performance.now() + 1e3)) {
     return { resource: "process", state: "removed" };
   }
   return {
@@ -15176,7 +15401,7 @@ function summarizeCleanup(launchId, steps) {
 }
 async function cleanupElectronLaunchResources(options) {
   const timeoutMs = typeof options.timeoutMs === "number" && Number.isSafeInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : ELECTRON_CLEANUP_DEFAULT_TIMEOUT_MS;
-  const deadlineMs = Date.now() + timeoutMs;
+  const deadlineMs = performance.now() + timeoutMs;
   const processStep = await cleanupProcess(options.record, options.child, deadlineMs);
   const debugPortStep = await cleanupDebugPort(options.record);
   const userDataDirSkipReason = shouldSkipUserDataDirCleanup(processStep, debugPortStep);
@@ -15298,17 +15523,25 @@ function directoryOwnerTrusted(entry, platform) {
   return uid !== void 0 && entry.uid === uid && (entry.mode & 63) === 0;
 }
 async function ensureCoordinationDirectory(path, platform) {
+  let stage = "prepare.directory-mkdir";
   try {
     try {
       await mkdir3(path, { mode: 448 });
     } catch (error) {
       if (getErrorCode(error) !== "EEXIST") {
+        debugPolicyFailure(stage, "native-error", error);
         return false;
       }
     }
+    stage = "prepare.directory-stat";
     const entry = await lstat3(path);
-    return !entry.isSymbolicLink() && entry.isDirectory() && directoryOwnerTrusted(entry, platform);
-  } catch {
+    const trusted = !entry.isSymbolicLink() && entry.isDirectory() && directoryOwnerTrusted(entry, platform);
+    if (!trusted) {
+      debugPolicyFailure(stage, "unsafe-metadata");
+    }
+    return trusted;
+  } catch (error) {
+    debugPolicyFailure(stage, "native-error", error);
     return false;
   }
 }
@@ -15344,13 +15577,143 @@ var init_browser_execution_identity = __esm({
     init_process_socket_storage();
     init_process_identity();
     init_process_errors();
+    init_browser_execution_policy_debug();
+  }
+});
+
+// dist/extensions/agent-browser/lib/browser-execution-claim-endpoint.js
+import { unlink } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { dirname as dirname11, join as join19 } from "node:path";
+function claimEndpointPath(claimPath, token) {
+  return join19(dirname11(claimPath), `.l-${token}`);
+}
+function openClaimEndpoint(claimPath, token) {
+  if (!endpointsSupported) {
+    return void 0;
+  }
+  const server = createServer();
+  const subscribers = /* @__PURE__ */ new Set();
+  let closed = false;
+  const close = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    server.close();
+    for (const subscriber of subscribers) {
+      subscriber.destroy();
+    }
+    subscribers.clear();
+  };
+  server.on("connection", (subscriber) => {
+    subscriber.unref();
+    subscribers.add(subscriber);
+    subscriber.on("error", () => {
+    });
+    subscriber.on("close", () => {
+      subscribers.delete(subscriber);
+    });
+    subscriber.resume();
+  });
+  server.on("error", (error) => {
+    debugPolicyFailure("endpoint.listen", "native-error", error);
+    close();
+  });
+  server.unref();
+  server.listen(claimEndpointPath(claimPath, token));
+  return { close };
+}
+async function removeClaimEndpoint(claimPath, token) {
+  if (!endpointsSupported) {
+    return;
+  }
+  try {
+    await unlink(claimEndpointPath(claimPath, token));
+  } catch (error) {
+    if (getErrorCode(error) !== "ENOENT") {
+      debugPolicyFailure("endpoint.unlink", "native-error", error);
+    }
+  }
+}
+function sleep2(signal, deadline, setWake) {
+  return new Promise((resolve19) => {
+    const timer = setTimeout(done, Math.max(0, Math.min(deadline - performance.now(), MAX_TIMER_MS)));
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      setWake(void 0);
+      resolve19();
+    }
+    setWake(done);
+    signal?.addEventListener("abort", done, { once: true });
+    if (signal?.aborted === true) {
+      done();
+    }
+  });
+}
+async function subscribeClaimEndpoint(claimPath, token, signal, deadline) {
+  if (!endpointsSupported) {
+    return void 0;
+  }
+  let connected = false;
+  let disconnected = false;
+  let wake;
+  const open6 = () => connected && !disconnected;
+  const setWake = (next) => {
+    wake = next;
+  };
+  const socket = createConnection(claimEndpointPath(claimPath, token));
+  socket.on("error", (error) => {
+    if (!connected) {
+      debugPolicyFailure("endpoint.connect", "unavailable", error);
+    }
+    disconnected = true;
+    wake?.();
+  });
+  socket.on("close", () => {
+    disconnected = true;
+    wake?.();
+  });
+  socket.once("connect", () => {
+    connected = true;
+    wake?.();
+  });
+  await sleep2(signal, deadline, setWake);
+  if (!open6()) {
+    socket.destroy();
+    return void 0;
+  }
+  socket.resume();
+  return {
+    token,
+    connected: open6,
+    wait: async (waitSignal, waitDeadline) => {
+      if (!disconnected) {
+        await sleep2(waitSignal, waitDeadline, setWake);
+      }
+    },
+    close: () => {
+      wake = void 0;
+      socket.destroy();
+    }
+  };
+}
+var endpointsSupported, MAX_TIMER_MS;
+var init_browser_execution_claim_endpoint = __esm({
+  "dist/extensions/agent-browser/lib/browser-execution-claim-endpoint.js"() {
+    "use strict";
+    init_browser_execution_policy_debug();
+    init_process_errors();
+    endpointsSupported = process.platform !== "win32";
+    MAX_TIMER_MS = 2147483647;
   }
 });
 
 // dist/extensions/agent-browser/lib/browser-execution-claim-storage.js
 import { randomInt as randomInt2, randomUUID as randomUUID6 } from "node:crypto";
-import { lstat as lstat4, readFile as readFile6, readdir as readdir6, rename, rm as rm8 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname11, join as join19 } from "node:path";
+import { lstat as lstat4, readFile as readFile7, readdir as readdir6, rename, rm as rm8 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname12, join as join20 } from "node:path";
 function secureEntry(entry, directory) {
   if (entry.isSymbolicLink() || (directory ? !entry.isDirectory() : !entry.isFile())) {
     return false;
@@ -15367,60 +15730,99 @@ function secureEntryOwnership(entry, mask) {
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   return uid !== void 0 && entry.uid === uid && (entry.mode & mask) === 0;
 }
-async function readClaimTicket(path, owner) {
-  const ticketPath = join19(path, LOCK_TICKET_FILE);
+async function readClaimTicket(path, owner, report) {
+  const ticketPath = join20(path, LOCK_TICKET_FILE);
+  let stage = "claim.ticket-stat";
   try {
     if (!secureEntry(await lstat4(ticketPath), false)) {
+      report?.(stage, "unsafe-metadata");
       return void 0;
     }
-    const ticket = parseTicket(await readFile6(ticketPath, "utf8"), owner.token);
+    stage = "claim.ticket-read";
+    const ticket = parseTicket(await readFile7(ticketPath, "utf8"), owner.token);
+    if (ticket === void 0) {
+      report?.(stage, "invalid-ticket-or-token");
+    }
     return ticket === void 0 ? void 0 : { owner, path, ticket };
   } catch (error) {
-    return getErrorCode(error) === "ENOENT" ? { owner, path, ticket: null } : void 0;
+    const code = getErrorCode(error);
+    if (code !== "ENOENT") {
+      report?.(stage, "native-error", error);
+    }
+    return code === "ENOENT" ? { owner, path, ticket: null } : void 0;
   }
 }
-async function readClaim(path) {
+async function inspectClaim(path, report) {
+  let stage = "claim.directory-stat";
   try {
     const directory = await lstat4(path);
-    const ownerPath = join19(path, LOCK_OWNER_FILE);
+    const ownerPath = join20(path, LOCK_OWNER_FILE);
+    stage = "claim.owner-stat";
     const ownerEntry = await lstat4(ownerPath);
     if (!secureEntry(directory, true) || !secureEntry(ownerEntry, false)) {
+      report?.("claim.metadata", "unsafe-directory-or-owner");
       return void 0;
     }
-    const owner = parseOwner(await readFile6(ownerPath, "utf8"));
-    return owner ? await readClaimTicket(path, owner) : void 0;
-  } catch {
+    stage = "claim.owner-read";
+    const owner = parseOwner(await readFile7(ownerPath, "utf8"));
+    if (!owner) {
+      report?.(stage, "invalid-owner");
+    }
+    return owner ? await readClaimTicket(path, owner, report) : void 0;
+  } catch (error) {
+    report?.(stage, "native-error", error);
     return void 0;
   }
 }
+function reportDirectClaimFailure(stage, reason, error) {
+  if (getErrorCode(error) !== "ENOENT") {
+    debugPolicyFailure(stage, reason, error);
+  }
+}
+function readClaim(path) {
+  return inspectClaim(path, policyDebugEnabled ? reportDirectClaimFailure : void 0);
+}
 async function claimDisappeared(path) {
   try {
     await lstat4(path);
     return false;
   } catch (error) {
-    return getErrorCode(error) === "ENOENT";
+    const code = getErrorCode(error);
+    if (code !== "ENOENT") {
+      debugPolicyFailure("claims.absence-stat", "absence-not-confirmed", error);
+    }
+    return code === "ENOENT";
   }
 }
 async function readClaims(basePath) {
-  const directory = dirname11(basePath);
+  const directory = dirname12(basePath);
   const prefix = `${basename5(basePath)}.claim-`;
   let names;
   try {
     names = await readdir6(directory);
-  } catch {
+  } catch (error) {
+    debugPolicyFailure("claims.readdir", "native-error", error);
     return void 0;
   }
   const claims = [];
   for (const name of names.filter((candidate) => candidate.startsWith(prefix))) {
-    const path = join19(directory, name);
-    const claim = await readClaim(path);
+    const path = join20(directory, name);
+    let failure;
+    const claim = await inspectClaim(path, policyDebugEnabled ? (stage, reason, error) => {
+      failure = { stage, reason, error: policyDebugError(error) };
+    } : void 0);
     if (!claim) {
       if (await claimDisappeared(path)) {
         continue;
       }
+      if (failure !== void 0) {
+        debugPolicyFailure(failure.stage, failure.reason, failure.error);
+      }
+      debugPolicyFailure("claims.inspect", "absence-not-confirmed");
       return void 0;
     }
     if (name !== `${prefix}${claim.owner.token}`) {
+      debugPolicyFailure("claims.inspect", "published-owner-token-mismatch");
       return void 0;
     }
     claims.push(claim);
@@ -15436,6 +15838,7 @@ async function ownerAlive(owner, budget) {
       return false;
     }
     if (code !== "EPERM") {
+      debugPolicyFailure("owner.liveness", "native-error", error);
       return void 0;
     }
   }
@@ -15460,6 +15863,7 @@ function waitForRetry(signal) {
 async function moveOwnedClaim(path, movedPath, token, deadline) {
   while (true) {
     if ((await readClaim(path))?.owner.token !== token) {
+      debugPolicyFailure("remove.verify", "owner-missing-or-token-mismatch");
       return void 0;
     }
     try {
@@ -15470,18 +15874,20 @@ async function moveOwnedClaim(path, movedPath, token, deadline) {
       if (code === "ENOENT") {
         return "absent";
       }
-      if (process.platform !== "win32" || code !== "EPERM" || Date.now() >= deadline) {
+      if (process.platform !== "win32" || code !== "EPERM" || performance.now() >= deadline) {
+        debugPolicyFailure("remove.rename", "native-error", error);
         return void 0;
       }
       await waitForRetry();
-      if (Date.now() >= deadline) {
+      if (performance.now() >= deadline) {
+        debugPolicyFailure("remove.rename", "retry-deadline", error);
         return void 0;
       }
     }
   }
 }
 async function removeClaimOwnedBy(path, token, deadline = 0) {
-  const movedPath = join19(dirname11(path), `.pi-agent-browser-policy-remove-${token}-${randomUUID6()}`);
+  const movedPath = join20(dirname12(path), `.pi-agent-browser-policy-remove-${token}-${randomUUID6()}`);
   const movement = await moveOwnedClaim(path, movedPath, token, deadline);
   if (movement === "absent") {
     return true;
@@ -15491,13 +15897,21 @@ async function removeClaimOwnedBy(path, token, deadline = 0) {
   }
   const moved = await readClaim(movedPath);
   if (moved?.owner.token !== token) {
+    debugPolicyFailure("remove.moved-verify", "owner-missing-or-token-mismatch");
     try {
       await rename(movedPath, path);
-    } catch {
+    } catch (error) {
+      debugPolicyFailure("remove.restore-rename", "native-error", error);
     }
     return false;
   }
-  await rm8(movedPath, { force: true, recursive: true });
+  try {
+    await rm8(movedPath, { force: true, recursive: true });
+  } catch (error) {
+    debugPolicyFailure("remove.rm", "native-error", error);
+    throw error;
+  }
+  await removeClaimEndpoint(path, token);
   return true;
 }
 function gcBatch(names) {
@@ -15512,7 +15926,7 @@ function gcBatch(names) {
   return batch;
 }
 async function cleanDeadClaim(directory, name, budget) {
-  const path = join19(directory, name);
+  const path = join20(directory, name);
   const published = name.includes(".lock-v4.claim-");
   if (published) {
     const entry = await lstat4(path).catch(() => void 0);
@@ -15536,7 +15950,7 @@ async function cleanDeadPolicyArtifacts(directory, budget) {
     return;
   }
   for (const name of gcBatch(names)) {
-    if (budget.signal?.aborted === true || Date.now() >= (budget.deadline ?? Infinity)) {
+    if (budget.signal?.aborted === true || performance.now() >= (budget.deadline ?? Infinity)) {
       return;
     }
     await cleanDeadClaim(directory, name, budget);
@@ -15548,6 +15962,8 @@ var init_browser_execution_claim_storage = __esm({
     "use strict";
     init_process_identity();
     init_process_errors();
+    init_browser_execution_claim_endpoint();
+    init_browser_execution_policy_debug();
     init_browser_execution_claim_codec();
     POLICY_LOCK_WAIT_MS = 1e3;
     LOCK_OWNER_FILE = "owner.json";
@@ -15560,7 +15976,7 @@ var init_browser_execution_claim_storage = __esm({
 // dist/extensions/agent-browser/lib/browser-execution-claims.js
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { lstat as lstat5, mkdir as mkdir4, rename as rename2, rm as rm9, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function claimPrecedes(left, right) {
   if (left.ticket === null) {
     return true;
@@ -15585,45 +16001,55 @@ function relevantPredecessor(claim, ownClaim) {
   const sessions = claim.owner.sessionNames;
   return ownSessions === null || sessions === null || ownSessions.some((session) => sessions.includes(session));
 }
-async function claimBlocks(claim, ownClaim, budget) {
+async function blockingPredecessor(claim, ownClaim, budget) {
   if (!relevantPredecessor(claim, ownClaim) || await hasPublishedLaterTicket(claim, ownClaim)) {
-    return false;
+    return void 0;
+  }
+  if (!await claimStillExists(claim.path)) {
+    return void 0;
   }
   const alive = await ownerAlive(claim.owner, budget);
   if (alive === false) {
     await removeClaimOwnedBy(claim.path, claim.owner.token);
-    return false;
+    return void 0;
   }
   if (!await claimStillExists(claim.path)) {
-    return false;
+    return void 0;
   }
-  return !await hasPublishedLaterTicket(claim, ownClaim);
+  return await hasPublishedLaterTicket(claim, ownClaim) ? void 0 : { claim, ownerConfirmed: alive === true };
 }
 async function claimStillExists(path) {
   try {
     await lstat5(path);
     return true;
   } catch (error) {
-    return getErrorCode(error) !== "ENOENT";
+    const code = getErrorCode(error);
+    if (code !== "ENOENT") {
+      debugPolicyFailure("acquire.predecessor-stat", "presence-unresolved", error);
+    }
+    return code !== "ENOENT";
   }
 }
-async function anyPredecessorBlocks(claims, own, budget) {
+async function firstBlockingPredecessor(claims, own, budget) {
   for (const claim of claims) {
-    if (await claimBlocks(claim, own, budget)) {
-      return true;
+    const blocking = await blockingPredecessor(claim, own, budget);
+    if (blocking) {
+      return blocking;
     }
   }
-  return false;
+  return void 0;
 }
 async function prepareClaim(identity, budget) {
   const directory = getCoordinationDirectory(process.platform);
   if (!await ensureCoordinationDirectory(directory, process.platform)) {
+    debugPolicyFailure("acquire.prepare", "directory-unavailable");
     return void 0;
   }
   const basePath = getBrowserExecutionLockPath(identity);
   const token = randomUUID7();
   const startIdentity = await readProcessStartIdentity(process.pid, process.platform, budget);
   if (startIdentity === void 0 || startIdentity.length === 0) {
+    debugPolicyFailure("acquire.prepare", "start-identity-unavailable");
     return void 0;
   }
   const owner = {
@@ -15635,6 +16061,7 @@ async function prepareClaim(identity, budget) {
   };
   const content = JSON.stringify(owner);
   if (Buffer.byteLength(content) > POLICY_LOCK_MAX_BYTES) {
+    debugPolicyFailure("acquire.prepare", "owner-too-large");
     return void 0;
   }
   return {
@@ -15646,59 +16073,164 @@ async function prepareClaim(identity, budget) {
     path: `${basePath}.claim-${token}`
   };
 }
-async function publishClaim(claim) {
-  await mkdir4(claim.candidatePath, { mode: 448 });
-  await writeFile2(join20(claim.candidatePath, LOCK_OWNER_FILE), claim.content, {
-    encoding: "utf8",
-    flag: "wx",
-    mode: 384
-  });
-  await rename2(claim.candidatePath, claim.path);
+function publicationRetryAvailable(budget) {
+  return budget.deadline !== void 0 && budget.signal?.aborted !== true && performance.now() < budget.deadline;
+}
+function candidateMatchesPreparedClaim(candidate, claim) {
+  if (!candidate || candidate.ticket !== null) {
+    return false;
+  }
+  const { owner } = candidate;
+  const expected = claim.owner;
+  const sessions = owner.sessionNames;
+  const expectedSessions = expected.sessionNames;
+  const identityFields = ["token", "pid", "startIdentity", "version"];
+  return identityFields.every((field) => owner[field] === expected[field]) && (expectedSessions === null ? sessions === null : sessions !== null && sessions.length === expectedSessions.length && sessions.every((session, index) => session === expectedSessions[index]));
+}
+async function publishCandidate(claim, budget) {
+  while (true) {
+    try {
+      await rename2(claim.candidatePath, claim.path);
+      return true;
+    } catch (error) {
+      if (process.platform !== "win32" || getErrorCode(error) !== "EPERM" || !publicationRetryAvailable(budget)) {
+        throw error;
+      }
+      await waitForRetry(budget.signal);
+      if (!publicationRetryAvailable(budget)) {
+        throw error;
+      }
+      const candidate = await readClaim(claim.candidatePath);
+      if (!candidateMatchesPreparedClaim(candidate, claim)) {
+        debugPolicyFailure("publish.verify", "candidate-unconfirmed", error);
+        return false;
+      }
+      if (!publicationRetryAvailable(budget)) {
+        throw error;
+      }
+    }
+  }
+}
+async function publishClaim(claim, budget) {
+  let stage = "publish.mkdir";
+  try {
+    await mkdir4(claim.candidatePath, { mode: 448 });
+    stage = "publish.owner-write";
+    await writeFile2(join21(claim.candidatePath, LOCK_OWNER_FILE), claim.content, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    stage = "publish.rename";
+    return await publishCandidate(claim, budget);
+  } catch (error) {
+    debugPolicyFailure(stage, "native-error", error);
+    throw error;
+  }
 }
 async function publishTicket(claim) {
   const claims = await readClaims(claim.basePath);
   if (!claims) {
+    debugPolicyFailure("ticket.scan", "claims-unavailable");
     return void 0;
   }
   const maxTicket = claims.reduce((max, entry) => entry.ticket === null ? max : Math.max(max, entry.ticket), 0);
   if (!Number.isSafeInteger(maxTicket + 1)) {
+    debugPolicyFailure("ticket.number", "unsafe-ticket-number");
     return void 0;
   }
   const ticket = { ticket: maxTicket + 1, token: claim.owner.token, version: 4 };
-  const candidate = join20(claim.path, `.ticket-${claim.owner.token}.tmp`);
-  await writeFile2(candidate, JSON.stringify(ticket), { encoding: "utf8", flag: "wx", mode: 384 });
-  await rename2(candidate, join20(claim.path, LOCK_TICKET_FILE));
+  const candidate = join21(claim.path, `.ticket-${claim.owner.token}.tmp`);
+  let stage = "ticket.write";
+  try {
+    await writeFile2(candidate, JSON.stringify(ticket), {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    stage = "ticket.rename";
+    await rename2(candidate, join21(claim.path, LOCK_TICKET_FILE));
+  } catch (error) {
+    debugPolicyFailure(stage, "native-error", error);
+    throw error;
+  }
   return ticket.ticket;
 }
 function acquisitionCancelled(budget) {
   return budget.signal?.aborted === true;
 }
-async function waitForTurn(claim, ticket, budget, deadline) {
-  while (budget.signal?.aborted !== true) {
-    const claims = await readClaims(claim.basePath);
-    if (!claims) {
-      return false;
-    }
-    const own = claims.find((entry) => entry.owner.token === claim.owner.token);
-    if (!own || own.ticket !== ticket) {
-      return false;
-    }
-    if (!await anyPredecessorBlocks(claims, own, budget)) {
-      await cleanDeadPolicyArtifacts(claim.directory, budget);
-      return !acquisitionCancelled(budget);
+function createPredecessorWait() {
+  let subscription;
+  const attempted = /* @__PURE__ */ new Set();
+  const close = () => {
+    subscription?.close();
+    subscription = void 0;
+  };
+  return {
+    close,
+    wait: async (blocking, budget, deadline) => {
+      const { token } = blocking.claim.owner;
+      if (subscription?.token === token && subscription.connected()) {
+        await subscription.wait(budget.signal, deadline);
+        return;
+      }
+      close();
+      if (blocking.ownerConfirmed && blocking.claim.ticket !== null && !attempted.has(token)) {
+        attempted.add(token);
+        subscription = await subscribeClaimEndpoint(blocking.claim.path, token, budget.signal, deadline);
+        return;
+      }
+      await waitForRetry(budget.signal);
     }
-    if (Date.now() >= deadline) {
-      return false;
+  };
+}
+async function waitForTurn(claim, ticket, budget, deadline) {
+  const predecessorWait = createPredecessorWait();
+  try {
+    while (budget.signal?.aborted !== true) {
+      const claims = await readClaims(claim.basePath);
+      if (!claims) {
+        debugPolicyFailure("acquire.wait-scan", "claims-unavailable");
+        return false;
+      }
+      const own = claims.find((entry) => entry.owner.token === claim.owner.token);
+      if (!own || own.ticket !== ticket) {
+        debugPolicyFailure("acquire.own-claim", !own ? "missing" : "ticket-mismatch");
+        return false;
+      }
+      const blocking = await firstBlockingPredecessor(claims, own, budget);
+      if (!blocking) {
+        return await acquireTurn(claim, budget);
+      }
+      if (performance.now() >= deadline) {
+        debugPolicyFailure("acquire.wait", "deadline");
+        return false;
+      }
+      await predecessorWait.wait(blocking, budget, deadline);
     }
-    await waitForRetry(budget.signal);
+    debugPolicyFailure("acquire.wait", "cancelled");
+    return false;
+  } finally {
+    predecessorWait.close();
   }
-  return false;
+}
+async function acquireTurn(claim, budget) {
+  await cleanDeadPolicyArtifacts(claim.directory, budget);
+  const cancelled = acquisitionCancelled(budget);
+  if (cancelled) {
+    debugPolicyFailure("acquire.turn", "cancelled");
+  }
+  return !cancelled;
 }
 function acquisitionDeadline(options) {
-  return options.deadline ?? Date.now() + (options.timeoutMs ?? POLICY_LOCK_WAIT_MS);
+  return options.deadline ?? performance.now() + (options.timeoutMs ?? POLICY_LOCK_WAIT_MS);
 }
-async function acquireExecutionClaim(options) {
-  if (options.signal?.aborted === true) {
+function acquireExecutionClaim(options) {
+  return policyDebugEnabled ? withPolicyDebugAttempt(() => acquireClaim(options)) : acquireClaim(options);
+}
+async function acquireClaim(options) {
+  if (acquisitionCancelled(options)) {
+    debugPolicyFailure("acquire.begin", "cancelled");
     return void 0;
   }
   const deadline = acquisitionDeadline(options);
@@ -15712,41 +16244,68 @@ async function acquireExecutionClaim(options) {
   }
   let published = false;
   let acquired = false;
+  let cleanupCandidate = true;
+  let endpoint;
   try {
-    await publishClaim(claim);
+    if (!await publishClaim(claim, budget)) {
+      cleanupCandidate = false;
+      return void 0;
+    }
     published = true;
+    endpoint = openClaimEndpoint(claim.path, claim.owner.token);
     const ticket = await publishTicket(claim);
     if (ticket === void 0 || !await waitForTurn(claim, ticket, budget, deadline)) {
       return void 0;
     }
     acquired = true;
     return {
-      release: async () => {
-        await removeClaimOwnedBy(claim.path, claim.owner.token, Date.now() + POLICY_LOCK_WAIT_MS);
-      }
+      release: policyDebugPhase("release", async () => removeOwnClaim(claim, endpoint, "release.complete"))
     };
-  } catch {
+  } catch (error) {
+    debugPolicyFailure("acquire.complete", "native-error", error);
     return void 0;
   } finally {
-    await rm9(claim.candidatePath, { force: true, recursive: true }).catch(() => void 0);
+    await cleanupUnpublishedCandidate(claim, cleanupCandidate);
     if (published && !acquired) {
-      await removeClaimOwnedBy(claim.path, claim.owner.token, Date.now() + POLICY_LOCK_WAIT_MS);
+      await removeOwnClaim(claim, endpoint, "cleanup.complete");
     }
   }
 }
+async function removeOwnClaim(claim, endpoint, stage) {
+  try {
+    const removed = await removeClaimOwnedBy(claim.path, claim.owner.token, performance.now() + POLICY_LOCK_WAIT_MS);
+    debugRemovalResult(removed, stage);
+  } finally {
+    endpoint?.close();
+  }
+}
+async function cleanupUnpublishedCandidate(claim, permitted) {
+  if (permitted) {
+    await rm9(claim.candidatePath, { force: true, recursive: true }).catch((error) => {
+      debugPolicyFailure("cleanup.candidate-rm", "native-error", error);
+    });
+  }
+}
+function debugRemovalResult(removed, stage) {
+  if (!removed) {
+    debugPolicyFailure(stage, "claim-not-removed");
+  }
+}
 var init_browser_execution_claims = __esm({
   "dist/extensions/agent-browser/lib/browser-execution-claims.js"() {
     "use strict";
     init_process_errors();
+    init_browser_execution_policy_debug();
     init_process_identity();
     init_browser_execution_claim_codec();
     init_browser_execution_identity();
+    init_browser_execution_claim_endpoint();
     init_browser_execution_claim_storage();
   }
 });
 
 // dist/extensions/agent-browser/lib/managed-session-policy-lock.js
-import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
 function groupExecutionIdentities(identities) {
   if (identities.length === 0) {
     throw new Error("Browser execution coordination requires at least one identity.");
@@ -15821,10 +16380,10 @@ async function withBrowserExecutionLocks(options, run) {
   const signals = [controller.signal, options.signal, parent?.signal].filter((signal2) => signal2 !== void 0);
   const signal = AbortSignal.any(signals);
   const expire = () => controller.abort(new DOMException("Browser execution deadline exceeded.", "TimeoutError"));
-  const remaining = options.deadline - Date.now();
+  const remaining = options.deadline - performance.now();
   const timer = setTimeout(expire, Math.max(0, Math.min(remaining, 2147483647)));
   const checkBudget = () => {
-    if (Date.now() >= options.deadline) {
+    if (performance.now() >= options.deadline) {
       expire();
     }
     signal.throwIfAborted();
@@ -15900,7 +16459,7 @@ var init_managed_session_policy_lock = __esm({
     init_browser_execution_claims();
     init_browser_execution_identity();
     init_browser_execution_identity();
-    executionScope = new AsyncLocalStorage7();
+    executionScope = new AsyncLocalStorage8();
   }
 });
 
@@ -15913,13 +16472,31 @@ function getRunningHeadedAutosavePolicyChangeError(recordedInterval, closeComman
 function getHeadedManagedAutosaveEnv(interval) {
   return interval !== void 0 ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: interval } : void 0;
 }
+function isDaemonGeneration(value) {
+  return isRecord(value) && typeof value.pid === "number" && Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.start === "string" && value.start !== "" && typeof value.socketDir === "string";
+}
+function managedSessionDaemonGenerationsMatch(recorded, current) {
+  if (recorded === void 0 || current === void 0) {
+    return void 0;
+  }
+  try {
+    const previous = JSON.parse(recorded);
+    const observed = JSON.parse(current);
+    if (!isDaemonGeneration(previous) || !isDaemonGeneration(observed)) {
+      return void 0;
+    }
+    return previous.pid !== observed.pid || previous.socketDir !== observed.socketDir ? false : processStartIdentitiesMatch(previous.start, observed.start);
+  } catch {
+    return void 0;
+  }
+}
 async function readDaemonGeneration(runtime, options) {
   if (options.includeGeneration !== true || typeof runtime.backgroundPid !== "number" || !Number.isSafeInteger(runtime.backgroundPid) || runtime.backgroundPid <= 0 || typeof runtime.socketDir !== "string" || runtime.browserLaunched === false) {
     return void 0;
   }
   const start = await readProcessStartIdentity(runtime.backgroundPid, process.platform, {
     signal: options.signal,
-    deadline: Date.now() + (options.timeoutMs ?? 5e3)
+    deadline: performance.now() + (options.timeoutMs ?? 5e3)
   });
   return start !== void 0 && start !== "" ? JSON.stringify({
     pid: runtime.backgroundPid,
@@ -16089,17 +16666,17 @@ async function closeUnderPolicy(options, lifecycle) {
 async function closeWithDeadline(options) {
   const controller = new AbortController();
   let phase = "policy coordination";
-  let phaseStartedAt = Date.now();
+  let phaseStartedAt = performance.now();
   let timeoutError2;
   const timer = setTimeout(() => {
-    timeoutError2 = `Managed-session cleanup timed out after ${options.timeoutMs} ms during ${phase} (${Date.now() - phaseStartedAt} ms in this phase).`;
+    timeoutError2 = `Managed-session cleanup timed out after ${options.timeoutMs} ms during ${phase} (${Math.round(performance.now() - phaseStartedAt)} ms in this phase).`;
     controller.abort();
   }, options.timeoutMs);
   const lifecycle = {
     signal: controller.signal,
     enterPhase: (nextPhase) => {
       phase = nextPhase;
-      phaseStartedAt = Date.now();
+      phaseStartedAt = performance.now();
     },
     clearTimer: () => {
       clearTimeout(timer);
@@ -16205,7 +16782,7 @@ function reconcileDaemonReceipt(context2, daemon, receipt) {
   if (daemon.status !== "active" || receipt === void 0 || context2.restoreState.hasDaemonRestoreKey(context2.sessionName, context2.namespace)) {
     return;
   }
-  if (daemon.generation === receipt.generation && daemon.restoreKey === receipt.restoreKey) {
+  if (managedSessionDaemonGenerationsMatch(receipt.generation, daemon.generation) === true && daemon.restoreKey === receipt.restoreKey) {
     context2.restoreState.recordDaemonRestoreKey(context2.sessionName, context2.namespace, daemon.restoreKey, daemon.generation);
   } else {
     context2.restoreState.forgetDaemonRestoreKey(context2.sessionName, context2.namespace);
@@ -16403,7 +16980,7 @@ var init_branch = __esm({
 // dist/extensions/agent-browser/lib/electron/discovery-evidence.js
 import { constants as fsConstants } from "node:fs";
 import { access as access2, readdir as readdir7, realpath as realpath2, stat as stat9 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname12, extname as extname4, join as join21 } from "node:path";
+import { basename as basename6, dirname as dirname13, extname as extname4, join as join22 } from "node:path";
 async function isDirectory(path) {
   try {
     return (await stat9(path)).isDirectory();
@@ -16445,19 +17022,19 @@ async function directoryContainsChromePak(directory) {
   }
 }
 async function hasElectronAppPayload(resourcesDirectory) {
-  return await pathExists(join21(resourcesDirectory, "app.asar")) || await pathExists(join21(resourcesDirectory, "default_app.asar")) || await isDirectory(join21(resourcesDirectory, "app"));
+  return await pathExists(join22(resourcesDirectory, "app.asar")) || await pathExists(join22(resourcesDirectory, "default_app.asar")) || await isDirectory(join22(resourcesDirectory, "app"));
 }
 async function hasLinuxElectronEvidence(executablePath) {
   const resolved = await resolveRealPath(executablePath);
   if (!await isExecutableFile(resolved)) {
     return false;
   }
-  const directory = dirname12(resolved);
+  const directory = dirname13(resolved);
   if (!await directoryContainsChromePak(directory)) {
     return false;
   }
-  for (const base of [directory, dirname12(directory)]) {
-    if (await hasElectronAppPayload(join21(base, "resources"))) {
+  for (const base of [directory, dirname13(directory)]) {
+    if (await hasElectronAppPayload(join22(base, "resources"))) {
       return true;
     }
   }
@@ -16468,9 +17045,9 @@ async function inspectWin32Executable(executablePath) {
   if (!await isExecutableFile(resolved)) {
     return void 0;
   }
-  const directory = dirname12(resolved);
-  const hasAppPayload = await hasElectronAppPayload(join21(directory, "resources"));
-  const hasPak = await directoryContainsChromePak(directory) || await pathExists(join21(directory, "resources.pak"));
+  const directory = dirname13(resolved);
+  const hasAppPayload = await hasElectronAppPayload(join22(directory, "resources"));
+  const hasPak = await directoryContainsChromePak(directory) || await pathExists(join22(directory, "resources.pak"));
   if (!hasAppPayload || !hasPak) {
     return void 0;
   }
@@ -16488,8 +17065,8 @@ var init_discovery_evidence = __esm({
 });
 
 // dist/extensions/agent-browser/lib/electron/discovery-darwin.js
-import { readdir as readdir8, readFile as readFile7 } from "node:fs/promises";
-import { basename as basename7, join as join22 } from "node:path";
+import { readdir as readdir8, readFile as readFile8 } from "node:fs/promises";
+import { basename as basename7, join as join23 } from "node:path";
 function readPlistString(plist, key) {
   const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const match = new RegExp(`<key>\\s*${escapedKey}\\s*</key>\\s*<string>([\\s\\S]*?)</string>`, "i").exec(plist);
@@ -16497,7 +17074,7 @@ function readPlistString(plist, key) {
 }
 async function readMacInfoPlist(appPath) {
   try {
-    const plist = await readFile7(join22(appPath, "Contents", "Info.plist"), "utf8");
+    const plist = await readFile8(join23(appPath, "Contents", "Info.plist"), "utf8");
     return {
       CFBundleDisplayName: readPlistString(plist, "CFBundleDisplayName") ?? "",
       CFBundleExecutable: readPlistString(plist, "CFBundleExecutable") ?? "",
@@ -16509,15 +17086,15 @@ async function readMacInfoPlist(appPath) {
   }
 }
 async function resolveMacExecutablePath(appPath, executableName, fallbackName) {
-  const directory = join22(appPath, "Contents", "MacOS");
+  const directory = join23(appPath, "Contents", "MacOS");
   if (executableName !== void 0 && executableName.trim().length > 0) {
-    const path = join22(directory, executableName);
+    const path = join23(directory, executableName);
     return await pathExists(path) ? path : void 0;
   }
   try {
     const entries = await readdir8(directory, { withFileTypes: true });
     const candidate = entries.find((entry) => entry.isFile() && entry.name === fallbackName) ?? entries.find((entry) => entry.isFile());
-    return candidate ? join22(directory, candidate.name) : void 0;
+    return candidate ? join23(directory, candidate.name) : void 0;
   } catch {
     return void 0;
   }
@@ -16526,11 +17103,11 @@ function firstNonempty(values) {
   return values.find((value) => value !== void 0 && value.length > 0);
 }
 async function inspectDarwinApp(appPath) {
-  const framework = join22(appPath, "Contents", "Frameworks", "Electron Framework.framework");
+  const framework = join23(appPath, "Contents", "Frameworks", "Electron Framework.framework");
   if (!await isDirectory(framework)) {
     return void 0;
   }
-  if (!await hasElectronAppPayload(join22(appPath, "Contents", "Resources"))) {
+  if (!await hasElectronAppPayload(join23(appPath, "Contents", "Resources"))) {
     return void 0;
   }
   const info = await readMacInfoPlist(appPath);
@@ -16561,7 +17138,7 @@ async function inspectDirectory(directory) {
       continue;
     }
     try {
-      const app = await inspectDarwinApp(join22(directory, entry.name));
+      const app = await inspectDarwinApp(join23(directory, entry.name));
       if (app) {
         apps.push(app);
       }
@@ -16726,7 +17303,7 @@ var init_discovery_desktop = __esm({
 
 // dist/extensions/agent-browser/lib/electron/discovery-packages.js
 import { readdir as readdir9 } from "node:fs/promises";
-import { basename as basename9, extname as extname5, isAbsolute as isAbsolute6, join as join23, relative, resolve as resolve9 } from "node:path";
+import { basename as basename9, extname as extname5, isAbsolute as isAbsolute6, join as join24, relative, resolve as resolve9 } from "node:path";
 function pathIsWithin(path, parent) {
   const relativePath = relative(resolve9(parent), resolve9(path));
   return relativePath.length === 0 || !relativePath.startsWith("..") && !isAbsolute6(relativePath);
@@ -16739,7 +17316,7 @@ async function findExecutableInPath(command, pathEnv) {
     if (directory.length === 0) {
       continue;
     }
-    const candidate = join23(directory, command);
+    const candidate = join24(directory, command);
     if (await isFile(candidate)) {
       return candidate;
     }
@@ -16750,7 +17327,7 @@ async function resolveSnapExecutable(commandPath, entry, locations) {
   const commandName = basename9(commandPath);
   const names = [commandName, commandName.split(".")[0] ?? "", entry.desktopId.split(".")[0] ?? ""];
   for (const snapName of new Set(names.filter((name) => name.length > 0))) {
-    const root = join23(locations.snapMountDirectory, snapName, "current");
+    const root = join24(locations.snapMountDirectory, snapName, "current");
     const candidate = await new ElectronBinarySearch([
       commandName,
       commandName.split(".").at(-1) ?? commandName
@@ -16783,7 +17360,7 @@ function getFlatpakCommandName(tokens) {
   return void 0;
 }
 function getFlatpakRoots(entry, locations) {
-  const userExport = join23(locations.homeDir, ".local", "share", "flatpak", "exports", "share", "applications");
+  const userExport = join24(locations.homeDir, ".local", "share", "flatpak", "exports", "share", "applications");
   if (pathIsWithin(entry.filePath, userExport)) {
     return [locations.flatpakUserAppDirectory, locations.flatpakSystemAppDirectory];
   }
@@ -16796,7 +17373,7 @@ async function resolveFlatpakExecutable(tokens, entry, locations) {
   const appId = getFlatpakAppId(tokens, entry.desktopId);
   const commandName = getFlatpakCommandName(tokens);
   for (const root of getFlatpakRoots(entry, locations)) {
-    const candidate = await new ElectronBinarySearch(commandName === void 0 ? [] : [commandName]).find(join23(root, appId, "current", "active", "files"));
+    const candidate = await new ElectronBinarySearch(commandName === void 0 ? [] : [commandName]).find(join24(root, appId, "current", "active", "files"));
     if (candidate !== void 0) {
       return candidate;
     }
@@ -16866,7 +17443,7 @@ var init_discovery_packages = __esm({
         return void 0;
       }
       async inspectEntry(directory, entry, depth) {
-        const path = join23(directory, entry.name);
+        const path = join24(directory, entry.name);
         if (entry.isDirectory()) {
           return this.visit(path, depth + 1);
         }
@@ -16884,8 +17461,8 @@ var init_discovery_packages = __esm({
 });
 
 // dist/extensions/agent-browser/lib/electron/discovery-linux.js
-import { readdir as readdir10, readFile as readFile8 } from "node:fs/promises";
-import { basename as basename10, extname as extname6, isAbsolute as isAbsolute7, join as join24 } from "node:path";
+import { readdir as readdir10, readFile as readFile9 } from "node:fs/promises";
+import { basename as basename10, extname as extname6, isAbsolute as isAbsolute7, join as join25 } from "node:path";
 async function resolveLinuxExecutable(entry, locations) {
   const tokens = stripEnvLauncher(tokenizeDesktopExec(entry.exec));
   const token = tokens.at(0);
@@ -16909,7 +17486,7 @@ async function resolveLinuxExecutable(entry, locations) {
 async function inspectLinuxDesktopFile(filePath, locations) {
   let text3;
   try {
-    text3 = await readFile8(filePath, "utf8");
+    text3 = await readFile9(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -16945,7 +17522,7 @@ async function inspectDirectory2(directory, locations) {
       continue;
     }
     try {
-      const app = await inspectLinuxDesktopFile(join24(directory, entry.name), locations);
+      const app = await inspectLinuxDesktopFile(join25(directory, entry.name), locations);
       if (app) {
         apps.push(app);
       }
@@ -16987,7 +17564,7 @@ __export(discovery_exports, {
   inspectElectronExecutablePath: () => inspectElectronExecutablePath
 });
 import { homedir as homedir3 } from "node:os";
-import { basename as basename11, join as join25, resolve as resolve10 } from "node:path";
+import { basename as basename11, join as join26, resolve as resolve10, sep } from "node:path";
 function normalizeSensitivityValue(value) {
   const normalized = value?.trim().replace(/[_./\\-]+/g, " ").replace(/\s+/g, " ");
   return normalized === void 0 || normalized.length === 0 ? void 0 : normalized;
@@ -17021,17 +17598,17 @@ function normalizeMaxResults(value) {
 }
 function linuxDesktopDirectories(locations, homeDir) {
   return locations?.linuxDesktopDirectories ?? [
-    join25(homeDir, ".local", "share", "applications"),
+    join26(homeDir, ".local", "share", "applications"),
     "/usr/share/applications",
     "/var/lib/snapd/desktop/applications",
-    join25(homeDir, ".local", "share", "flatpak", "exports", "share", "applications"),
+    join26(homeDir, ".local", "share", "flatpak", "exports", "share", "applications"),
     "/var/lib/flatpak/exports/share/applications"
   ];
 }
 function resolvePackageLocations(locations, homeDir) {
   return {
     flatpakSystemAppDirectory: locations?.flatpakSystemAppDirectory ?? "/var/lib/flatpak/app",
-    flatpakUserAppDirectory: locations?.flatpakUserAppDirectory ?? join25(homeDir, ".local", "share", "flatpak", "app"),
+    flatpakUserAppDirectory: locations?.flatpakUserAppDirectory ?? join26(homeDir, ".local", "share", "flatpak", "app"),
     snapBinDirectory: locations?.snapBinDirectory ?? "/snap/bin",
     snapMountDirectory: locations?.snapMountDirectory ?? "/snap"
   };
@@ -17043,7 +17620,7 @@ function resolveLocations(locations) {
     homeDir,
     darwinApplicationDirectories: locations?.darwinApplicationDirectories ?? [
       "/Applications",
-      join25(homeDir, "Applications")
+      join26(homeDir, "Applications")
     ],
     linuxDesktopDirectories: linuxDesktopDirectories(locations, homeDir),
     pathEnv: locations?.pathEnv ?? process.env.PATH ?? ""
@@ -17083,12 +17660,12 @@ function sortApps(apps) {
   });
 }
 function findMacAppBundleAncestor(path) {
-  const parts = resolve10(path).split(/[\\/]+/);
+  const parts = resolve10(path).split(sep);
   const index = parts.findIndex((part) => part.endsWith(".app"));
   if (index < 0) {
     return void 0;
   }
-  const ancestor = parts.slice(0, index + 1).join("/");
+  const ancestor = parts.slice(0, index + 1).join(sep);
   return ancestor.length > 0 ? ancestor : "/";
 }
 async function inspectElectronExecutablePath(executablePath, platform = process.platform) {
@@ -19466,7 +20043,7 @@ var init_timeout_diagnostics = __esm({
 // dist/extensions/agent-browser/lib/executable-path.js
 import { constants as fsConstants2 } from "node:fs";
 import { access as access3, stat as stat11 } from "node:fs/promises";
-import { delimiter, join as join26 } from "node:path";
+import { delimiter, join as join27 } from "node:path";
 async function isExecutableFile2(candidate) {
   try {
     await access3(candidate, fsConstants2.X_OK);
@@ -19477,7 +20054,7 @@ async function isExecutableFile2(candidate) {
 }
 async function executableExistsOnPath(command) {
   const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
-  const candidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((directory) => extensions.map((extension) => join26(directory, `${command}${extension}`)));
+  const candidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((directory) => extensions.map((extension) => join27(directory, `${command}${extension}`)));
   for (const candidate of candidates) {
     if (await isExecutableFile2(candidate)) {
       return true;
@@ -20102,6 +20679,7 @@ function nativeObservationDetails(options, lifecycle, browserWindow) {
     recordingRecovery: options.presentation.recordingRecovery,
     readConfirmation: options.presentation.readConfirmation,
     exitCode: options.processResult.exitCode,
+    exitSignal: options.processResult.exitSignal,
     parseError: options.plainTextInspection ? void 0 : options.parseError,
     stderr: options.processResult.stderr,
     stdout: options.plainTextInspection ? options.inspectionText ?? "" : void 0,
@@ -22745,11 +23323,12 @@ var init_batch_redaction = __esm({
 function createStepIdentity(item, index) {
   const command = isStringArray2(item.command) ? item.command : void 0;
   const redactedCommand = command ? redactInvocationArgs(command) : void 0;
+  const visibleCommand = hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command;
   return {
     command,
     redactedCommand,
-    index,
-    commandText: formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index),
+    index: item.index ?? index,
+    commandText: formatBatchStepCommand(item.index === void 0 ? visibleCommand : void 0, item.index ?? index),
     lifecycle: extractAgentBrowserLifecycle(item.result)
   };
 }
@@ -22930,12 +23509,16 @@ async function buildBatchStepPresentation(options) {
   const identity = createStepIdentity(options.item, options.index);
   const scope = { namespace: options.namespace, sessionName: options.sessionName };
   if (options.item.success === false && identity.command?.[0] !== "record") {
-    return buildFailedStep(options.item, identity, scope);
+    return {
+      ...buildFailedStep(options.item, identity, scope),
+      nativeIndex: options.item.index
+    };
   }
   const request = buildNestedRequest(options, identity.command);
   const presentation = await options.buildNestedToolPresentation(request);
   return {
     details: buildStepDetails(presentation, identity, request.commandInfo, scope),
+    nativeIndex: options.item.index,
     presentation
   };
 }
@@ -23121,6 +23704,9 @@ function scanTypingRun(steps, start) {
   return typedStepCount >= 2 ? { nextIndex: index, typedCharCount, delayMs } : void 0;
 }
 function getTypingStart(steps, index) {
+  if (steps.at(index)?.nativeIndex !== void 0) {
+    return void 0;
+  }
   const details = steps.at(index)?.details;
   if (!details || !details.success) {
     return void 0;
@@ -23243,13 +23829,20 @@ function formatBatchStatusText(steps, status, modelVisible) {
   ].filter((line) => line !== void 0).join("\n\n");
 }
 function serializeBatchData(steps) {
-  return steps.map(({ details }) => details.success ? { command: details.command, result: details.data, success: true } : {
-    command: details.command,
+  return steps.map(({ details, nativeIndex }) => details.success ? {
+    ...batchResultIdentity(details.command, nativeIndex),
+    result: details.data,
+    success: true
+  } : {
+    ...batchResultIdentity(details.command, nativeIndex),
     error: details.text,
     ...details.command?.[0] === "record" ? { result: details.data } : {},
     success: false
   });
 }
+function batchResultIdentity(command, index) {
+  return index === void 0 ? { command } : { index };
+}
 function formatBatchChangeText(observed, unverified) {
   if (observed === 0) {
     return `batch \u2192 ${unverified} action${unverified === 1 ? "" : "s"} dispatched \u2192 application change unverified`;
@@ -23289,7 +23882,7 @@ var init_batch_summary = __esm({
 
 // dist/extensions/agent-browser/lib/results/presentation/batch.js
 function isAgentBrowserBatchResultArray(value) {
-  return Array.isArray(value) && value.every((row) => isRecord(row) && (row.command === void 0 || isStringArray2(row.command)) && (row.success === void 0 || typeof row.success === "boolean"));
+  return Array.isArray(value) && value.every((row) => isRecord(row) && (row.command === void 0 || isStringArray2(row.command)) && (row.index === void 0 || typeof row.index === "number" && Number.isSafeInteger(row.index) && row.index >= 0) && (row.success === void 0 || typeof row.success === "boolean"));
 }
 async function collectPresentedSteps(options) {
   const steps = [];
@@ -23678,6 +24271,12 @@ function stateShowText(data) {
   }
   return lines.join("\n");
 }
+function stateLoadText(data) {
+  const loaded = `State loaded: ${redactModelFacingText(getStringField(data, "path") ?? getStringField(data, "name") ?? "ok")}`;
+  const skipped = (getArrayField(data, "skippedOrigins") ?? []).filter((origin) => typeof origin === "string");
+  return skipped.length === 0 ? loaded : `${loaded}
+Skipped storage for origins (page did not stay on that origin): ${redactModelFacingText(skipped.join(", "))}`;
+}
 function formatStateText(data, subcommand) {
   if (subcommand === "show") {
     return stateShowText(data);
@@ -23687,7 +24286,7 @@ function formatStateText(data, subcommand) {
     return states.length === 0 ? "No saved states." : states.map(stateLine).join("\n");
   }
   if (data.loaded === true) {
-    return `State loaded: ${redactModelFacingText(getStringField(data, "path") ?? getStringField(data, "name") ?? "ok")}`;
+    return stateLoadText(data);
   }
   return data.cleared === true || data.clear === true ? "State cleared." : void 0;
 }
@@ -23730,6 +24329,7 @@ var init_diagnostic_identity = __esm({
       "compatibilityStatus",
       "restoreKey",
       "restoreStatus",
+      "restoreSkippedOrigins",
       "restoreLoadedPath",
       "restoreValidationPending",
       "restoreSave",
@@ -25214,7 +25814,7 @@ function redactBatchSpillData(data) {
     const command = isStringArray2(row.command) ? row.command : void 0;
     return {
       ...row,
-      command: command ? redactInvocationArgs(command) : row.command,
+      command: row.index === void 0 && command ? redactInvocationArgs(command) : void 0,
       error: row.error === void 0 ? void 0 : redactBatchStepErrorData(command, row.error),
       result: row.result === void 0 ? void 0 : redactPresentationData(parseCommandInfo(command ?? []), row.result)
     };
@@ -25734,7 +26334,7 @@ var init_prepare_failure = __esm({
 });
 
 // dist/extensions/agent-browser/lib/electron/launch-monitor.js
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 function isElectronLaunchAborted(signal) {
   return signal?.aborted ?? false;
 }
@@ -25759,7 +26359,7 @@ function activePortReadError(error) {
 async function readDevToolsActivePort(userDataDir) {
   const path = `${userDataDir}/DevToolsActivePort`;
   try {
-    const text3 = await readFile11(path, "utf8");
+    const text3 = await readFile12(path, "utf8");
     const port = Number(text3.split(/\r?\n/)[0].trim());
     const valid = Number.isSafeInteger(port) && port > 0 && port <= 65535;
     return {
@@ -25774,7 +26374,7 @@ async function readDevToolsActivePort(userDataDir) {
 }
 async function pollDevToolsActivePort(options) {
   let devToolsActivePort;
-  while (Date.now() <= options.deadlineMs) {
+  while (performance.now() <= options.deadlineMs) {
     if (isElectronLaunchAborted(options.signal)) {
       return { devToolsActivePort, failure: "aborted" };
     }
@@ -25798,7 +26398,7 @@ async function pollDevToolsActivePort(options) {
   return { devToolsActivePort, failure: "timeout" };
 }
 async function pollCdpMetadata(port, deadlineMs, signal) {
-  while (Date.now() <= deadlineMs) {
+  while (performance.now() <= deadlineMs) {
     if (isElectronLaunchAborted(signal)) {
       return { aborted: true };
     }
@@ -25830,7 +26430,7 @@ var init_launch_monitor = __esm({
 // dist/extensions/agent-browser/lib/electron/launch-process.js
 import { spawn as spawn3 } from "node:child_process";
 import { open as open5 } from "node:fs/promises";
-import { dirname as dirname16, join as join30 } from "node:path";
+import { dirname as dirname17, join as join31 } from "node:path";
 async function closeOutputHandle(file) {
   try {
     await file.close();
@@ -25925,11 +26525,11 @@ var init_launch_process = __esm({
       async spawn(executablePath, args, signal) {
         const handles = [];
         try {
-          handles.push(await open5(join30(this.userDataDir, "stdout.log"), "wx", 384));
-          handles.push(await open5(join30(this.userDataDir, "stderr.log"), "wx", 384));
+          handles.push(await open5(join31(this.userDataDir, "stdout.log"), "wx", 384));
+          handles.push(await open5(join31(this.userDataDir, "stderr.log"), "wx", 384));
           signal?.throwIfAborted();
           this.process = spawn3(executablePath, args, {
-            cwd: dirname16(executablePath),
+            cwd: dirname17(executablePath),
             detached: process.platform !== "win32",
             stdio: ["ignore", handles[0].fd, handles[1].fd]
           });
@@ -25960,12 +26560,13 @@ var init_launch_process = __esm({
           return isRecord(error) && error.code === "EPERM";
         }
       }
+      /** Waits for exit until deadlineMs, a performance.now() timestamp unaffected by wall-clock steps. */
       async waitForExit(deadlineMs) {
         const child = this.process;
         if (child === void 0) {
           return true;
         }
-        while (Date.now() <= deadlineMs) {
+        while (performance.now() <= deadlineMs) {
           if (child.exitCode !== null || child.signalCode !== null) {
             return true;
           }
@@ -25990,14 +26591,14 @@ var init_launch_process = __esm({
         if (terminateError !== void 0) {
           return terminateError;
         }
-        if (await this.waitForExit(Date.now() + 1e3)) {
+        if (await this.waitForExit(performance.now() + 1e3)) {
           return void 0;
         }
         const killError = this.signalChild("SIGKILL");
         if (killError !== void 0) {
           return killError;
         }
-        if (await this.waitForExit(Date.now() + 1e3)) {
+        if (await this.waitForExit(performance.now() + 1e3)) {
           return void 0;
         }
         return `PID ${child.pid} remained alive after failed Electron launch cleanup.`;
@@ -26007,8 +26608,8 @@ var init_launch_process = __esm({
           return { evidence: {}, lines: [] };
         }
         const [stdout, stderr] = await Promise.all([
-          readOutputTail(join30(this.userDataDir, "stdout.log")),
-          readOutputTail(join30(this.userDataDir, "stderr.log"))
+          readOutputTail(join31(this.userDataDir, "stdout.log")),
+          readOutputTail(join31(this.userDataDir, "stderr.log"))
         ]);
         return {
           evidence: {
@@ -26186,7 +26787,7 @@ async function launchElectronApp(options) {
     };
   }
   const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
-  const startedAtMs = Date.now();
+  const startedAtMs = performance.now();
   const userDataDir = await createSecureTempDirectory(ELECTRON_PROFILE_DIR_PREFIX);
   if (isElectronLaunchAborted(options.signal)) {
     return abortedProfileResult(userDataDir, options, target);
@@ -26231,7 +26832,7 @@ var init_launch = __esm({
       diagnostics(observation2) {
         return {
           ...observation2,
-          elapsedMs: Math.max(0, Date.now() - this.startedAtMs),
+          elapsedMs: Math.round(Math.max(0, performance.now() - this.startedAtMs)),
           exitCode: this.process.exitCode,
           exitSignal: this.process.exitSignal,
           outputCaptured: this.process.outputCaptured,
@@ -26365,7 +26966,7 @@ var init_launch = __esm({
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-artifacts.js
 import { copyFile, mkdir as mkdir6 } from "node:fs/promises";
-import { dirname as dirname17, resolve as resolve16 } from "node:path";
+import { dirname as dirname18, resolve as resolve16 } from "node:path";
 function getArtifactParentPathTokenIndex(commandTokens) {
   if (commandTokens[0] === "download" && commandTokens.length >= 3) {
     return 2;
@@ -26390,7 +26991,7 @@ async function ensureArtifactParentDirectory(commandTokens, cwd) {
   if (requestedPath === void 0 || requestedPath === "") {
     return;
   }
-  await mkdir6(dirname17(resolve16(cwd, requestedPath)), { recursive: true });
+  await mkdir6(dirname18(resolve16(cwd, requestedPath)), { recursive: true });
 }
 function screenshotPathIndex(commandTokens, batchStep) {
   if (batchStep) {
@@ -26407,7 +27008,7 @@ async function normalizeScreenshotPathInTokens(commandTokens, cwd, batchStep = f
   }
   const requestedPath = commandTokens[pathIndex];
   const absolutePath = resolve16(cwd, requestedPath);
-  await mkdir6(dirname17(absolutePath), { recursive: true });
+  await mkdir6(dirname18(absolutePath), { recursive: true });
   const tokens = [...commandTokens];
   tokens[pathIndex] = absolutePath;
   const terminatorIndex = batchStep ? -1 : tokens.indexOf("--");
@@ -26502,7 +27103,7 @@ async function repairScreenshotData(options) {
   if (reportedAbsolutePath !== void 0 && reportedAbsolutePath !== request.absolutePath) {
     tempPath = reportedAbsolutePath;
     if (status === "missing" && await pathExists(reportedAbsolutePath)) {
-      await mkdir6(dirname17(request.absolutePath), { recursive: true });
+      await mkdir6(dirname18(request.absolutePath), { recursive: true });
       await copyFile(reportedAbsolutePath, request.absolutePath);
       status = "repaired-from-temp";
     }
@@ -26834,6 +27435,31 @@ var init_prepare_session_plan = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-daemon.js
+async function notCallerOwned() {
+  return false;
+}
+function observeCallerDaemonInactive(facts, { plan, session }) {
+  if (session.ownedManagedSession) {
+    return notCallerOwned;
+  }
+  let observation2;
+  const observe = async () => {
+    const initial = facts.initialDaemonObservation;
+    if (initial?.identity === getAgentBrowserSessionIdentityKey(plan.sessionName ?? "", plan.namespace)) {
+      return initial.daemon.status === "inactive";
+    }
+    return plan.sessionName !== void 0 && (await inspectManagedSessionDaemon({
+      cwd: facts.cwd,
+      signal: facts.signal,
+      sessionName: plan.sessionName,
+      namespace: plan.namespace
+    })).status === "inactive";
+  };
+  return () => {
+    observation2 ??= observe();
+    return observation2;
+  };
+}
 function daemonReuseError(plan, session, policy) {
   if (policy.error !== void 0 && policy.error !== "") {
     return policy.error;
@@ -26865,7 +27491,12 @@ async function prepareDaemonPolicy(process2, electronLaunchRecord, planning) {
   const { plan, session } = planning;
   const context2 = session.ownedManagedSession;
   if (session.browserIndependent || planHasValidationError(plan) || !context2) {
-    return { plan, session, policy: { inactive: false } };
+    return {
+      plan,
+      session,
+      policy: { inactive: false },
+      callerDaemonInactive: observeCallerDaemonInactive(process2, planning)
+    };
   }
   const closeCommand = isCloseCommand(plan.commandInfo.command);
   const policy = await acquireOwnedManagedSessionDaemonPolicy({
@@ -26886,7 +27517,8 @@ async function prepareDaemonPolicy(process2, electronLaunchRecord, planning) {
       inactive: policy.daemonStatus === "inactive",
       generationInspection: policy.generationInspection,
       cleanupOnlyReason: policy.error !== void 0 && policy.error !== "" ? policy.cleanupOnlyReason : void 0
-    }
+    },
+    callerDaemonInactive: notCallerOwned
   };
 }
 function chromeStartupEligible(facts, plan, request) {
@@ -26899,16 +27531,7 @@ async function prepareChromeStartupArgs(facts, planning, request) {
   })) {
     return void 0;
   }
-  const { plan, session, policy } = planning;
-  let inactive = policy.inactive;
-  if (!session.ownedManagedSession) {
-    inactive = (facts.initialDaemonObservation?.identity === getAgentBrowserSessionIdentityKey(plan.sessionName ?? "", plan.namespace) ? facts.initialDaemonObservation.daemon.status === "inactive" : void 0) ?? (plan.sessionName !== void 0 && (await inspectManagedSessionDaemon({
-      cwd: facts.cwd,
-      signal: facts.signal,
-      sessionName: plan.sessionName,
-      namespace: plan.namespace
-    })).status === "inactive");
-  }
+  const inactive = planning.session.ownedManagedSession ? planning.policy.inactive : await planning.callerDaemonInactive();
   return inactive || facts.configuredChromeLaunch === true ? facts.chromeStartupArgs : void 0;
 }
 var init_prepare_daemon = __esm({
@@ -26964,11 +27587,10 @@ async function reconcileGeneration(pageState, process2, request) {
     owned: session.ownedManagedSession
   }, request.generationInspection);
   pageState.bindSnapshotGeneration(key, daemon.status === "active" ? daemon.generation : void 0);
-  const generationKnown = daemon.status === "active" && daemon.generation !== void 0;
-  if (generationKnown && snapshot.generation === daemon.generation) {
+  const generationMatch = managedSessionDaemonGenerationsMatch(snapshot.generation, daemon.status === "active" ? daemon.generation : void 0);
+  if (generationMatch === true) {
     return { ...page, nativeGenerationChanged: false };
   }
-  const nativeGenerationChanged = generationKnown && snapshot.generation !== void 0;
   const invalidation = buildPageTransitionRefSnapshotInvalidation("The native browser generation changed or could not be verified. Take a new complete snapshot before using refs, even when the URL is unchanged.");
   pageState.applyRefSnapshotInvalidation({
     invalidation,
@@ -26977,7 +27599,7 @@ async function reconcileGeneration(pageState, process2, request) {
   });
   return {
     ...page,
-    nativeGenerationChanged,
+    nativeGenerationChanged: generationMatch === false,
     priorRefSnapshotState: void 0,
     priorRefSnapshotInvalidation: invalidation
   };
@@ -27034,6 +27656,7 @@ var init_prepare_page_state = __esm({
     init_session_page_state();
     init_managed_session_daemon_policy();
     init_session_state();
+    init_managed_session_daemon_inspection();
   }
 });
 
@@ -27157,7 +27780,7 @@ async function preparePageSelection(pageState, process2, hasReadConfirmation, re
     executionPlan: request.plan,
     livePageVerified: false
   };
-  if (!shouldSelectRememberedTab(request.plan, hasReadConfirmation, request)) {
+  if (!shouldSelectRememberedTab(request.plan, hasReadConfirmation, request) || await probeWouldDropLaunchFlags(process2)) {
     return base;
   }
   process2.signal?.throwIfAborted();
@@ -27208,6 +27831,9 @@ function verifiedLivePage(selection, url) {
     }
   };
 }
+async function probeWouldDropLaunchFlags(process2) {
+  return process2.preserveAttachedBrowserSession !== true && await process2.callerColdLaunch?.() === true;
+}
 async function verifyPreparationLivePage(process2, selection, request) {
   const plan = selection.executionPlan;
   if (request.requirement === void 0 || request.requirement === "" || plan.sessionName === void 0 || plan.sessionName === "") {
@@ -27216,6 +27842,9 @@ async function verifyPreparationLivePage(process2, selection, request) {
   if (process2.establishAttachedBrowserSession === true) {
     return { ...selection, executionPlan: withPlanValidationError(plan, request.requirement) };
   }
+  if (await probeWouldDropLaunchFlags(process2)) {
+    return selection;
+  }
   const url = await readLiveUrl(process2, plan);
   if (url === void 0) {
     return { ...selection, executionPlan: withPlanValidationError(plan, request.requirement) };
@@ -28863,9 +29492,11 @@ async function prepareNativeCommand(facts, context2, evidence) {
   const plan = context2.semantic.selection.executionPlan;
   const page = context2.semantic.selection.page;
   const input = context2.input;
+  const callerColdLaunch = !context2.session.browserIndependent && needsManagedSession(parseArgvDescriptor(plan.effectiveArgs), native.processStdin) && facts.preserveAttachedBrowserSession !== true && await facts.callerColdLaunch?.() === true;
   return {
     kind: "ready",
     prepared: {
+      callerColdLaunch: callerColdLaunch ? true : void 0,
       compiledElectron: input.compiledElectron,
       compiledJob: input.compiledJob,
       compiledNetworkSourceLookup: input.compiledNetworkSourceLookup,
@@ -28914,6 +29545,8 @@ var init_prepare_command = __esm({
     init_process();
     init_runtime_redaction();
     init_argv_grammar();
+    init_argv_descriptor();
+    init_command_policy();
     init_click_dispatch();
     init_diagnostics();
     init_prepare_failure();
@@ -28983,6 +29616,10 @@ async function prepareCommandPhases(state, controls, context2) {
 }
 async function preparePagePhases(state, controls, planning, request) {
   const { plan, session, policy } = planning;
+  const pageControls = {
+    ...controls,
+    callerColdLaunch: hasBrowserLaunchFlag(request.preparedArgs.args) ? planning.callerDaemonInactive : void 0
+  };
   const initial = controls.initialDaemonObservation;
   const page = await preparePageState(state, controls, {
     plan,
@@ -28992,7 +29629,7 @@ async function preparePagePhases(state, controls, planning, request) {
     preserveAttachedBrowserSession: controls.preserveAttachedBrowserSession,
     generationInspection: policy.generationInspection ?? (!session.ownedManagedSession && initial?.generationInspected === true && initial.identity === getAgentBrowserSessionIdentityKey(plan.sessionName ?? "", plan.namespace) ? initial.daemon : void 0)
   });
-  const selection = await preparePageSelection(state.sessionPageState, controls, session.readConfirmation !== void 0, {
+  const selection = await preparePageSelection(state.sessionPageState, pageControls, session.readConfirmation !== void 0, {
     ...request,
     plan,
     page,
@@ -29001,14 +29638,14 @@ async function preparePagePhases(state, controls, planning, request) {
   if ("earlyResult" in selection) {
     return selection.earlyResult;
   }
-  const semantic = await prepareSemanticAction(controls, request.sessionFacts, {
+  const semantic = await prepareSemanticAction(pageControls, request.sessionFacts, {
     hasReadConfirmation: session.readConfirmation !== void 0,
     ownsSession: session.ownedManagedSession !== void 0
   }, {
     ...request,
     selection
   });
-  return prepareCommandPhases(state, controls, { ...request, semantic, session, policy });
+  return prepareCommandPhases(state, pageControls, { ...request, semantic, session, policy });
 }
 async function prepareRequest(identity, input, settings) {
   const freshSessionName = createFreshSessionName(identity.managedSessionBaseName, identity.ephemeralSessionSeed, identity.freshSessionOrdinal + 1);
@@ -29121,6 +29758,7 @@ var init_prepare = __esm({
   "dist/extensions/agent-browser/lib/orchestration/browser-run/prepare.js"() {
     "use strict";
     init_runtime();
+    init_launch_scoped_flags();
     init_page_target_validation();
     init_categories();
     init_process();
@@ -29242,20 +29880,20 @@ function planRecordingRecovery(options) {
     return void 0;
   }
   const { batch, steps, rows } = recoverySource(options);
-  const stopIndex = steps.reduce((last, step, index) => isRecordingStop(step) && stopNeedsRecovery(options, rows?.at(index)) ? index : last, -1);
-  if (stopIndex < 0) {
+  const stopPosition = steps.reduce((last, step, position) => isRecordingStop(step) && stopNeedsRecovery(options, rows?.at(position)) ? position : last, -1);
+  if (stopPosition < 0) {
     return void 0;
   }
   let expected = options.reservation;
-  for (const [index, step] of steps.slice(0, stopIndex).entries()) {
-    expected = reservationForStart(options, step, rows?.at(index)) ?? expected;
+  for (const [position, step] of steps.slice(0, stopPosition).entries()) {
+    expected = reservationForStart(options, step, rows?.at(position)) ?? expected;
   }
   return {
     batch,
     rows,
-    stopIndex,
+    stopPosition,
     expected,
-    attempt: originalAttempt(options, rows?.at(stopIndex))
+    attempt: originalAttempt(options, rows?.at(stopPosition))
   };
 }
 function receiptMatches(receipt, expected, nowMs) {
@@ -29410,7 +30048,7 @@ function classifyRecordingRecovery(evidence, plan, verified) {
 }
 function repairRecordingEnvelope(options, plan, data, verified) {
   if (plan.rows) {
-    const rows = plan.rows.map((row, index) => index === plan.stopIndex && isRecord(row) ? { ...row, result: data, success: verified, error: verified ? void 0 : row.error } : row);
+    const rows = plan.rows.map((row, position) => position === plan.stopPosition && isRecord(row) ? { ...row, result: data, success: verified, error: verified ? void 0 : row.error } : row);
     const healed = verified && !options.processResult.timedOut && rows.every((row) => isRecord(row) && row.success === true);
     return {
       healed,
@@ -29523,13 +30161,13 @@ async function recoverRecordingStop(options) {
     batch: plan.batch,
     envelope: repaired.envelope,
     partialBatch: plan.batch && plan.rows === void 0,
-    stopIndex: plan.stopIndex,
+    stopPosition: plan.stopPosition,
     presentation: finishRecordingPresentation(options, presentation, evidence, recovery),
     recovery
   };
 }
 function mergeRecoveryNextActions(base, result) {
-  const laterRecording = base.batchSteps?.slice(result.stopIndex + 1).some((step) => step.artifacts?.some(isPendingRecordingArtifact) === true) === true;
+  const laterRecording = base.batchSteps?.slice(result.stopPosition + 1).some((step) => step.artifacts?.some(isPendingRecordingArtifact) === true) === true;
   const unrelatedFailure = base.batchFailure !== void 0 && !isRecordingStop(base.batchFailure.failedStep.command ?? []);
   const nextActions = (base.nextActions ?? []).filter((action) => action.id === "stop-pending-recording" ? laterRecording : unrelatedFailure);
   appendUniqueAgentBrowserNextActions(nextActions, result.presentation.nextActions);
@@ -29544,7 +30182,7 @@ function mergeRecordingRecoveryPresentation(base, result) {
     ...base,
     artifacts,
     artifactVerification: buildArtifactVerificationSummary(artifacts ?? []),
-    batchSteps: base.batchSteps?.map((step) => step.index === result.stopIndex ? {
+    batchSteps: base.batchSteps?.map((step, position) => position === result.stopPosition ? {
       ...step,
       artifacts: result.presentation.artifacts,
       artifactVerification: result.presentation.artifactVerification
@@ -29583,6 +30221,10 @@ async function parseNativeOutput(draft) {
     plainText: draft.plainTextUpgrade,
     textOutput: draft.textOutput
   });
+  draft.parsed = {
+    ...draft.parsed,
+    envelope: resolveIndexedBatchCommands(draft.parsed.envelope, draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin)
+  };
   observeNativeWebMcp(draft.parsed.envelope?.data);
   draft.parseError = draft.parsed.parseError;
   draft.recordingStopRecovery = await recoverRecordingStop({
@@ -30213,7 +30855,9 @@ function mergeObservedNavigation(draft) {
 async function observeNavigationTarget(draft) {
   resolveResultingPageState(draft);
   const { prepared, cwd, signal } = draft.input;
-  if (canObserveSuccessfulNavigation(draft) && navigationObservationRequested(draft)) {
+  const navigationRequested = navigationObservationRequested(draft);
+  const coldTargetObservation = prepared.callerColdLaunch === true && !isOpenNavigationCommand(prepared.executionPlan.commandInfo.command);
+  if (canObserveSuccessfulNavigation(draft) && (navigationRequested || coldTargetObservation)) {
     draft.navigationSummary = await collectNavigationSummary({
       cwd,
       namespace: prepared.executionPlan.namespace,
@@ -30233,7 +30877,9 @@ async function observeNavigationTarget(draft) {
     });
     draft.failedTransitionReverification = draft.navigationSummary !== void 0;
   }
-  mergeObservedNavigation(draft);
+  if (navigationRequested || draft.failedTransitionReverification) {
+    mergeObservedNavigation(draft);
+  }
 }
 async function correctRestoredOpenTab(draft) {
   const { prepared, cwd, signal } = draft.input;
@@ -30730,6 +31376,9 @@ function getTransitionInvalidation(draft) {
   if (draft.unsettledWebMcpMutation) {
     return buildPageTransitionRefSnapshotInvalidation("A detached WebMCP invocation is still pending or failed to settle and can mutate, rerender, or navigate the page, so prior snapshot refs remain invalid after URL verification. Run webmcp result or cancel, then take a fresh snapshot before using page-scoped refs.");
   }
+  if (draft.input.prepared.callerColdLaunch === true && draft.input.processResult.agentBrowserStarted) {
+    return buildPageTransitionRefSnapshotInvalidation("The previous caller-owned browser stopped. Take a fresh complete snapshot before using page-scoped refs.");
+  }
   return observedTransitionInvalidation(draft, direct ?? planned);
 }
 function observedTransitionInvalidation(draft, commandInvalidation) {
@@ -31426,6 +32075,7 @@ function resolveNativeErrorText(draft) {
     effectiveArgs: draft.input.prepared.redactedProcessArgs,
     envelope: draft.presentationEnvelope,
     exitCode: draft.input.processResult.exitCode,
+    exitSignal: draft.input.processResult.exitSignal,
     parseError: draft.parseError,
     plainTextInspection: draft.plainTextInspection,
     staleRefArgs: getStaleRefArgs(draft.input.prepared.commandTokens, draft.input.prepared.runtimeToolStdin),
@@ -31470,7 +32120,7 @@ function observeResultLaunchPolicy(draft) {
   draft.resultHeadedManagedAutosaveInterval = resultRetainsPreparedManagedSession && !(draft.commandClosesSession && draft.succeeded) ? draft.input.prepared.ownedManagedSessionContext?.headedManagedAutosaveInterval : void 0;
 }
 function classifyMalformedNativeFailure(draft) {
-  if (draft.parseError !== void 0 && draft.parseError.length > 0 && draft.input.processResult.exitCode !== 0 && draft.input.processResult.stderr.trim().length > 0 && !draft.input.processResult.timedOut && !draft.input.processResult.aborted && !draft.input.processResult.spawnError) {
+  if (draft.parseError !== void 0 && draft.parseError.length > 0 && draft.input.processResult.exitCode !== 0 && !draft.input.processResult.timedOut && !draft.input.processResult.aborted && !draft.input.processResult.spawnError) {
     draft.presentation.failureCategory = "upstream-error";
   }
 }
@@ -32432,7 +33082,23 @@ __export(process_output_exports, {
   processBrowserOutput: () => processBrowserOutput
 });
 import { rm as rm14 } from "node:fs/promises";
-async function processBrowserOutput(input) {
+function coldLaunchOutput(input) {
+  if (input.prepared.callerColdLaunch !== true || !input.processResult.agentBrowserStarted) {
+    return input;
+  }
+  return {
+    ...input,
+    prepared: {
+      ...input.prepared,
+      priorSessionTabTarget: void 0,
+      priorSessionTabTargetUnknown: true,
+      priorRefSnapshotState: void 0,
+      resolvedSemanticActionRefSnapshot: void 0
+    }
+  };
+}
+async function processBrowserOutput(invocation) {
+  const input = coldLaunchOutput(invocation);
   const ownership = captureBrowserOutputOwnership(input);
   try {
     const native = await observeNativeEffects(input, ownership);
@@ -32473,6 +33139,11 @@ import { open as open2, stat as stat2 } from "node:fs/promises";
 // dist/extensions/agent-browser/lib/browser-journal-projection.js
 init_parsing();
 var ENVELOPE_MAX_BYTES = 16 * 1024 * 1024;
+var MAX_NESTING = 1024;
+var RESERVE_PER_BYTE = 16;
+var NATIVE_RECORD_BYTES = ENVELOPE_MAX_BYTES / RESERVE_PER_BYTE;
+var NATIVE_STRUCTURE_LIMIT = 64 * 1024;
+var JOURNAL_CHUNK_BYTES = 64 * 1024;
 function matches(field, key) {
   return field === key || field === "*" && typeof key === "number";
 }
@@ -32611,7 +33282,7 @@ var JsonProjection = class {
     }
   }
   startContainer(name) {
-    if (this.stack.length >= 1024) {
+    if (this.stack.length >= MAX_NESTING) {
       throw new Error("Journal JSON nesting exceeds 1024 levels.");
     }
     const currentPath = this.excluded() ? [] : this.path();
@@ -32676,14 +33347,110 @@ async function projectJson(input, fields, maxBytes = ENVELOPE_MAX_BYTES) {
   consume(chain.none);
   return projection.result();
 }
+function stringEnd(bytes, open6) {
+  for (let quote = bytes.indexOf(34, open6 + 1); quote !== -1; quote = bytes.indexOf(34, quote + 1)) {
+    let escapes = 0;
+    while (bytes[quote - 1 - escapes] === 92) {
+      escapes++;
+    }
+    if (escapes % 2 === 0) {
+      return quote;
+    }
+  }
+  return -1;
+}
+var DEPTH_STEP = new Int8Array(256);
+var STRUCTURE_STEP = new Uint8Array(256);
+for (const byte of [91, 123]) {
+  DEPTH_STEP[byte] = 1;
+  STRUCTURE_STEP[byte] = 1;
+}
+for (const byte of [93, 125]) {
+  DEPTH_STEP[byte] = -1;
+}
+for (const byte of [44, 58]) {
+  STRUCTURE_STEP[byte] = 1;
+}
+function fitsNativeParse(bytes) {
+  let depth = 0;
+  let structure = 0;
+  for (let index = 0; index < bytes.length; index++) {
+    const byte = bytes[index];
+    if (byte === 34) {
+      index = stringEnd(bytes, index);
+      if (index === -1) {
+        return false;
+      }
+      continue;
+    }
+    depth += DEPTH_STEP[byte];
+    structure += STRUCTURE_STEP[byte];
+    if (depth > MAX_NESTING || structure > NATIVE_STRUCTURE_LIMIT) {
+      return false;
+    }
+  }
+  return true;
+}
+function selectValue(value, path, fields) {
+  if (typeof value !== "object" || value === null || fields.some((field) => field.every((key, index) => matches(key, path[index])))) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const selected2 = [];
+    for (const [index, item] of value.entries()) {
+      const itemPath = [...path, index];
+      if (selectedPath(itemPath, fields)) {
+        selected2[index] = selectValue(item, itemPath, fields);
+      }
+    }
+    return selected2;
+  }
+  const selected = {};
+  for (const [key, item] of Object.entries(value)) {
+    const itemPath = [...path, key];
+    if (selectedPath(itemPath, fields)) {
+      Object.defineProperty(selected, key, {
+        value: selectValue(item, itemPath, fields),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  return selected;
+}
+function nativeProjection(bytes, fields) {
+  if (!fitsNativeParse(bytes)) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const selected = selectValue(value, [], fields);
+  return isRecord(selected) ? selected : void 0;
+}
+async function* chunks(bytes) {
+  for (let start = 0; start < bytes.length; start += JOURNAL_CHUNK_BYTES) {
+    yield bytes.subarray(start, start + JOURNAL_CHUNK_BYTES);
+  }
+}
+async function projectJsonBytes(bytes, fields, maxBytes = ENVELOPE_MAX_BYTES) {
+  const native = bytes.length * RESERVE_PER_BYTE <= maxBytes ? nativeProjection(bytes, fields) : void 0;
+  return native ?? projectJson(chunks(bytes), fields, maxBytes);
+}
 
 // dist/extensions/agent-browser/lib/browser-journal-reader.js
-var CHUNK_BYTES = 64 * 1024;
 async function* readRange(file, range) {
   let position = range.offset;
   const end = range.offset + range.length;
   while (position < end) {
-    const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, end - position));
+    const buffer = Buffer.allocUnsafe(Math.min(JOURNAL_CHUNK_BYTES, end - position));
     const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
     if (bytesRead === 0) {
       throw new Error("Journal changed or truncated during read.");
@@ -32692,35 +33459,69 @@ async function* readRange(file, range) {
     yield buffer.subarray(0, bytesRead);
   }
 }
+function hasContent(buffer, start, end) {
+  for (let index = start; index < end; index++) {
+    const byte = buffer[index];
+    if (byte !== 9 && byte !== 13 && byte !== 32) {
+      return true;
+    }
+  }
+  return false;
+}
 var JournalLineFramer = class {
   start;
   nonblank = false;
+  parts = [];
+  held = 0;
   constructor(offset) {
     this.start = offset;
   }
   *accept(buffer, position) {
-    for (let index = 0; index < buffer.length; index++) {
-      const byte = buffer[index];
-      if (byte === 10) {
-        if (this.nonblank) {
-          yield { offset: this.start, length: position + index + 1 - this.start };
-        }
-        this.start = position + index + 1;
-        this.nonblank = false;
-      } else if (![9, 13, 32].includes(byte)) {
-        this.nonblank = true;
+    let index = 0;
+    while (index < buffer.length) {
+      const newline = buffer.indexOf(10, index);
+      const end = newline === -1 ? buffer.length : newline;
+      this.nonblank ||= hasContent(buffer, index, end);
+      this.hold(buffer.subarray(index, newline === -1 ? end : end + 1));
+      if (newline === -1) {
+        return;
+      }
+      const record = this.take(position + newline + 1);
+      if (record) {
+        yield record;
       }
+      index = newline + 1;
     }
   }
   final(end, sealed) {
-    return this.nonblank && sealed ? { offset: this.start, length: end - this.start } : void 0;
+    return sealed ? this.take(end) : void 0;
+  }
+  hold(part) {
+    this.held += part.length;
+    if (this.held > NATIVE_RECORD_BYTES) {
+      this.parts = void 0;
+    } else {
+      this.parts?.push(part);
+    }
+  }
+  take(next) {
+    let record;
+    if (this.nonblank) {
+      const range = { offset: this.start, length: next - this.start };
+      record = this.parts ? { ...range, bytes: Buffer.concat(this.parts) } : range;
+    }
+    this.start = next;
+    this.nonblank = false;
+    this.parts = [];
+    this.held = 0;
+    return record;
   }
 };
 async function* journalRanges(file, end, sealed = false, offset = 0) {
   let position = offset;
   const framer = new JournalLineFramer(offset);
   while (position < end) {
-    const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, end - position));
+    const buffer = Buffer.allocUnsafe(Math.min(JOURNAL_CHUNK_BYTES, end - position));
     const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
     if (bytesRead === 0) {
       throw new Error("Journal truncated during read.");
@@ -32748,14 +33549,14 @@ var STRUCTURAL_FIELDS = [
   ["message", "details", "artifactManifest", "version"],
   ["message", "details", "electron", "action"]
 ];
-async function scanJournalMetadata(file, end, sealed = false) {
+async function scanJournalMetadata(file, end, sealed = false, offset = 0) {
   const entries = [];
-  for await (const range of journalRanges(file, end, sealed)) {
-    const value = await projectJson(readRange(file, range), STRUCTURAL_FIELDS);
+  for await (const range of journalRanges(file, end, sealed, offset)) {
+    const value = range.bytes ? await projectJsonBytes(range.bytes, STRUCTURAL_FIELDS) : await projectJson(readRange(file, range), STRUCTURAL_FIELDS);
     if (!value) {
       throw new Error(`Expected a journal object at byte ${range.offset}.`);
     }
-    entries.push({ ...range, value });
+    entries.push({ offset: range.offset, length: range.length, value });
   }
   return entries;
 }
@@ -33331,6 +34132,20 @@ var REPLAY_CUSTOM_TYPES = /* @__PURE__ */ new Set([
   "agent-browser-recording-reservation",
   "agent-browser-script-session"
 ]);
+var journalIndexes = /* @__PURE__ */ new WeakMap();
+function appendCompatible(previous, current) {
+  return previous.dev === current.dev && previous.ino === current.ino && current.size >= previous.size && (current.size > previous.size || current.mtimeMs === previous.mtimeMs && current.ctimeMs === previous.ctimeMs);
+}
+async function readJournalIndex(manager, file, path, captured) {
+  const previous = journalIndexes.get(manager);
+  journalIndexes.delete(manager);
+  const reusable = previous?.path === path && appendCompatible(previous.captured, captured) && previous.header === manager.getHeader();
+  const prefix = reusable ? previous.metadata : [];
+  const last = prefix.at(-1);
+  const offset = last ? last.offset + last.length : 0;
+  const suffix = reusable && captured.size === previous.captured.size ? [] : await scanJournalMetadata(file, captured.size, false, offset);
+  return { path, header: manager.getHeader(), captured, metadata: [...prefix, ...suffix] };
+}
 function branchEntries(entries, selectedLeaf) {
   const byId = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -33429,6 +34244,16 @@ function winningSnapshot(body, source) {
   const value = body?.[source.root];
   return isRecord(value) && isRecord(value.details) ? legacySnapshot(value.details.refSnapshot, source.id) : void 0;
 }
+async function projectEntryBody(file, entry, fields, maxBytes) {
+  if (entry.length > NATIVE_RECORD_BYTES) {
+    return projectJson(readRange(file, entry), fields, maxBytes);
+  }
+  const parts = [];
+  for await (const part of readRange(file, entry)) {
+    parts.push(part);
+  }
+  return projectJsonBytes(Buffer.concat(parts), fields, maxBytes);
+}
 var PublishedJournalReplay = class {
   file;
   ownerSessionId;
@@ -33458,7 +34283,7 @@ var PublishedJournalReplay = class {
       this.advance(value, parent);
       return;
     }
-    const body = await projectJson(readRange(this.file, entry), replayFields(value, legacy), legacy ? Infinity : void 0);
+    const body = await projectEntryBody(this.file, entry, replayFields(value, legacy), legacy ? Infinity : void 0);
     const candidate = { ...value, ...body };
     const record = this.normalizeRecord(candidate, parent);
     this.rememberSnapshot(entry, legacy, record?.snapshot);
@@ -33502,7 +34327,7 @@ var PublishedJournalReplay = class {
     }
     const { entry, legacy } = definition;
     const root = entry.value.type === "message" ? "message" : "data";
-    const body = await projectJson(readRange(this.file, entry), legacy ? [[root, "details", "refSnapshot"]] : [["data", "snapshot"]], Infinity);
+    const body = await projectEntryBody(this.file, entry, legacy ? [[root, "details", "refSnapshot"]] : [["data", "snapshot"]], Infinity);
     const resolved = winningSnapshot(body, { root, legacy, id });
     const destination = this.projected.find((candidate) => isRecord(candidate) && candidate.id === entry.value.id);
     if (!isRecord(destination) || !isRecord(destination.data)) {
@@ -33512,7 +34337,7 @@ var PublishedJournalReplay = class {
     if (!isRecord(resolved) || resolved.id !== id) {
       throw new Error("Winning browser snapshot identity is invalid.");
     }
-    snapshotFromDefinition(resolved);
+    assertSnapshotDefinition(resolved);
   }
 };
 function replayRelevant(value) {
@@ -33525,9 +34350,9 @@ async function verifyCapturedFile(file, path, captured) {
     throw new Error("Pi journal replaced or truncated during replay.");
   }
 }
-function validateJournalHeader(metadata, sessionId) {
-  const header = metadata.find((entry) => entry.value.type === "session");
-  if (header?.value.id !== sessionId) {
+function validateJournalHeader(index, manager) {
+  const header = index.metadata.find((entry) => entry.value.type === "session");
+  if (header?.value.id !== (index.header?.id ?? manager.getSessionId())) {
     throw new Error("Pi session journal identity does not match the active session.");
   }
 }
@@ -33544,29 +34369,37 @@ async function openPublishedJournal(path) {
 async function readBrowserEntries(manager, physical = false) {
   const path = manager.getSessionFile();
   if (path === void 0 || path.length === 0) {
+    journalIndexes.delete(manager);
     return inMemoryEntries(manager, physical);
   }
   const leaf = physical ? null : manager.getLeafId();
-  const file = await openPublishedJournal(path);
-  if (!file) {
-    return inMemoryEntries(manager, physical);
-  }
+  let file;
   try {
+    file = await openPublishedJournal(path);
+    if (!file) {
+      journalIndexes.delete(manager);
+      return inMemoryEntries(manager, physical);
+    }
     const captured = await file.stat();
     if (!captured.isFile()) {
       throw new Error("Pi session journal is not a regular file.");
     }
-    const metadata = await scanJournalMetadata(file, captured.size);
-    validateJournalHeader(metadata, manager.getHeader()?.id ?? manager.getSessionId());
+    const index = await readJournalIndex(manager, file, path, captured);
+    const { metadata } = index;
+    validateJournalHeader(index, manager);
     const records = metadata.filter((entry) => entry.value.type !== "session");
     const selected = physical ? records : branchEntries(records, leaf);
     const replay = new PublishedJournalReplay(file, selected, legacyOwner(manager));
     await replay.project(selected);
     const entries = await replay.resolveWinningDefinitions(physical);
     await verifyCapturedFile(file, path, captured);
+    journalIndexes.set(manager, index);
     return entries;
+  } catch (error) {
+    journalIndexes.delete(manager);
+    throw error;
   } finally {
-    await file.close();
+    await file?.close();
   }
 }
 
@@ -33791,10 +34624,10 @@ init_managed_session_restore();
 
 // dist/extensions/agent-browser/lib/orchestration/execution-queue.js
 init_argv_grammar();
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 var AsyncExecutionQueue = class {
   tail = Promise.resolve();
-  active = new AsyncLocalStorage3();
+  active = new AsyncLocalStorage4();
   isCurrent() {
     return this.active.getStore()?.active === true;
   }
@@ -33897,14 +34730,14 @@ function buildInstalledDocsGuideline(paths) {
 }
 var QUICK_START_GUIDELINES = [
   "Choose agent_browser for one native command, native batch --bail with JSON-array stdin for a known fixed sequence, or agent_browser_code for loops, branches, and aggregation. Return to the model when a fresh observation needs judgment. Neither tool is a named recipe registry.",
-  'agent_browser takes args (argv after the binary), optional stdin, outputPath, timeoutMs, and sessionMode. Start with { args: ["open", "<url>"] }, then { args: ["snapshot", "-i"] }; act on current @refs and re-snapshot after navigation or DOM changes. Native commands, providers, plugins, profiles, auth, file access, and caller paths remain available through args.',
+  'agent_browser takes args (argv after the binary), optional stdin, outputPath, timeoutMs, and sessionMode; sessionMode:fresh intentionally launches a separate managed browser. Start with { args: ["open", "<url>"] }, then { args: ["snapshot", "-i"] }; act on current @refs and re-snapshot after navigation or DOM changes. Native commands, providers, plugins, profiles, auth, file access, and caller paths remain available through args; native config and environment pass through. Use requested/configured profiles and verify authentication after restart.',
   'Use { args: ["batch", "--bail"], stdin: "[[\\"fill\\",\\"@e1\\",\\"text\\"],[\\"click\\",\\"@e2\\"]]" } for same-snapshot form fields followed by submit. Split if a fill rerenders later fields. Add native condition waits after navigation-prone actions; a click alone does not prove the destination loaded. Avoid blind mutation retries after timeout.',
   "agent_browser_code takes { code, session?, namespace?, timeoutMs?, outputPath? }. JavaScript globals are fresh for every call; the selected browser persists and is shared with agent_browser. Use await browser({ args, stdin?, timeoutMs? }), inspect result.success, and emit selected JSON instead of whole envelopes. Use emitImage(result.imageObservations[0]) only when image inspection is needed; image handles belong to the current code call. No imports or host filesystem/network/process APIs are exposed.",
   `Example agent_browser_code: { code: 'const result = await browser({args:["get","title"]}); if (!result.success) { emit(result); } else { emit({title:result.data}); }' }. Native batch still avoids extra CLI processes for fixed segments inside code. Explicit session/namespace controls select the browser for this cell without changing the default browser.`,
   'Call agent_browser_tools with no fields for inventory, or { enable: ["action", "qa", "electron", "source", "network"] } for advanced native tools. It adds agent_browser_action, agent_browser_qa, agent_browser_electron, agent_browser_source, and agent_browser_network_source without disabling other tools. The browser instructions cover these capabilities; activation reveals their selected tool declarations.',
   "Use read <url> for readable web text; get title/url, get text/html/value/count <selector>, or get attr <selector> <name> for targeted state. For eval --stdin, put JavaScript in stdin and return the desired value. outputPath saves result data and must differ from screenshot/download/recording paths. Use --json only when JSON text is needed.",
-  "For artifacts, verify artifactVerification and artifacts before reporting success. A pending recording is not verified output; install ffmpeg before starting and pair start with stop. Native download owns the click and saves Blob/redirect downloads. Close keeps explicitly saved files. Save promptGuard-required paths before close. Screenshot pixels are not browser CSS coordinates: use imageObservations geometry (dimensions, viewport, crop/origin, scroll and DPR) before any visual-coordinate action; full-page and element captures are not current-viewport coordinates, and Pi resizing only maps sent pixels to original image pixels. Lightpanda images are text-rendered, not graphical layout; rendering:text never supports CSS/mouse-coordinate input.",
-  "Follow model-visible nextActions when present, including identity and stdin, instead of guessing commands. Treat native pending confirmations and unknown mutation outcomes as inspection boundaries. For dense snapshots, inspect Omitted high-value controls before reading a full spill."
+  "For artifacts, verify artifactVerification and artifacts before reporting success. A pending recording is not verified output; install ffmpeg before starting and pair start with stop. Native download owns the click and saves Blob/redirect downloads. Close keeps explicitly saved files. Save promptGuard-required paths before close. Screenshot pixels are not browser CSS coordinates: use imageObservations geometry (dimensions, viewport, crop/origin, scroll and DPR) before any visual-coordinate action; full-page and element captures are not current-viewport coordinates, and Pi resizing only maps sent pixels to original image pixels. Lightpanda images are text-rendered, not graphical layout; rendering:text never supports CSS/mouse-coordinate input. Prefer refs; inspect screenshots only when the task needs vision.",
+  "Follow model-visible nextActions when present, including identity and stdin, instead of guessing commands. Treat native pending confirmations and unknown mutation outcomes as inspection boundaries. Native outcome_unknown means a command may have run and was not retried; inspect before any repeat. For dense snapshots, inspect Omitted high-value controls before reading a full spill."
 ];
 var ADVANCED_TOOL_PROMPT_GUIDELINES = {
   action: [
@@ -33946,11 +34779,11 @@ var SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
   "Do not assume Playwright selector dialects such as text=Close or button:has-text('Close') are supported wrapper syntax unless current upstream agent-browser behavior has been verified.",
   "For authenticated or user-specific content explicitly requested by the user, such as feeds, inboxes, account pages, or private dashboards, use a real profile only when the user/config asks for it or profiles have been inspected; do not assume --profile Default exists on every machine. Do not use a real profile for public pages just because they are dashboards. Treat visible page content from real profiles as model-visible transcript data. On macOS, copied Chrome profiles may omit encrypted cookies, so profile selection alone is not proof of authentication; verify the target page and use a user-approved headed login once when needed. Use --auto-connect only if profile-based reuse is unavailable or the task is specifically about attaching to a running debug-enabled browser. If profile/user-data-dir resolution fails, stop retrying opens, run profiles and/or doctor through agent_browser, then report what the user needs to configure.",
   "Ordinary bare calls share one native browser within your root Pi parent/subagent group; unrelated roots browse independently. Coordinate multi-call navigation inside your group with existing subagent/intercom tools. Explicit native session defaults still win. Pi quit does not close group browsers; never close an unrelated browser.",
-  `When using launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), put them on the first command for that session. If you intentionally use an explicit --session, keep using that same explicit session for follow-ups.`,
+  `When using launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), put them on the first command for that session. If you intentionally use an explicit --session, keep using that same explicit session for follow-ups. If you already used the implicit session and now need launch-scoped flags, retry with top-level sessionMode set to fresh or pass an explicit --session for the new launch; never pass --session-mode inside args. After a successful unnamed fresh launch, later auto calls follow that new session.`,
   "Cooperating Pi processes serialize each complete browser operation and code cell by native socket context, namespace, and session, including target/ref helpers and state updates. Different identities remain concurrent; namespace-wide close waits for matching operations. All participating Pi instances must load this release; humans, third-party clients, and older extensions are outside that coordination. It is not a transaction or rollback. For raw batches whose later content depends on navigation, use exact batch --bail or split the calls.",
   "After a successful `connect`, `--cdp`, or enabled `--auto-connect` call, verify with get url and keep using the resulting session without repeating the attach flag. The wrapper remembers that attachment across active-branch reload/resume and live-checks the URL before later page reads/interactions because an attached browser can drift externally; caller config, file access, launch arguments, and environment pass through unchanged. A successful close clears the marker. When several named sessions share one Chrome, pass --pin-tab once (AGENT_BROWSER_PIN_TAB) so a closed bound tab fails as tab_gone instead of acting on a neighbor; recover with tab new or tab list. --no-pin-tab turns the sticky pin off. tab list includes each tab's CDP targetId, accepted as a tab ref.",
-  `If you already used the implicit session and now need launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}), retry with top-level sessionMode set to fresh or pass an explicit --session for the new launch; never pass --session-mode inside args. After a successful unnamed fresh launch, later auto calls follow that new session.`,
-  "Chrome is the default. Use separately installed Lightpanda only when explicitly selected with --engine lightpanda, environment or native config; --engine is launch-scoped, so use sessionMode:fresh to change a managed browser. Lightpanda text-rendered screenshots do not prove graphical layout/visibility or mouse coordinates. Chrome profiles, headed mode, multi-tab, WebGPU and native WebMCP are not parity capabilities; choose Chrome explicitly when needed, never assume automatic fallback.",
+  "Chrome is the default. Select separately installed Lightpanda or experimental Obscura explicitly with --engine lightpanda|obscura, environment or native config; use sessionMode:fresh to change a managed engine. Lightpanda text-rendered screenshots never establish graphical layout or mouse coordinates. Obscura has accessibility, iframe and screenshot gaps; read its command-reference limits first. Profiles, headed mode, multi-tab, WebGPU and WebMCP are not parity capabilities; choose Chrome when needed, never assume automatic fallback.",
+  "For CLI HTTPS trust on read/install/upgrade/doctor, use --ca-cert <path> or --use-system-ca; --use-system-ca false disables OS roots and SSL_CERT_FILE is a fallback. These do not disable certificate verification or configure remote CDP trust. Browser CA trust remains Linux-Chromium-only and launch-scoped.",
   'For WebGPU pages, use args ["--webgpu", "open", "<url>"] on a fresh local browser launch; use doctor --webgpu (or --headed on Linux/Windows capture paths) to prove rendering before trusting a non-black screenshot. WebGPU cannot be combined with --cdp, --auto-connect, or provider launches unless --webgpu false overrides an enabled config/environment default.',
   "For experimental WebMCP page tools, use webmcp list, then webmcp invoke <tool> with --params and optional --frame/--detach/--timeout; use webmcp result or cancel for detached calls. Locally managed Chrome enables WebMCP by default; a positive navigation hint means the page has tools to list. --no-webmcp is launch-scoped and requires a fresh session; invoke/result/cancel can mutate or navigate, so refresh snapshot refs afterward.",
   "For --allowed-domains, use a fresh local Chrome context. Upstream rejects CDP/auto-connect, profiles, restore/state replay, direct-page providers, iOS/Safari, and startup/profile Chrome args because they cannot guarantee containment; Chromium also disables RTCPeerConnection while the allowlist is active.",
@@ -33958,7 +34791,7 @@ var SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
   "For first-navigation setup, use open without a URL plus network route --resource-type <csv>, cookies set --curl <file>, or --init-script/--enable before navigate/opening the target page.",
   "For stateful browser context work, use auth save --password-stdin with the tool stdin field for credentials, auth list/show/delete/remove for local auth-profile maintenance, auth login when you need the browser to fill a saved profile, and state save/load/list/show/rename/clear/clean for upstream saved-state lifecycle. State paths, restore identifiers, wrapper-prefixed sessions, and all upstream list rows remain available; credential values inside cookie/storage/auth payloads are still redacted from presentation.",
   "Upstream restore sessions periodically autosave cookies and localStorage while the browser stays open, including page-driven background changes; AGENT_BROWSER_AUTOSAVE_INTERVAL_MS controls the interval (30000 by default; 0 disables periodic saves but keeps save-on-close), while the never value for --restore-save disables automatic saves for that restore session. For wrapper-owned headed launches, the wrapper defaults the interval to 0 because upstream 0.33.2 collects multi-origin storage through visible temporary tabs, then records and reapplies the effective launch-time value to helpers and follow-ups so daemon configuration remains stable. Native close still saves, but direct window close can lose newer state because upstream exempts headed browsers from idle shutdown; set AGENT_BROWSER_AUTOSAVE_INTERVAL_MS before launch when periodic preservation matters, because changing it on a running wrapper-owned headed session requires close plus a fresh launch.",
-  "For batch chains that touch cookies, storage, auth, or other secret-bearing commands, use details.batchSteps for per-step artifacts, categories, spill paths, and full structured errors; top-level details.data on batch is only a compact redacted step matrix (success, argv-redacted command, redacted result or scrubbed error text) built from the same presentation rules as standalone calls.",
+  "For batch chains that touch cookies, storage, auth, or other secret-bearing commands, use details.batchSteps for per-step artifacts, categories, spill paths, and full structured errors; top-level details.data on batch is only a compact redacted step matrix (success, argv-redacted command or native --omit-command index, redacted result or scrubbed error text) built from the same presentation rules as standalone calls. Indexed receipts preserve original input positions, including skipped empty rows, without echoing commands.",
   "For non-core families, pass current upstream commands through the native tool directly: network requests, network route <url>, network har start/stop [path], diff snapshot, diff screenshot --baseline <file>, diff url <u1> <u2>, trace start, trace stop [path], profiler start, profiler stop [path], record start <path>, record stop, console/errors [--clear], highlight <selector>, inspect, clipboard read, clipboard write <text>, clipboard copy/paste, stream enable/disable/status, dashboard start/stop, device list for iOS simulator inventory, and chat <message>. For compact network requests output, prefer details.nextActions for request detail, route-mock diagnostics, actionable failed-request agent_browser_network_source, filtering, clearing the aggregate buffer before repro, or HAR capture follow-ups instead of guessing request-id syntax. Artifact-producing commands report details.artifacts and verification state; long-running starts such as stream, dashboard, trace/profiler, and record should be paired with the matching stop/disable command when the task is done; stream enable already-enabled outcomes are treated as idempotent success with status/disable follow-ups.",
   'For Electron desktop apps, enable agent_browser_electron through agent_browser_tools for wrapper-owned discovery, isolated launch, status, compact probe, and cleanup: list first, treat likely-sensitive annotations as hints rather than enforcement, launch with the default snapshot handoff unless handoff: "tabs" is the safer diagnostic starting point, use agent_browser_electron probe or snapshot -i/agent_browser_qa attached:true for current-session state, and always cleanup the returned launchId when done. agent_browser_electron launch uses an isolated temporary profile; it does not reuse the app\'s normal signed-in profile or attach to an already-running authenticated app. For signed-in local app state, host-launch the normal app with --remote-debugging-port when appropriate, then use raw args connect <port|url>; after connect, run get url to verify the active target before page-content reads, inspect tab list, select the stable tab id such as tab t2, verify it again with get url, then run a condition wait or snapshot -i before using refs. close commands (`close`, `quit`, or `exit`) only close the browser/CDP session; leave manually launched app shutdown, profile cleanup, and explicit artifacts to the host owner.',
   "For provider or specialized app workflows, load version-matched upstream guidance with skills get agentcore|electron|slack|dogfood|vercel-sandbox|derive-client through the native tool; add --full when you need references/templates, and use skills get --all only for broad skill audits. Use derive-client when recording HAR traffic to generate a standalone API client; prefer network har start (text bodies by default) or network har start --content all|none before multi-step capture. For accessibility audits use a11y or a11y --tags wcag2a,wcag2aa (CDP browsers only). Hosted sandbox workflows should use upstream @agent-browser/sandbox helpers outside this wrapper. Provider launches such as -p ios, --provider browserbase/kernel/browseruse/browserless/agentcore, and iOS --device are upstream-owned setup paths; use sessionMode fresh when switching providers and expect external credentials or local Appium/Xcode setup to be required.",
@@ -33976,6 +34809,7 @@ var SHARED_BROWSER_PLAYBOOK_GUIDELINES = [
   "For evidence-only screenshots, QA captures, or other audit artifacts, save to an explicit path and branch on details.artifactVerification plus details.artifacts before reporting PASS/FAIL; do not require vision review of inline image attachments unless the user asked for visual inspection.",
   "Respect explicit user stop boundaries yourself. When the surrounding authenticated employee or automation context is explicitly unattended/auto-approved, ordinary non-destructive form submissions within the requested flow may proceed without separate confirmation. Still require explicit authorization for purchases, production-control actions, destructive or irreversible actions, and account, security, or privacy changes. The wrapper does not infer broad business intent from prompt text; details.promptGuard is reserved for concrete artifact-before-close checks.",
   "Recording needs ffmpeg on PATH before start. Current upstream checks it at startup; older natives may defer failure. A pending recording is not verified output.",
+  "Native 0.41 mcp call and stdin-driven MCP can finish normally, but this wrapper currently rejects all non-help mcp invocations. Session/namespace coordination and credential/image presentation are not integrated; use ordinary agent_browser commands.",
   "Do not call --help or other exploratory inspection commands unless the user explicitly asks for them or debugging the browser integration is necessary."
 ];
 var TOOL_PROMPT_GUIDELINES_SUFFIX = [
@@ -34020,7 +34854,7 @@ function buildToolPromptGuidelines(options) {
   return [
     ...options.includeWebSearch ? ["Prefer agent_browser_web_search for facts; agent_browser for pages."] : TOOL_PROMPT_GUIDELINES_PREFIX,
     ...options.docs ? [buildInstalledDocsGuideline(options.docs)] : [],
-    ...RUNTIME_PROMPT_GUIDELINES,
+    ...options.compact ? RUNTIME_PROMPT_GUIDELINES : [],
     ...browserExecutablePathGuideline !== void 0 ? [browserExecutablePathGuideline] : [],
     ...browserDefaultProfileGuideline !== void 0 ? [browserDefaultProfileGuideline] : [],
     TOOL_PROMPT_GUIDELINES_SUFFIX[0]
@@ -36376,11 +37210,13 @@ function sleepWithAbort(ms, signal) {
   });
 }
 var WebSearchRequestGate = class {
+  // A performance.now() timestamp (0 before the first request), so a system clock step neither
+  // skips nor extends the spacing between requests.
   lastRequestStartedAt = 0;
   tail = Promise.resolve();
   run(signal, task) {
     const runTask = async () => {
-      const elapsedMs = this.lastRequestStartedAt === 0 ? WEB_SEARCH_MIN_REQUEST_INTERVAL_MS : Date.now() - this.lastRequestStartedAt;
+      const elapsedMs = this.lastRequestStartedAt === 0 ? WEB_SEARCH_MIN_REQUEST_INTERVAL_MS : performance.now() - this.lastRequestStartedAt;
       const waitMs = Math.max(0, WEB_SEARCH_MIN_REQUEST_INTERVAL_MS - elapsedMs);
       if (waitMs > 0) {
         await sleepWithAbort(waitMs, signal);
@@ -36388,7 +37224,7 @@ var WebSearchRequestGate = class {
       if (signal?.aborted === true) {
         signal.throwIfAborted();
       }
-      this.lastRequestStartedAt = Date.now();
+      this.lastRequestStartedAt = performance.now();
       return task();
     };
     const result = this.tail.then(runTask, runTask);
@@ -36761,7 +37597,7 @@ function createAgentBrowserWebSearchTool(configState, options = {}) {
 
 // dist/extensions/agent-browser/lib/bash-guard.js
 init_parsing();
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 var DIRECT_AGENT_BROWSER_BASH_BYPASS_ENV = "PI_AGENT_BROWSER_ALLOW_DIRECT_BASH";
 var DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN = /^(?:[.~]|\.\.?|\/)?(?:[^\s;&|]+\/)?agent-browser$/;
@@ -36934,7 +37770,7 @@ function isTruthyEnvValue(value) {
 }
 async function isPackageDevelopmentCwd(cwd) {
   try {
-    const packageJson = JSON.parse(await readFile4(join14(cwd, "package.json"), "utf8"));
+    const packageJson = JSON.parse(await readFile5(join14(cwd, "package.json"), "utf8"));
     return isRecord(packageJson) && packageJson.name === PACKAGE_NAME;
   } catch {
     return false;
@@ -36945,6 +37781,16 @@ async function isDirectAgentBrowserBashAllowed(cwd) {
 }
 
 // dist/extensions/agent-browser/lib/orchestration/extension-prompt.js
+var COMPACT_FALLBACK_ENV = "AGENT_BROWSER_COMPACT_FALLBACK";
+var PLAYBOOK_MODE_ENV = "AGENT_BROWSER_PLAYBOOK";
+function isCompactFallbackEnabled() {
+  const compactEnv = process.env[COMPACT_FALLBACK_ENV]?.trim().toLowerCase();
+  if (compactEnv === "1" || compactEnv === "true" || compactEnv === "yes") {
+    return true;
+  }
+  const playbookEnv = process.env[PLAYBOOK_MODE_ENV]?.trim().toLowerCase();
+  return playbookEnv === "compact" || playbookEnv === "minimal" || playbookEnv === "0" || playbookEnv === "false";
+}
 function isBashToolCallEvent(event) {
   return isRecord(event) && event.toolName === "bash" && isRecord(event.input) && typeof event.input.command === "string";
 }
@@ -36981,6 +37827,7 @@ function shouldIncludeProjectConfig(ctx, argv = process.argv) {
 }
 var BrowserPrompt = class {
   pi;
+  docsPaths;
   state;
   webSearchToolRegistered = false;
   constructor(pi) {
@@ -37018,7 +37865,7 @@ var BrowserPrompt = class {
     });
     this.webSearchToolRegistered = true;
   }
-  instructions(ctx) {
+  instructions(ctx, options) {
     const config = loadAgentBrowserConfigSync({
       cwd: ctx.cwd,
       includeProjectConfig: shouldIncludeProjectConfig(ctx)
@@ -37031,18 +37878,22 @@ var BrowserPrompt = class {
 
 Project agent_browser config guidance:
 ${guidance.map((line) => `- ${line}`).join("\n")}` : "";
+    const compact = !(options?.forceFull ?? false) && isCompactFallbackEnabled();
     const guidelines = [
       ...buildToolPromptGuidelines({
+        compact,
         browserDefaultProfile: config.trustedBrowserDefaultProfile,
         browserExecutablePath: config.trustedBrowserExecutablePath,
         includeWebSearch: this.webSearchToolRegistered,
-        docs: getInstalledDocsPaths()
+        docs: this.docsPaths ??= getInstalledDocsPaths()
       }),
-      ...QUICK_START_GUIDELINES,
-      ...SHARED_BROWSER_PLAYBOOK_GUIDELINES,
-      ...WRAPPER_TAB_RECOVERY_BEHAVIOR,
-      ...Object.values(ADVANCED_TOOL_PROMPT_GUIDELINES).flat(),
-      ...this.webSearchToolRegistered ? WEB_SEARCH_TOOL_PROMPT_GUIDELINES : []
+      ...compact ? [] : [
+        ...QUICK_START_GUIDELINES,
+        ...SHARED_BROWSER_PLAYBOOK_GUIDELINES,
+        ...WRAPPER_TAB_RECOVERY_BEHAVIOR,
+        ...Object.values(ADVANCED_TOOL_PROMPT_GUIDELINES).flat(),
+        ...this.webSearchToolRegistered ? WEB_SEARCH_TOOL_PROMPT_GUIDELINES : []
+      ]
     ];
     return `${PROJECT_RULE_PROMPT}
 
@@ -37064,7 +37915,7 @@ ${[...new Set(guidelines)].map((line) => `- ${line}`).join("\n")}${configPrompt}
           "agent_browser_web_search",
           ...Object.values(AGENT_BROWSER_TOOL_INVENTORY).map(({ name }) => name)
         ],
-        instructions: (ctx) => this.instructions(ctx)
+        instructions: (ctx) => this.instructions(ctx, { forceFull: true })
       }
     ]);
     setManaged(() => {
@@ -37237,10 +38088,9 @@ function syncOwnedManagedSessionsFromResult(sessions, result, cwd) {
   retireOutcomeOwner(sessions, outcome, details, current);
 }
 async function closeOwnedManagedSessionsExcept(sessions, pages, settings, options) {
-  const keepKey = getSessionContextKey(options.keepSessionName, options.keepNamespace);
   const owners = Array.from(sessions);
   for (const [key, owner] of owners) {
-    if (key === keepKey) {
+    if (options.keepKeys.has(key)) {
       continue;
     }
     const error = await closeManagedSession({
@@ -38421,8 +39271,8 @@ init_managed_session_daemon_policy();
 
 // dist/extensions/agent-browser/lib/input-modes/script.js
 init_types();
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname13, join as join27 } from "node:path";
+import { existsSync as existsSync4, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname14, join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import which2 from "which";
 
@@ -38955,19 +39805,19 @@ function resolveScriptChildNodePath(options) {
   return nodePath;
 }
 function resolveScriptWorkerPath() {
-  let currentDir = dirname13(fileURLToPath2(import.meta.url));
-  while (!existsSync4(join27(currentDir, "package.json"))) {
-    const parentDir = dirname13(currentDir);
+  let currentDir = dirname14(fileURLToPath2(import.meta.url));
+  while (!existsSync4(join28(currentDir, "package.json"))) {
+    const parentDir = dirname14(currentDir);
     if (parentDir === currentDir) {
       throw new Error("Unable to resolve the pi-agent-browser-native package root.");
     }
     currentDir = parentDir;
   }
-  const workerPath = join27(currentDir, "dist", "extensions", "agent-browser", "script-worker.js");
+  const workerPath = join28(currentDir, "dist", "extensions", "agent-browser", "script-worker.js");
   if (!existsSync4(workerPath)) {
     throw new Error("Compiled script worker is missing; run npm run build or reinstall pi-agent-browser-native.");
   }
-  return workerPath;
+  return realpathSync5(workerPath);
 }
 function createAgentBrowserScriptCloseArgs(sessionName) {
   return ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, "close"];
@@ -39821,6 +40671,21 @@ function restoreAttachedSessionKeysFromBranch(branch) {
 }
 
 // dist/extensions/agent-browser/lib/orchestration/extension-branch-restore.js
+function isActiveOnBranch(events, key) {
+  const active = events.managedSessionActiveRanks.get(key);
+  const closed = events.managedSessionCloseRanks.get(key);
+  return active !== void 0 && (closed === void 0 || closed < active);
+}
+function* restorableBranchManagedIdentities(events, baseName) {
+  for (const [key, identity] of events.managedSessionActiveIdentities) {
+    if (isActiveOnBranch(events, key) && isRestorableManagedSessionName(identity.sessionName, baseName)) {
+      yield [key, identity];
+    }
+  }
+}
+function getOwnerKey(sessionName, namespace) {
+  return getSessionContextKey(sessionName, typeof namespace === "string" ? namespace : void 0) ?? sessionName;
+}
 async function readBranchForRestore(runtime, ctx, resetRuntimeOwnership) {
   runtime.branch.beginRestore(ctx.sessionManager.getSessionId());
   runtime.prompt.restore(ctx);
@@ -39924,7 +40789,7 @@ var BrowserBranchRestoration = class {
     }
   }
   restoreManagedOwners() {
-    for (const [sessionKey, identity] of this.branchResourceEvents.managedSessionActiveIdentities) {
+    for (const [sessionKey, identity] of restorableBranchManagedIdentities(this.branchResourceEvents, this.runtime.managed.baseName)) {
       this.restoreBranchManagedOwner(sessionKey, identity);
     }
     if (this.restoredState.active) {
@@ -39939,14 +40804,9 @@ var BrowserBranchRestoration = class {
     }
   }
   sessionActiveOnBranch(key) {
-    const active = this.branchResourceEvents.managedSessionActiveRanks.get(key);
-    const closed = this.branchResourceEvents.managedSessionCloseRanks.get(key);
-    return active !== void 0 && (closed === void 0 || closed < active);
+    return isActiveOnBranch(this.branchResourceEvents, key);
   }
   restoreBranchManagedOwner(key, identity) {
-    if (!this.sessionActiveOnBranch(key) || !isRestorableManagedSessionName(identity.sessionName, this.runtime.managed.baseName)) {
-      return;
-    }
     const launch = this.branchResourceEvents.managedSessionLaunchState.get(key);
     trackOwnedManagedSession(this.runtime.managed.owned, identity.sessionName, launch?.cwd ?? this.ctx.cwd, {
       branchOwned: true,
@@ -40047,6 +40907,24 @@ async function restoreBranchBackedState(runtime, ctx, options) {
   const input = await readBranchForRestore(runtime, ctx, options.resetRuntimeOwnership);
   return new BrowserBranchRestoration(runtime, ctx, input).run();
 }
+async function readTransferableManagedSessionKeys(runtime, ctx) {
+  const branch = await readBrowserEntries(ctx.sessionManager);
+  const { baseName } = runtime.managed;
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key] of restorableBranchManagedIdentities(collectBranchManagedResourceEvents(branch), baseName)) {
+    keys.add(key);
+  }
+  const current = restoreManagedSessionStateFromBranch([...branch], baseName);
+  if (current.active) {
+    keys.add(getOwnerKey(current.sessionName, current.namespace));
+  }
+  for (const begin of collectPendingOwnedBrowserIntents(branch, runtime.branch.ownerSessionId)) {
+    if (typeof begin.state.sessionName === "string") {
+      keys.add(getOwnerKey(begin.state.sessionName, begin.state.namespace));
+    }
+  }
+  return keys;
+}
 
 // dist/extensions/agent-browser/lib/orchestration/extension-lifecycle.js
 var BrowserLifecycle = class {
@@ -40076,8 +40954,22 @@ var BrowserLifecycle = class {
     await this.runtime.code.settle();
     await this.runtime.managedSessionExecutionQueue.run(() => this.runtime.artifacts.queue.run(() => this.restore(ctx, false)));
   }
-  async cleanup(ctx, quitting) {
+  async retainedManagedSessionKeys(ctx, scope) {
+    const { managed } = this.runtime;
+    if (scope === "quit") {
+      return /* @__PURE__ */ new Set();
+    }
+    if (scope === "restart" && ctx) {
+      try {
+        return await readTransferableManagedSessionKeys(this.runtime, ctx);
+      } catch {
+      }
+    }
+    return managed.active ? /* @__PURE__ */ new Set([getSessionContextKey(managed.name, managed.namespace) ?? managed.name]) : /* @__PURE__ */ new Set();
+  }
+  async cleanup(ctx, scope) {
     const { runtime } = this;
+    const quitting = scope === "quit";
     const active = getActiveElectronRecords(runtime.electron.records);
     const preserved = quitting ? active.filter((record) => !runtime.electron.ownedRecords.has(record.launchId)).map((record) => record.userDataDir) : active.map((record) => record.userDataDir);
     const records = quitting ? runtime.electron.ownedRecords : getOffBranchOwnedElectronLaunchRecords(runtime.electron.ownedRecords, runtime.electron.records);
@@ -40102,8 +40994,7 @@ var BrowserLifecycle = class {
       restore: runtime.managed.restore,
       timeoutMs: runtime.implicitSessionCloseTimeoutMs
     }, {
-      keepSessionName: !quitting && runtime.managed.active ? runtime.managed.name : void 0,
-      keepNamespace: !quitting && runtime.managed.active ? runtime.managed.namespace : void 0,
+      keepKeys: await this.retainedManagedSessionKeys(ctx, scope),
       onClosed: (owner) => runtime.recordings.retire(owner.sessionName, owner.namespace)
     });
     runtime.recordings.flush();
@@ -40118,22 +41009,25 @@ var BrowserLifecycle = class {
     runtime.recordings.resetIfClean();
     runtime.electron.reset();
   }
-  async shutdown(ctx, quitting) {
+  async shutdown(ctx, scope) {
     await this.runtime.code.settle();
     this.runtime.branch.invalidate();
-    const preservePaths = await this.runtime.managedSessionExecutionQueue.run(() => this.runtime.artifacts.queue.run(() => this.cleanup(ctx, quitting)));
+    const preservePaths = await this.runtime.managedSessionExecutionQueue.run(() => this.runtime.artifacts.queue.run(() => this.cleanup(ctx, scope)));
     this.reset();
     await cleanupSecureTempArtifacts({ preservePaths });
   }
 };
-function isQuitting(event) {
-  return event?.reason === "quit";
+function getShutdownScope(event) {
+  if (event?.reason !== "quit") {
+    return "replace";
+  }
+  return event.disposition === "handoff" || event.disposition === "provisional" ? "restart" : "quit";
 }
 function registerBrowserLifecycle(runtime) {
   const lifecycle = new BrowserLifecycle(runtime);
   runtime.pi.on("session_start", (_event, ctx) => lifecycle.start(ctx));
   runtime.pi.on("session_tree", (_event, ctx) => lifecycle.tree(ctx));
-  runtime.pi.on("session_shutdown", (event, ctx) => lifecycle.shutdown(ctx, isQuitting(event)));
+  runtime.pi.on("session_shutdown", (event, ctx) => lifecycle.shutdown(ctx, getShutdownScope(event)));
 }
 
 // dist/extensions/agent-browser/lib/orchestration/extension-tool-boundary.js
@@ -40264,14 +41158,14 @@ init_process_environment();
 init_runtime();
 import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir4 } from "node:os";
-import { join as join28, resolve as resolve13 } from "node:path";
+import { join as join29, resolve as resolve13 } from "node:path";
 
 // dist/extensions/agent-browser/lib/orchestration/native-config.js
 init_parsing();
 init_argv_grammar();
 init_process();
 init_envelope();
-import { readFile as readFile9, rm as rm12 } from "node:fs/promises";
+import { readFile as readFile10, rm as rm12 } from "node:fs/promises";
 var VALUE_DEFAULTS = [
   "executablePath",
   "profile",
@@ -40326,7 +41220,7 @@ function requestsLaunch(config, options) {
 }
 async function readConfigFile(path) {
   try {
-    const config = JSON.parse(await readFile9(path, "utf8"));
+    const config = JSON.parse(await readFile10(path, "utf8"));
     if (!isRecord(config)) {
       return void 0;
     }
@@ -40819,7 +41713,16 @@ function cliValue2(args, flag) {
 function requestsConnection(tokens, stdin) {
   return tokens[0] === "connect" || getUpstreamEffectiveBatchSteps(tokens, stdin).some((step) => requestsConnection(step));
 }
-function rootBrowserSessionName(rootSessionId) {
+function rootPiSessionId(sessionId) {
+  const root = process.env.PI_INTERCOM_ROOT_SESSION_ID;
+  if (root !== void 0 && root !== "" && root === root.trim() && root === process.env.PI_INTERCOM_PARENT_SESSION_ID) {
+    return root;
+  }
+  const legacyRoot = process.env.PI_SUBAGENT_ROOT_SESSION_ID;
+  return process.env.PI_SUBAGENT_CHILD === "1" && legacyRoot !== void 0 && legacyRoot !== "" ? legacyRoot : sessionId;
+}
+function rootBrowserSessionName(sessionId) {
+  const rootSessionId = rootPiSessionId(sessionId);
   return `pi-root-${createHash6("sha256").update(rootSessionId).digest("hex").slice(0, 24)}`;
 }
 function nativeBooleanOverrides(args) {
@@ -40850,10 +41753,10 @@ var NativeSessionCall = class {
     const configArg = scanUpstreamGlobalFlagOccurrences([...input.toolArgs], "--config").at(0);
     this.configPath = configArg?.value ?? this.env.AGENT_BROWSER_CONFIG;
     this.configPaths = this.configPath !== void 0 ? [resolve13(context2.cwd, this.configPath)] : [
-      join28(homedir4(), ".agent-browser", "config.json"),
-      join28(context2.cwd, "agent-browser.json")
+      join29(homedir4(), ".agent-browser", "config.json"),
+      join29(context2.cwd, "agent-browser.json")
     ];
-    this.rootName = context2.root === void 0 ? void 0 : rootBrowserSessionName(context2.root.id);
+    this.rootName = context2.root === void 0 ? void 0 : rootBrowserSessionName(context2.root.sessionId);
     this.browserCommand = input.kind !== "electron" && needsManagedSession(parseArgvDescriptor([...input.toolArgs]), input.toolStdin);
     const session = extractExplicitSessionName([...input.toolArgs]);
     this.rootFallback = context2.root !== void 0 && this.env.AGENT_BROWSER_SESSION === void 0 && (session === void 0 || session === this.rootName) && this.browserCommand;
@@ -40922,10 +41825,10 @@ var NativeSessionCall = class {
     };
   }
   booleanEnvironment(args) {
-    const debug = getBooleanFlagValue([...args], "--debug");
+    const debug2 = getBooleanFlagValue([...args], "--debug");
     const noAutoDialog = getBooleanFlagValue([...args], "--no-auto-dialog");
     return {
-      ...debug !== void 0 ? { AGENT_BROWSER_DEBUG: debug ? "1" : void 0 } : {},
+      ...debug2 !== void 0 ? { AGENT_BROWSER_DEBUG: debug2 ? "1" : void 0 } : {},
       ...noAutoDialog !== void 0 ? { AGENT_BROWSER_NO_AUTO_DIALOG: noAutoDialog ? "1" : "0" } : {}
     };
   }
@@ -40988,18 +41891,18 @@ async function withNativeSessionDefaults(input, context2, run) {
 // dist/extensions/agent-browser/lib/execution-cwd.js
 init_parsing();
 import { readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { dirname as dirname14, isAbsolute as isAbsolute11, join as join29 } from "node:path";
+import { dirname as dirname15, isAbsolute as isAbsolute11, join as join30 } from "node:path";
 function isDirectoryOwner(source) {
   if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source)) {
     return true;
   }
-  const directories = [source.baseDir, isAbsolute11(source.path) ? dirname14(source.path) : void 0];
+  const directories = [source.baseDir, isAbsolute11(source.path) ? dirname15(source.path) : void 0];
   return directories.some((directory) => {
     if (directory === void 0 || directory.length === 0 || !isAbsolute11(directory)) {
       return false;
     }
     try {
-      const manifest = JSON.parse(readFileSync6(join29(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync6(join30(directory, "package.json"), "utf8"));
       return isRecord(manifest) && manifest.name === "pi-change-working-dir";
     } catch {
       return false;
@@ -41053,8 +41956,8 @@ init_argv_grammar();
 init_artifact_manifest();
 init_runtime();
 init_text();
-import { mkdir as mkdir5, readFile as readFile10, realpath as realpath3, stat as stat14, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname15, extname as extname7, isAbsolute as isAbsolute12, resolve as resolve14 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile11, realpath as realpath3, stat as stat14, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname16, extname as extname7, isAbsolute as isAbsolute12, resolve as resolve14 } from "node:path";
 function normalizeRequestedOutputPath(path) {
   return path.startsWith("@") ? path.slice(1) : path;
 }
@@ -41090,7 +41993,7 @@ async function readCompactedSpill(path, manifest) {
   if (path === void 0 || path.length === 0 || live !== true) {
     throw new Error("Full compacted output is unavailable from the wrapper-managed spill; outputPath was not written.");
   }
-  const text3 = await readFile10(path, "utf8");
+  const text3 = await readFile11(path, "utf8");
   if (extname7(path) !== ".json") {
     return text3;
   }
@@ -41247,7 +42150,7 @@ async function saveOutput(result, destination, preserveText) {
   const payload = await getOutputPayload(result);
   const serialized = typeof payload.value === "string" ? payload.value : `${JSON.stringify(payload.value, null, 2)}
 `;
-  await mkdir5(dirname15(destination.absolutePath), { recursive: true });
+  await mkdir5(dirname16(destination.absolutePath), { recursive: true });
   await writeFile3(destination.absolutePath, serialized, "utf8");
   const bytes = Buffer.byteLength(serialized, "utf8");
   const outputFile = {
@@ -41298,7 +42201,7 @@ init_batch_stdin();
 function parseRawArtifactSteps(commands) {
   const steps = [];
   for (const command of commands) {
-    if (command === "--bail") {
+    if (isNativeBatchOption(command)) {
       continue;
     }
     const parsed = parseBatchCommandArgument(command);
@@ -41559,7 +42462,7 @@ var OperationPathBinding = class {
   }
   bindRawBatchRows() {
     for (let index = 1; index < this.tokens.length; index++) {
-      if (this.tokens[index] === "--bail") {
+      if (isNativeBatchOption(this.tokens[index])) {
         continue;
       }
       const row = parseBatchCommandArgument(this.tokens[index]).step;
@@ -41592,7 +42495,7 @@ var OperationPathBinding = class {
     this.bindWebMcpParams();
   }
   bindBatch(stdin) {
-    if (this.tokens.slice(1).some((token) => token !== "--bail")) {
+    if (this.tokens.slice(1).some((token) => !isNativeBatchOption(token))) {
       this.bindRawBatchRows();
       return { args: this.result, stdin };
     }
@@ -42062,7 +42965,7 @@ var ElectronHostCoordinator = class {
       return await withBrowserExecutionLocks({
         identities,
         signal: this.call.signal,
-        deadline: Date.now() + this.call.executionTimeoutMs,
+        deadline: performance.now() + this.call.executionTimeoutMs,
         waitOnly: true
       }, (signal) => this.execute(signal));
     } catch (error) {
@@ -42636,6 +43539,11 @@ init_command_taxonomy();
 init_session_state();
 init_artifact_manifest();
 init_read_confirmation();
+function withoutCommand(step) {
+  const visible = { ...step };
+  delete visible.command;
+  return visible;
+}
 var BrowserCommandResult = class {
   runtime;
   call;
@@ -42892,12 +43800,28 @@ var BrowserCommandResult = class {
         throw new Error("The selected Pi branch changed before browser-state confirmation.");
       }
     } catch (error) {
-      return this.persistenceFailure(error);
+      return this.omitIndexedBatchCommands(this.persistenceFailure(error));
     }
     this.runtime.sessions.pages.applyBrowserRecord(finish);
     this.runtime.artifacts.manifest = applyArtifactChanges(this.runtime.artifacts.manifest, finish.event.artifacts);
     return void 0;
   }
+  omitIndexedBatchCommands(result) {
+    const details = result.details;
+    const tokens = extractUpstreamCommandTokens(this.call.toolArgs);
+    if (!isRecord(details) || tokens[0] !== "batch" || !tokens.includes("--omit-command") || !Array.isArray(details.batchSteps)) {
+      return result;
+    }
+    const failure = details.batchFailure;
+    return {
+      ...result,
+      details: {
+        ...details,
+        batchSteps: details.batchSteps.map((step) => isRecord(step) ? withoutCommand(step) : step),
+        ...isRecord(failure) && isRecord(failure.failedStep) ? { batchFailure: { ...failure, failedStep: withoutCommand(failure.failedStep) } } : {}
+      }
+    };
+  }
   async complete() {
     if (isRecord(this.result.details)) {
       this.result.details.browserEventVersion = 1;
@@ -42906,12 +43830,13 @@ var BrowserCommandResult = class {
       }
       this.result.details.artifactManifest = invocationArtifactManifest(this.call.branch.isCurrent() ? this.runtime.artifacts.manifest : this.prepared.browserRunState.artifactManifest, this.dispatch.initialArtifactManifest, this.result.details);
     }
-    return applyAgentBrowserOutputPath({
+    const result = await applyAgentBrowserOutputPath({
       cwd: this.call.operationCwd,
       outputPath: this.call.outputPath,
       preserveTextContent: Array.isArray(this.call.params.args) && isBooleanFlagEnabled(this.call.params.args, "--json"),
       result: warnRecordingPersistence(this.runtime.recordings.dirty, this.result)
     });
+    return this.omitIndexedBatchCommands(result);
   }
 };
 
@@ -43205,7 +44130,7 @@ var BrowserCommandCoordinator = class {
   }
   deadline() {
     const url = this.runtime.sessions.pages.get(this.key).tabTarget?.url;
-    return Date.now() + (this.call.params.timeoutMs ?? getCommandAwareProcessTimeoutMs(extractUpstreamCommandTokens(this.call.toolArgs), this.call.resolvedInput.toolStdin, url) ?? getAgentBrowserProcessTimeoutMs());
+    return performance.now() + (this.call.params.timeoutMs ?? getCommandAwareProcessTimeoutMs(extractUpstreamCommandTokens(this.call.toolArgs), this.call.resolvedInput.toolStdin, url) ?? getAgentBrowserProcessTimeoutMs());
   }
   async runLocked() {
     if (!this.needsIdentityLock()) {
@@ -43378,11 +44303,9 @@ var BrowserAdmission = class {
     if (!this.canSelectNativeRoot(call)) {
       return void 0;
     }
-    const root = process.env.PI_SUBAGENT_ROOT_SESSION_ID;
-    const id = process.env.PI_SUBAGENT_CHILD === "1" && root !== void 0 && root !== "" ? root : call.ctx.sessionManager.getSessionId();
     const profile = config.trustedBrowserDefaultProfile;
     return {
-      id,
+      sessionId: call.ctx.sessionManager.getSessionId(),
       profile: profile?.policy === "always" && !/[\\/~]/.test(profile.name) ? profile.name : void 0,
       executablePath: config.trustedBrowserExecutablePath
     };
@@ -43522,6 +44445,7 @@ var BrowserCodeExecution = class {
   runtime;
   invocation;
   operationCwd;
+  /** A performance.now() timestamp bounding the whole cell, unaffected by wall-clock steps. */
   deadline;
   output = createBrowserCodeOutput();
   nativeEnvironment = getAgentBrowserProcessEnvironment();
@@ -43535,7 +44459,7 @@ var BrowserCodeExecution = class {
     this.runtime = runtime;
     this.invocation = invocation;
     this.operationCwd = operationCwd;
-    this.deadline = Date.now() + (invocation.params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS);
+    this.deadline = performance.now() + (invocation.params.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS);
   }
   start() {
     const { runtime, invocation } = this;
@@ -43579,10 +44503,8 @@ var BrowserCodeExecution = class {
       includeProjectConfig: shouldIncludeProjectConfig(invocation.ctx)
     });
     const profile = config.trustedBrowserDefaultProfile;
-    const root = process.env.PI_SUBAGENT_ROOT_SESSION_ID;
-    const id = process.env.PI_SUBAGENT_CHILD === "1" && root !== void 0 && root !== "" ? root : invocation.ctx.sessionManager.getSessionId();
     return {
-      id,
+      sessionId: invocation.ctx.sessionManager.getSessionId(),
       profile: profile?.policy === "always" && !/[\\/~]/.test(profile.name) ? profile.name : void 0,
       executablePath: config.trustedBrowserExecutablePath
     };
@@ -43652,7 +44574,7 @@ var BrowserCodeExecution = class {
       params: {
         args,
         stdin: inner.stdin,
-        timeoutMs: Math.min(inner.timeoutMs ?? this.deadline - Date.now(), Math.max(1, this.deadline - Date.now()))
+        timeoutMs: Math.min(inner.timeoutMs ?? this.remainingMs(), Math.max(1, this.remainingMs()))
       },
       signal: innerSignal,
       ctx,
@@ -43668,11 +44590,15 @@ var BrowserCodeExecution = class {
     }
     return this.output.observe(result);
   }
+  /** Whole milliseconds left in the cell: inner calls and the script child take integer timeouts. */
+  remainingMs() {
+    return Math.ceil(this.deadline - performance.now());
+  }
   async runCell(signal, identity) {
     const run = await runAgentBrowserScript({
       code: this.invocation.params.code,
       signal,
-      timeoutMs: Math.max(1, this.deadline - Date.now()),
+      timeoutMs: Math.max(1, this.remainingMs()),
       emitImage: (image) => this.output.emitImage(image),
       dispatch: (inner, innerSignal) => this.dispatch(inner, innerSignal, identity)
     });
@@ -43724,7 +44650,7 @@ var BrowserCodeExecution = class {
   }
   async run() {
     this.start();
-    const timer = setTimeout(() => this.controller.abort(new DOMException("Browser code deadline exceeded.", "TimeoutError")), Math.max(0, this.deadline - Date.now()));
+    const timer = setTimeout(() => this.controller.abort(new DOMException("Browser code deadline exceeded.", "TimeoutError")), Math.max(0, this.remainingMs()));
     try {
       const input = this.prepare();
       if (input.status === "invalid") {