pi-agent-browser-native 0.9.5 → 0.9.6

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

@@ -959,8 +959,7 @@ function getCommandSubcommand(tokens) {
   }
   return tokens.at(1);
 }
-function parseCommandInfoFromTokens(commandTokens) {
-  const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
+function parseCommandInfoFromTokens(upstreamCommandTokens) {
   const command = upstreamCommandTokens[0];
   return {
     command,
@@ -968,13 +967,13 @@ function parseCommandInfoFromTokens(commandTokens) {
   };
 }
 function parseCommandInfo(args) {
-  return parseCommandInfoFromTokens(extractCommandTokens(args));
+  return parseCommandInfoFromTokens(extractUpstreamCommandTokens(args));
 }
 function parseArgvDescriptor(args) {
   const commandTokens = extractCommandTokens(args);
   const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
   return {
-    commandInfo: parseCommandInfoFromTokens(commandTokens),
+    commandInfo: parseCommandInfoFromTokens(upstreamCommandTokens),
     commandTokens,
     upstreamCommandTokens
   };
@@ -1054,16 +1053,16 @@ function isString(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every(isString);
 }
-function getSelectValues(input, context) {
+function getSelectValues(input, context2) {
   const rawValue = input.value;
   const rawValues = input.values;
   if (rawValue !== void 0 && rawValues !== void 0) {
-    return { error: `${context}.value and ${context}.values cannot both be provided for select.` };
+    return { error: `${context2}.value and ${context2}.values cannot both be provided for select.` };
   }
   if (rawValues !== void 0) {
     if (!isStringArray(rawValues) || rawValues.length === 0 || rawValues.some((value) => value.trim().length === 0)) {
       return {
-        error: `${context}.values must be a non-empty array of non-empty strings for select.`
+        error: `${context2}.values must be a non-empty array of non-empty strings for select.`
       };
     }
     return { values: rawValues };
@@ -1071,7 +1070,7 @@ function getSelectValues(input, context) {
   if (typeof rawValue === "string" && rawValue.trim().length > 0) {
     return { values: [rawValue] };
   }
-  return { error: `${context}.value or ${context}.values is required for select.` };
+  return { error: `${context2}.value or ${context2}.values is required for select.` };
 }
 function getBatchResultItems(data) {
   return Array.isArray(data) ? data.filter(isRecord) : [];
@@ -1526,24 +1525,22 @@ function redactEmbeddedStructuredText(text3, redact) {
   let output = "";
   let cursor = 0;
   const findEnd = createBalancedJsonEndFinder(text3);
-  while (cursor < text3.length) {
-    const char = text3[cursor];
-    if (char !== "{" && char !== "[") {
-      output += char;
-      cursor += 1;
-      continue;
-    }
-    const endIndex = findEnd(cursor);
+  const openers = /[[{]/g;
+  let match;
+  while ((match = openers.exec(text3)) !== null) {
+    const endIndex = findEnd(match.index);
     if (endIndex === void 0) {
-      output += char;
-      cursor += 1;
       continue;
     }
-    const candidate = text3.slice(cursor, endIndex + 1);
-    output += redactSerializedJson(candidate, redact) ?? candidate;
-    cursor = endIndex + 1;
+    const candidate = text3.slice(match.index, endIndex + 1);
+    const redacted = redactSerializedJson(candidate, redact) ?? candidate;
+    if (redacted !== candidate) {
+      output += text3.slice(cursor, match.index) + redacted;
+      cursor = endIndex + 1;
+    }
+    openers.lastIndex = endIndex + 1;
   }
-  return output;
+  return cursor === 0 ? text3 : output + text3.slice(cursor);
 }
 var init_redaction_json = __esm({
   "dist/extensions/agent-browser/lib/redaction-json.js"() {
@@ -3502,7 +3499,7 @@ function getSupersededRecordingKeys(candidates, entry, key) {
     return [];
   }
   const entrySessionKey = entry.session !== void 0 && entry.session.length > 0 ? getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) : void 0;
-  return candidates.filter(([candidateKey2, candidate]) => {
+  return [...candidates].filter(([candidateKey2, candidate]) => {
     const sameRecordingSession = entrySessionKey === void 0 ? candidate.session === void 0 : candidate.session !== void 0 && getAgentBrowserSessionIdentityKey(candidate.session, candidate.namespace) === entrySessionKey;
     return candidateKey2 !== key && sameRecordingSession && candidate.kind === "video" && isPendingRecordingArtifact(candidate);
   }).map(([candidateKey2]) => candidateKey2);
@@ -3536,7 +3533,7 @@ function mergeSessionArtifactManifest(options) {
   }).map(({ entry }) => entry);
   for (const entry of orderedEntries) {
     const key = getSessionArtifactManifestEntryKey(entry);
-    for (const candidateKey2 of getSupersededRecordingKeys([...byPath], entry, key)) {
+    for (const candidateKey2 of getSupersededRecordingKeys(byPath, entry, key)) {
       byPath.delete(candidateKey2);
     }
     const existing = byPath.get(key);
@@ -4414,25 +4411,142 @@ var init_process_errors = __esm({
   }
 });
 
-// dist/extensions/agent-browser/lib/launch-scoped-flags.js
-function hasLaunchScopedFlagToken(args, flag) {
-  const commandStartIndex = findCommandStartIndex(args);
-  const command = commandStartIndex === void 0 ? void 0 : args[commandStartIndex];
-  return args.some((token, index) => {
-    if (token.startsWith(`${flag}=`)) {
-      return flag === "--restore";
-    }
-    if (token !== flag) {
+// dist/extensions/agent-browser/lib/batch-lifecycle.js
+function rowCommand(value, fallback) {
+  return Array.isArray(value) && value.every((token) => typeof token === "string") ? value : fallback;
+}
+function rowResult(row) {
+  if (isRecord(row.result)) {
+    return row.result;
+  }
+  return isRecord(row.data) ? row.data : void 0;
+}
+function rowBrowserLaunched(row, result) {
+  const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : result?.lifecycle;
+  if (!isRecord(lifecycle) || !isRecord(lifecycle.effectiveLaunch)) {
+    return void 0;
+  }
+  const launched = lifecycle.effectiveLaunch.browserLaunched;
+  return typeof launched === "boolean" ? launched : void 0;
+}
+function lifecycleStep(value, fallback) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const result = rowResult(value);
+  const command = rowCommand(value.command, fallback);
+  return {
+    result,
+    succeeded: value.success === true,
+    browserLaunched: rowBrowserLaunched(value, result),
+    tokens: command === void 0 ? void 0 : extractUpstreamCommandTokens(command)
+  };
+}
+function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
+  if (!Array.isArray(data)) {
+    return false;
+  }
+  return data.some((row, index) => {
+    if (!isRecord(row) || row.success !== true) {
       return false;
     }
-    if (flag === "--auto-connect") {
-      return isBooleanFlagEnabled(args, flag);
+    const command = rowCommand(row.command, fallbackCommands.at(index));
+    return command !== void 0 && !detectConfirmationRequired(row.result) && isCloseAllCommand(extractUpstreamCommandTokens(command));
+  });
+}
+function successfulClose(step) {
+  return step.succeeded && step.tokens !== void 0 && !detectConfirmationRequired(step.result) && (isCloseCommand(step.tokens[0]) || isSuccessfulNativeConfirmedClose(step.tokens, step.result));
+}
+function closedState(step) {
+  const result = step.result;
+  const closeData = step.tokens?.[0] === "confirm" && isRecord(result) && isRecord(result.result) ? result.result.data : result;
+  return {
+    endsClosed: true,
+    browserActiveAfterClose: false,
+    recordingClosedAfterBatch: true,
+    statePath: isRecord(closeData) && typeof closeData.statePath === "string" ? closeData.statePath : void 0
+  };
+}
+function recordingState(state, step) {
+  const relaunched = step.browserLaunched !== false;
+  const browserActiveAfterClose = state.browserActiveAfterClose || relaunched;
+  let recordingClosedAfterBatch = state.recordingClosedAfterBatch;
+  const subcommand = step.tokens?.[1];
+  if (step.succeeded && subcommand === "stop") {
+    recordingClosedAfterBatch = true;
+  } else if (step.succeeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart")) {
+    recordingClosedAfterBatch = false;
+  }
+  return {
+    ...state,
+    endsClosed: state.endsClosed && !relaunched,
+    browserActiveAfterClose,
+    recordingClosedAfterBatch
+  };
+}
+function advanceClosedState(state, step) {
+  if (step.tokens?.[0] === "record") {
+    return recordingState(state, step);
+  }
+  if (step.browserLaunched === false) {
+    return state;
+  }
+  return {
+    ...state,
+    endsClosed: false,
+    browserActiveAfterClose: true,
+    recordingClosedAfterBatch: step.tokens === void 0 ? false : state.recordingClosedAfterBatch
+  };
+}
+function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
+  if (!Array.isArray(rows)) {
+    return void 0;
+  }
+  let state;
+  for (const [index, row] of rows.entries()) {
+    const step = lifecycleStep(row, fallbackCommands.at(index));
+    if (step === void 0) {
+      continue;
     }
-    if (flag === "--state" && command === "wait" && commandStartIndex !== void 0 && index > commandStartIndex) {
-      return false;
+    if (successfulClose(step)) {
+      state = closedState(step);
+    } else if (state !== void 0) {
+      state = advanceClosedState(state, step);
     }
+  }
+  return state === void 0 ? void 0 : {
+    endsClosed: state.endsClosed,
+    recordingClosedAfterBatch: state.recordingClosedAfterBatch,
+    statePath: state.statePath
+  };
+}
+var init_batch_lifecycle = __esm({
+  "dist/extensions/agent-browser/lib/batch-lifecycle.js"() {
+    "use strict";
+    init_argv_descriptor();
+    init_command_taxonomy();
+    init_parsing();
+    init_native_confirmation();
+    init_confirmation();
+  }
+});
+
+// dist/extensions/agent-browser/lib/launch-scoped-flags.js
+function hasLaunchScopedFlagToken(args, flag) {
+  if (flag === "--restore" && args.some((token) => token.startsWith("--restore="))) {
     return true;
-  });
+  }
+  if (!args.includes(flag)) {
+    return false;
+  }
+  if (flag === "--auto-connect") {
+    return isBooleanFlagEnabled(args, flag);
+  }
+  if (flag !== "--state") {
+    return true;
+  }
+  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;
 var init_launch_scoped_flags = __esm({
@@ -5190,14 +5304,17 @@ function getTempArtifactByteLength(content) {
 async function listArtifactFiles(directory, excludedNames = /* @__PURE__ */ new Set()) {
   const entries = await readdir3(directory, { withFileTypes: true }).catch(() => []);
   const files = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || excludedNames.has(entry.name)) {
-      continue;
-    }
-    const path = join4(directory, entry.name);
-    const stats = await stat5(path).catch(() => void 0);
-    if (stats?.isFile() === true) {
-      files.push({ mtimeMs: stats.mtimeMs, path, size: stats.size });
+  const candidates = entries.filter((entry) => entry.isFile() && !excludedNames.has(entry.name));
+  for (let index = 0; index < candidates.length; index += 4) {
+    const batch = await Promise.all(candidates.slice(index, index + 4).map(async (entry) => {
+      const path = join4(directory, entry.name);
+      const stats = await stat5(path).catch(() => void 0);
+      return stats?.isFile() === true ? { mtimeMs: stats.mtimeMs, path, size: stats.size } : void 0;
+    }));
+    for (const file of batch) {
+      if (file !== void 0) {
+        files.push(file);
+      }
     }
   }
   return files;
@@ -5870,7 +5987,7 @@ var init_managed_session_posix_storage = __esm({
 });
 
 // dist/extensions/agent-browser/lib/managed-session-project-identity.js
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
 import { linkSync, lstatSync as lstatSync2, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname as dirname5, join as join7, resolve as resolve3 } from "node:path";
 function isManagedSessionRestoreKey(value) {
@@ -5976,7 +6093,7 @@ function matchingCacheIdentity(cached, checkout, filesystem) {
   return cached.gitDirectory === checkout.gitDirectory && cached.worktreeDirectory === checkout.worktreeDirectory && cached.gitFilesystemIdentity === filesystem.git && cached.worktreeFilesystemIdentity === filesystem.worktree && cached.marker === filesystem.marker ? cached.identity : void 0;
 }
 function publishGenerationMarker(markerPath, platform) {
-  const content = JSON.stringify({ id: randomUUID2(), version: 1 });
+  const content = JSON.stringify({ id: randomUUID3(), version: 1 });
   if (platform === "android") {
     try {
       writeFileSync(markerPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
@@ -5985,7 +6102,7 @@ function publishGenerationMarker(markerPath, platform) {
       return getErrorCode(error) === "EEXIST";
     }
   }
-  const candidatePath = `${markerPath}.candidate-${process.pid}-${randomUUID2()}`;
+  const candidatePath = `${markerPath}.candidate-${process.pid}-${randomUUID3()}`;
   try {
     writeFileSync(candidatePath, content, { encoding: "utf8", flag: "wx", mode: 384 });
     try {
@@ -6064,7 +6181,7 @@ function createManagedSessionRestoreKey(cwd, restoreScope = "", platform = proce
   }
   const identity = resolveProjectGenerationIdentity(canonicalCwd, platform);
   const material = identity ?? `unavailable:${canonicalCwd}`;
-  const digest = createHash("sha256").update(`restore-v3:${material}:scope:${restoreScope}`).digest("hex").slice(0, MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH);
+  const digest = createHash2("sha256").update(`restore-v3:${material}:scope:${restoreScope}`).digest("hex").slice(0, MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH);
   return `${MANAGED_SESSION_NAME_PREFIX}${digest}`;
 }
 var MANAGED_SESSION_RESTORE_KEY_PATTERN, MANAGED_SESSION_NAME_PREFIX, MANAGED_SESSION_FRESH_SUFFIX_PATTERN, MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH, PROJECT_GENERATION_MARKER_NAME, PROJECT_GENERATION_MARKER_MAX_BYTES, projectGenerationCache;
@@ -6207,8 +6324,8 @@ var init_managed_session_storage = __esm({
 
 // dist/extensions/agent-browser/lib/owned-managed-session-context.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-async function withOwnedManagedSessionContext(context, run) {
-  return await ownedManagedSessionStorage.run(context, run);
+async function withOwnedManagedSessionContext(context2, run) {
+  return await ownedManagedSessionStorage.run(context2, run);
 }
 function resolveOwnedManagedSessionContext(options) {
   const namespace = canonicalizeAgentBrowserNamespace(options.namespace);
@@ -6380,7 +6497,7 @@ var init_managed_session_restore_policy = __esm({
 });
 
 // dist/extensions/agent-browser/lib/managed-session-snapshot-records.js
-import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
 import { chmodSync, lstatSync as lstatSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync3, realpathSync as realpathSync3, renameSync, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join9 } from "node:path";
 function pathExistsOrIsUnreadable(path) {
@@ -6433,7 +6550,7 @@ function getCheckoutLineageHash(cwd, platform) {
   if (root === void 0 || root.length === 0) {
     return void 0;
   }
-  return createHash2("sha256").update(`managed-snapshot-lineage-v1:${platform}:${platform === "win32" ? root.toLowerCase() : root}`).digest("hex");
+  return createHash3("sha256").update(`managed-snapshot-lineage-v1:${platform}:${platform === "win32" ? root.toLowerCase() : root}`).digest("hex");
 }
 function privateOwnedDirectory(entry, platform) {
   if (platform === "win32") {
@@ -6492,7 +6609,7 @@ function removeManifestLineages(directory, platform) {
   }
 }
 function getRecordPath(directory, snapshotPath) {
-  return join9(directory, `${createHash2("sha256").update(snapshotPath).digest("hex")}.json`);
+  return join9(directory, `${createHash3("sha256").update(snapshotPath).digest("hex")}.json`);
 }
 function discardRecord(path) {
   try {
@@ -6529,7 +6646,7 @@ function verifyRecord(path, snapshotPath, platform) {
   }
 }
 function publishRecord(path, snapshotPath, content, platform) {
-  const temporaryPath = join9(dirname6(path), `.tmp-${process.pid}-${randomUUID3()}`);
+  const temporaryPath = join9(dirname6(path), `.tmp-${process.pid}-${randomUUID4()}`);
   try {
     writeFileSync2(temporaryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
     renameSync(temporaryPath, path);
@@ -6957,8 +7074,8 @@ function getOwnedManagedSessionNamespaceEnv(options) {
   const { namespace, owned, ownedContext } = resolveManagedSessionRestorePolicy(options);
   return owned ? { AGENT_BROWSER_NAMESPACE: ownedContext?.namespace ?? namespace ?? "" } : {};
 }
-function compatibilityForReuse(context, env, args, explicit) {
-  return explicit === void 0 && context.headedManagedAutosaveInterval !== void 0 && !agentBrowserExplicitConfigIsPresent(env, args) ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: context.headedManagedAutosaveInterval } : {};
+function compatibilityForReuse(context2, env, args, explicit) {
+  return explicit === void 0 && context2.headedManagedAutosaveInterval !== void 0 && !agentBrowserExplicitConfigIsPresent(env, args) ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: context2.headedManagedAutosaveInterval } : {};
 }
 function explicitAutosaveInterval(options) {
   const parent = options.parentEnv ?? getAgentBrowserProcessEnvironment();
@@ -6998,14 +7115,14 @@ function getManagedSessionRestoreProtectedEnv(options, restoreEnv) {
     ...options.env
   });
 }
-function validRestoreIdentity(context, cwd) {
-  if (context.restoreKey === void 0 || context.restoreKey.length === 0 || context.restoreScope === void 0 || context.restoreScope.length === 0) {
+function validRestoreIdentity(context2, cwd) {
+  if (context2.restoreKey === void 0 || context2.restoreKey.length === 0 || context2.restoreScope === void 0 || context2.restoreScope.length === 0) {
     return false;
   }
-  return createManagedSessionRestoreKey(cwd, context.restoreScope) === context.restoreKey && hasManagedSessionRestoreProjectIdentity(cwd);
+  return createManagedSessionRestoreKey(cwd, context2.restoreScope) === context2.restoreKey && hasManagedSessionRestoreProjectIdentity(cwd);
 }
-function validLaunchEnvironment(options, context, env) {
-  if (context.reuseOnly === true) {
+function validLaunchEnvironment(options, context2, env) {
+  if (context2.reuseOnly === true) {
     return true;
   }
   if (isDisabledEnvFlag(env[MANAGED_SESSION_RESTORE_ENV])) {
@@ -7017,7 +7134,7 @@ function validLaunchEnvironment(options, context, env) {
   if (MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS.some((name) => isUpstreamEnvFlagEnabled(env[name]))) {
     return false;
   }
-  return options.env?.[AGENT_BROWSER_RESTORE_ENV] === void 0 || options.env[AGENT_BROWSER_RESTORE_ENV] === context.restoreKey;
+  return options.env?.[AGENT_BROWSER_RESTORE_ENV] === void 0 || options.env[AGENT_BROWSER_RESTORE_ENV] === context2.restoreKey;
 }
 function validateManagedSessionRestoreContextForSpawn(options) {
   const { namespace, ownedContext, parentEnv } = resolveManagedSessionRestorePolicy(options);
@@ -7030,20 +7147,20 @@ function validateManagedSessionRestoreContextForSpawn(options) {
   const env = { ...parentEnv, ...options.env };
   return validLaunchEnvironment(options, ownedContext, env) && ensureManagedSessionRestoreStorageIsSecure({ ...env, ...ownedContext.protectedStorageEnv }, process.platform, namespace);
 }
-function reuseRestoreEnv(options, context) {
-  return context.restoreKey !== void 0 && context.restoreKey.length > 0 && context.restoreSuppressed !== true && validateManagedSessionRestoreContextForSpawn(options) ? { [AGENT_BROWSER_RESTORE_ENV]: context.restoreKey } : {};
+function reuseRestoreEnv(options, context2) {
+  return context2.restoreKey !== void 0 && context2.restoreKey.length > 0 && context2.restoreSuppressed !== true && validateManagedSessionRestoreContextForSpawn(options) ? { [AGENT_BROWSER_RESTORE_ENV]: context2.restoreKey } : {};
 }
-function disabledByPolicy(options, context, namespace) {
-  return managedSessionRestoreOptedOut(options) || context?.restoreSuppressed === true || isManagedSessionRestoreIncompatible(options, namespace);
+function disabledByPolicy(options, context2, namespace) {
+  return managedSessionRestoreOptedOut(options) || context2?.restoreSuppressed === true || isManagedSessionRestoreIncompatible(options, namespace);
 }
-function configuredRestoreEnv(options, context, policy) {
-  if (context.restoreDecision !== "enabled" || !policy.restoreState || policy.restoreState.isDisabled(policy.sessionName, policy.namespace)) {
+function configuredRestoreEnv(options, context2, policy) {
+  if (context2.restoreDecision !== "enabled" || !policy.restoreState || policy.restoreState.isDisabled(policy.sessionName, policy.namespace)) {
     return {};
   }
-  if (policy.sessionName === void 0 || policy.sessionName.length === 0 || context.restoreKey === void 0 || context.restoreKey.length === 0 || !validateManagedSessionRestoreContextForSpawn(options)) {
+  if (policy.sessionName === void 0 || policy.sessionName.length === 0 || context2.restoreKey === void 0 || context2.restoreKey.length === 0 || !validateManagedSessionRestoreContextForSpawn(options)) {
     return {};
   }
-  return { [AGENT_BROWSER_RESTORE_ENV]: context.restoreKey };
+  return { [AGENT_BROWSER_RESTORE_ENV]: context2.restoreKey };
 }
 function automaticRestoreEnv(options, policy) {
   if (disabledByPolicy({ ...options, parentEnv: policy.parentEnv }, policy.ownedContext, policy.namespace)) {
@@ -7061,37 +7178,37 @@ function getManagedSessionRestoreEnv(options) {
   if (!policy.owned || !policy.restoreState || closesBrowserSession(options.args)) {
     return {};
   }
-  const context = policy.ownedContext;
-  if (context?.reuseOnly === true) {
-    return reuseRestoreEnv(options, context);
+  const context2 = policy.ownedContext;
+  if (context2?.reuseOnly === true) {
+    return reuseRestoreEnv(options, context2);
   }
-  if (context?.restoreDecision !== void 0) {
-    return configuredRestoreEnv(options, context, policy);
+  if (context2?.restoreDecision !== void 0) {
+    return configuredRestoreEnv(options, context2, policy);
   }
   return automaticRestoreEnv(options, policy);
 }
-function recordEnabledDaemonKey(options, context) {
+function recordEnabledDaemonKey(options, context2) {
   const { namespace, restoreState, sessionName } = resolveManagedSessionRestorePolicy(options);
   if (options.ownedManagedSession !== true || !restoreState) {
     return;
   }
   const disabled = restoreState.isDisabled(sessionName, namespace);
-  if (!disabled && context.restoreKey !== void 0 && context.restoreKey.length > 0) {
-    restoreState.recordDaemonRestoreKey(sessionName, namespace, context.restoreKey);
+  if (!disabled && context2.restoreKey !== void 0 && context2.restoreKey.length > 0) {
+    restoreState.recordDaemonRestoreKey(sessionName, namespace, context2.restoreKey);
   } else if (disabled && !restoreState.hasDaemonRestoreKey(sessionName, namespace)) {
     restoreState.recordDaemonRestoreKey(sessionName, namespace, null);
   }
 }
-function commitPlannedDecision(options, context, policy) {
-  if (context.restoreDecision === "enabled") {
-    recordEnabledDaemonKey(options, context);
+function commitPlannedDecision(options, context2, policy) {
+  if (context2.restoreDecision === "enabled") {
+    recordEnabledDaemonKey(options, context2);
     return;
   }
   if (!policy.restoreState) {
     return;
   }
   if (options.ownedManagedSession === true) {
-    policy.restoreState.recordDaemonRestoreKey(policy.sessionName, policy.namespace, context.expectedDaemonRestoreKey ?? null);
+    policy.restoreState.recordDaemonRestoreKey(policy.sessionName, policy.namespace, context2.expectedDaemonRestoreKey ?? null);
   }
   policy.restoreState.disable(policy.sessionName, policy.namespace);
 }
@@ -7136,7 +7253,7 @@ var init_managed_session_restore = __esm({
 });
 
 // dist/extensions/agent-browser/lib/runtime-session-identity.js
-import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
 import { basename as basename3 } from "node:path";
 function namespaceFields(namespace) {
   return namespace === void 0 ? {} : { namespace };
@@ -7176,23 +7293,23 @@ function getRestorableManagedSessionName(value, fallbackSessionName) {
   return typeof value === "string" && isRestorableManagedSessionName(value, fallbackSessionName) ? value : void 0;
 }
 function createEphemeralSessionSeed() {
-  return randomUUID4();
+  return randomUUID5();
 }
 function createImplicitSessionName(sessionId, cwd, ephemeralSeed, platform = process.platform) {
   const normalizedSessionId = sessionId?.replaceAll("-", "").toLowerCase();
   const identity = normalizedSessionId !== void 0 && normalizedSessionId.length > 0 ? `session:${normalizedSessionId}:cwd:${cwd}` : `ephemeral:${cwd}:${ephemeralSeed}`;
   if (platform === "android") {
-    return `${MANAGED_SESSION_NAME_PREFIX2}${createHash3("sha256").update(identity).digest("hex").slice(0, 20)}`;
+    return `${MANAGED_SESSION_NAME_PREFIX2}${createHash4("sha256").update(identity).digest("hex").slice(0, 20)}`;
   }
   const projectSlug = basename3(cwd).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
   const slug = projectSlug.length > 0 ? projectSlug : "project";
-  const cwdHash = createHash3("sha256").update(`cwd:${cwd}`).digest("hex").slice(0, 8);
+  const cwdHash = createHash4("sha256").update(`cwd:${cwd}`).digest("hex").slice(0, 8);
   const sessionIdentity = normalizedSessionId !== void 0 && normalizedSessionId.length > 0 ? `session:${normalizedSessionId}` : identity;
-  const digest = createHash3("sha256").update(sessionIdentity).digest("hex").slice(0, 12);
+  const digest = createHash4("sha256").update(sessionIdentity).digest("hex").slice(0, 12);
   return `${MANAGED_SESSION_NAME_PREFIX2}${slug}-${digest}-${cwdHash}`;
 }
 function createFreshSessionName(baseSessionName, ephemeralSeed, ordinal) {
-  const suffix = createHash3("sha256").update(`fresh:${baseSessionName}:${ephemeralSeed}:${ordinal}`).digest("hex").slice(0, 10);
+  const suffix = createHash4("sha256").update(`fresh:${baseSessionName}:${ephemeralSeed}:${ordinal}`).digest("hex").slice(0, 10);
   return `${baseSessionName}-fresh-${suffix}`;
 }
 var init_runtime_session_identity = __esm({
@@ -7204,126 +7321,6 @@ var init_runtime_session_identity = __esm({
   }
 });
 
-// dist/extensions/agent-browser/lib/batch-lifecycle.js
-function rowCommand(value, fallback) {
-  return Array.isArray(value) && value.every((token) => typeof token === "string") ? value : fallback;
-}
-function rowResult(row) {
-  if (isRecord(row.result)) {
-    return row.result;
-  }
-  return isRecord(row.data) ? row.data : void 0;
-}
-function rowBrowserLaunched(row, result) {
-  const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : result?.lifecycle;
-  if (!isRecord(lifecycle) || !isRecord(lifecycle.effectiveLaunch)) {
-    return void 0;
-  }
-  const launched = lifecycle.effectiveLaunch.browserLaunched;
-  return typeof launched === "boolean" ? launched : void 0;
-}
-function lifecycleStep(value, fallback) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const result = rowResult(value);
-  const command = rowCommand(value.command, fallback);
-  return {
-    result,
-    succeeded: value.success === true,
-    browserLaunched: rowBrowserLaunched(value, result),
-    tokens: command === void 0 ? void 0 : extractUpstreamCommandTokens(command)
-  };
-}
-function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
-  if (!Array.isArray(data)) {
-    return false;
-  }
-  return data.some((row, index) => {
-    if (!isRecord(row) || row.success !== true) {
-      return false;
-    }
-    const command = rowCommand(row.command, fallbackCommands.at(index));
-    return command !== void 0 && !detectConfirmationRequired(row.result) && isCloseAllCommand(extractUpstreamCommandTokens(command));
-  });
-}
-function successfulClose(step) {
-  return step.succeeded && step.tokens !== void 0 && !detectConfirmationRequired(step.result) && (isCloseCommand(step.tokens[0]) || isSuccessfulNativeConfirmedClose(step.tokens, step.result));
-}
-function closedState(step) {
-  const result = step.result;
-  const closeData = step.tokens?.[0] === "confirm" && isRecord(result) && isRecord(result.result) ? result.result.data : result;
-  return {
-    endsClosed: true,
-    browserActiveAfterClose: false,
-    recordingClosedAfterBatch: true,
-    statePath: isRecord(closeData) && typeof closeData.statePath === "string" ? closeData.statePath : void 0
-  };
-}
-function recordingState(state, step) {
-  const relaunched = step.browserLaunched !== false;
-  const browserActiveAfterClose = state.browserActiveAfterClose || relaunched;
-  let recordingClosedAfterBatch = state.recordingClosedAfterBatch;
-  const subcommand = step.tokens?.[1];
-  if (step.succeeded && subcommand === "stop") {
-    recordingClosedAfterBatch = true;
-  } else if (step.succeeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart")) {
-    recordingClosedAfterBatch = false;
-  }
-  return {
-    ...state,
-    endsClosed: state.endsClosed && !relaunched,
-    browserActiveAfterClose,
-    recordingClosedAfterBatch
-  };
-}
-function advanceClosedState(state, step) {
-  if (step.tokens?.[0] === "record") {
-    return recordingState(state, step);
-  }
-  if (step.browserLaunched === false) {
-    return state;
-  }
-  return {
-    ...state,
-    endsClosed: false,
-    browserActiveAfterClose: true,
-    recordingClosedAfterBatch: step.tokens === void 0 ? false : state.recordingClosedAfterBatch
-  };
-}
-function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
-  if (!Array.isArray(rows)) {
-    return void 0;
-  }
-  let state;
-  for (const [index, row] of rows.entries()) {
-    const step = lifecycleStep(row, fallbackCommands.at(index));
-    if (step === void 0) {
-      continue;
-    }
-    if (successfulClose(step)) {
-      state = closedState(step);
-    } else if (state !== void 0) {
-      state = advanceClosedState(state, step);
-    }
-  }
-  return state === void 0 ? void 0 : {
-    endsClosed: state.endsClosed,
-    recordingClosedAfterBatch: state.recordingClosedAfterBatch,
-    statePath: state.statePath
-  };
-}
-var init_batch_lifecycle = __esm({
-  "dist/extensions/agent-browser/lib/batch-lifecycle.js"() {
-    "use strict";
-    init_argv_descriptor();
-    init_command_taxonomy();
-    init_parsing();
-    init_native_confirmation();
-    init_confirmation();
-  }
-});
-
 // dist/extensions/agent-browser/lib/runtime-replay-events.js
 function text(value) {
   return typeof value === "string" ? value : void 0;
@@ -9112,15 +9109,15 @@ function sourceSummary(status, candidateCount, electronWorkspace) {
       return "Source lookup found no candidate locations.";
   }
 }
-async function analyzeSourceLookupResults(data, compiled, cwd, context) {
+async function analyzeSourceLookupResults(data, compiled, cwd, context2) {
   const { distinctSourceCandidates: distinctSourceCandidates2, observeSourceCandidates: observeSourceCandidates2 } = await Promise.resolve().then(() => (init_lookup_source_evidence(), lookup_source_evidence_exports));
   const { scanWorkspaceComponent: scanWorkspaceComponent2 } = await Promise.resolve().then(() => (init_lookup_workspace(), lookup_workspace_exports));
   const observed = observeSourceCandidates2(data);
   const workspace = await scanWorkspaceComponent2(compiled.query, cwd);
   const candidates = distinctSourceCandidates2([...observed.candidates, ...workspace.candidates]);
   const status = sourceStatus(candidates.length, observed.unsupported);
-  const electronContext = status === "no-candidates" ? context?.electronContext : void 0;
-  const workspaceRoot = context?.workspaceRoot ?? cwd;
+  const electronContext = status === "no-candidates" ? context2?.electronContext : void 0;
+  const workspaceRoot = context2?.workspaceRoot ?? cwd;
   const limitations = [
     "Experimental lookup only reports candidates with evidence; it cannot guarantee a DOM node maps to one source file.",
     "React source hints require the page to be opened with --enable react-devtools and source information from the app build.",
@@ -9538,8 +9535,8 @@ function selectObservationFields(details) {
   return observation2;
 }
 function projectBatchMetadata(step) {
-  const { data: _data, ...metadata } = projectAgentBrowserObservation(step, step.success !== false);
-  return Object.assign({ index: step.index }, metadata);
+  const { data: _data, stdout: _stdout, ...metadata } = step;
+  return Object.assign({ index: step.index }, projectAgentBrowserObservation(metadata, step.success !== false));
 }
 function projectAgentBrowserObservation(details, succeeded) {
   const observation2 = selectObservationFields(details);
@@ -10459,8 +10456,8 @@ function hasScopedNamesSeen(text3, command) {
 function isUpstreamLocatorMiss(text3, command) {
   return /\bNo element found:\s*(?:getBy[A-Za-z]+|role=|text=|label=|placeholder=|alt=|title=|testid=)/i.test(text3) || /\bElement not found:/i.test(text3) && /\bVerify the selector, role, or name\b/i.test(text3) || /\bnone match name\b/i.test(text3) || hasScopedNamesSeen(text3, command) || /\belement has role\b[\s\S]*\bnone match\b/i.test(text3);
 }
-function classifyNativeFailure(context) {
-  const { options, text: text3, command } = context;
+function classifyNativeFailure(context2) {
+  const { options, text: text3, command } = context2;
   if (options.confirmationRequired === true) {
     return "confirmation-required";
   }
@@ -10475,8 +10472,8 @@ function classifyNativeFailure(context) {
   }
   return void 0;
 }
-function classifyProcessFailure(context) {
-  const { options, text: text3 } = context;
+function classifyProcessFailure(context2) {
+  const { options, text: text3 } = context2;
   if (options.timedOut === true || /\b(?:timed\s+out|timeout exceeded|watchdog|IPC read timeout)\b|must stay under its 30s IPC read timeout|Operation timed out/i.test(text3)) {
     return "timeout";
   }
@@ -10491,8 +10488,8 @@ function classifyProcessFailure(context) {
   }
   return void 0;
 }
-function classifyLifecycleFailure(context) {
-  const { options, text: text3 } = context;
+function classifyLifecycleFailure(context2) {
+  const { options, text: text3 } = context2;
   if (/policy[- ]blocked|blocked by caller policy|caller deny policy|caller allow policy/i.test(text3)) {
     return "policy-blocked";
   }
@@ -10513,8 +10510,8 @@ function reportsSelectorMatchFailure(text3) {
 function reportsUnsupportedSelector(text3) {
   return /\b(?:unsupported|unknown|invalid)\s+(?:selector|locator)\b/i.test(text3) || /\bfailed to parse selector\b/i.test(text3) || /\bselector\b.*\b(?:parse|syntax|unsupported|invalid)\b/i.test(text3) || /(?:\btext=|:has-text\(|\bgetByRole\b|\bgetByText\b)/i.test(text3) && reportsSelectorMatchFailure(text3);
 }
-function classifySelectorFailure(context) {
-  const { options, text: text3, command } = context;
+function classifySelectorFailure(context2) {
+  const { options, text: text3, command } = context2;
   if (/\bUnknown ref\b|\bstale ref\b|@ref may be stale|\bref\b.*\b(?:not found|missing|expired)\b/i.test(text3)) {
     return "stale-ref";
   }
@@ -10530,8 +10527,8 @@ function classifySelectorFailure(context) {
   }
   return reportsSelectorMatchFailure(text3) ? "selector-not-found" : void 0;
 }
-function classifyDownloadFailure(context) {
-  const { text: text3, command } = context;
+function classifyDownloadFailure(context2) {
+  const { text: text3, command } = context2;
   return (command === "download" || text3.includes("wait --download") || /\bdownload\b/i.test(text3)) && /missing|not verified|not found|failed|timeout|timed out/i.test(text3) ? "download-not-verified" : "upstream-error";
 }
 function classifyAgentBrowserFailureCategory(options) {
@@ -10542,8 +10539,8 @@ function classifyAgentBrowserFailureCategory(options) {
     options.spawnError,
     options.stderr
   ].filter(Boolean).join("\n");
-  const context = { options, text: text3, command: options.command ?? "" };
-  return classifyNativeFailure(context) ?? classifyProcessFailure(context) ?? classifyLifecycleFailure(context) ?? classifySelectorFailure(context) ?? classifyDownloadFailure(context);
+  const context2 = { options, text: text3, command: options.command ?? "" };
+  return classifyNativeFailure(context2) ?? classifyProcessFailure(context2) ?? classifyLifecycleFailure(context2) ?? classifySelectorFailure(context2) ?? classifyDownloadFailure(context2);
 }
 function buildAgentBrowserResultCategoryDetails(options) {
   if (options.succeeded) {
@@ -12054,9 +12051,9 @@ var init_process_child = __esm({
       exitCode = null;
       timer;
       completed = false;
-      constructor(child, complete, context) {
+      constructor(child, complete, context2) {
         this.complete = complete;
-        this.context = context;
+        this.context = context2;
         child.once("exit", (code) => {
           this.exited = true;
           this.exitCode = code;
@@ -12076,13 +12073,13 @@ var init_process_child = __esm({
         }
         this.completed = true;
         this.clear();
-        const context = this.context();
+        const context2 = this.context();
         this.complete(resolveSpawnedChildExitCode({
           closeCode,
           exitCode: this.exitCode,
           useExitFallback: this.exited,
-          timedOut: context.timedOut,
-          spawnError: context.spawnError
+          timedOut: context2.timedOut,
+          spawnError: context2.spawnError
         }));
       }
       clear() {
@@ -12281,6 +12278,8 @@ function canOperateWithoutVerifiedPage(command, subcommand) {
       return subcommand !== void 0 && subcommand !== "new";
     case "get":
       return subcommand === "url";
+    case "session":
+      return subcommand === void 0;
     case "webmcp":
       return ["result", "cancel"].includes(subcommand ?? "");
     case "record":
@@ -15277,7 +15276,7 @@ var init_browser_execution_claim_codec = __esm({
 });
 
 // dist/extensions/agent-browser/lib/browser-execution-identity.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { lstat as lstat3, mkdir as mkdir3, realpath } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join18 } from "node:path";
@@ -15288,7 +15287,7 @@ function getCoordinationDirectory(platform = process.platform) {
     return platform === "android" ? join18(tmpdir2(), `pi-agent-browser-policy${suffix2}`) : `/tmp/pi-agent-browser-policy${suffix2}`;
   }
   const user = process.env.USERNAME ?? process.env.USER ?? "unknown";
-  const suffix = createHash4("sha256").update(user).digest("hex").slice(0, 12);
+  const suffix = createHash5("sha256").update(user).digest("hex").slice(0, 12);
   return join18(tmpdir2(), `pi-agent-browser-policy-${suffix}`);
 }
 function directoryOwnerTrusted(entry, platform) {
@@ -15336,7 +15335,7 @@ async function resolveBrowserExecutionIdentity(options) {
   };
 }
 function getBrowserExecutionLockPath(identity) {
-  return join18(getCoordinationDirectory(), `.pi-agent-browser-policy-${createHash4("sha256").update(identity.socketContext).digest("hex")}.lock-v4`);
+  return join18(getCoordinationDirectory(), `.pi-agent-browser-policy-${createHash5("sha256").update(identity.socketContext).digest("hex")}.lock-v4`);
 }
 var init_browser_execution_identity = __esm({
   "dist/extensions/agent-browser/lib/browser-execution-identity.js"() {
@@ -15349,7 +15348,7 @@ var init_browser_execution_identity = __esm({
 });
 
 // dist/extensions/agent-browser/lib/browser-execution-claim-storage.js
-import { randomInt as randomInt2, randomUUID as randomUUID5 } from "node:crypto";
+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";
 function secureEntry(entry, directory) {
@@ -15482,7 +15481,7 @@ async function moveOwnedClaim(path, movedPath, token, deadline) {
   }
 }
 async function removeClaimOwnedBy(path, token, deadline = 0) {
-  const movedPath = join19(dirname11(path), `.pi-agent-browser-policy-remove-${token}-${randomUUID5()}`);
+  const movedPath = join19(dirname11(path), `.pi-agent-browser-policy-remove-${token}-${randomUUID6()}`);
   const movement = await moveOwnedClaim(path, movedPath, token, deadline);
   if (movement === "absent") {
     return true;
@@ -15559,7 +15558,7 @@ var init_browser_execution_claim_storage = __esm({
 });
 
 // dist/extensions/agent-browser/lib/browser-execution-claims.js
-import { randomUUID as randomUUID6 } from "node:crypto";
+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";
 function claimPrecedes(left, right) {
@@ -15622,7 +15621,7 @@ async function prepareClaim(identity, budget) {
     return void 0;
   }
   const basePath = getBrowserExecutionLockPath(identity);
-  const token = randomUUID6();
+  const token = randomUUID7();
   const startIdentity = await readProcessStartIdentity(process.pid, process.platform, budget);
   if (startIdentity === void 0 || startIdentity.length === 0) {
     return void 0;
@@ -16157,12 +16156,12 @@ var init_managed_session_close = __esm({
 function hasElectronAttachmentIdentity(record) {
   return record.webSocketDebuggerUrl !== void 0 && record.webSocketDebuggerUrl !== "" && record.sessionName !== void 0 && record.sessionName !== "";
 }
-function restoredAttachmentTarget(context, record) {
-  const cwd = context.cwd;
+function restoredAttachmentTarget(context2, record) {
+  const cwd = context2.cwd;
   if (cwd === void 0 || cwd === "" || !record || !hasElectronAttachmentIdentity(record)) {
     return void 0;
   }
-  if (record.cleanupState === "cleaned" || getAgentBrowserSessionIdentityKey(record.sessionName ?? "", record.namespace) !== getAgentBrowserSessionIdentityKey(context.sessionName, context.namespace)) {
+  if (record.cleanupState === "cleaned" || getAgentBrowserSessionIdentityKey(record.sessionName ?? "", record.namespace) !== getAgentBrowserSessionIdentityKey(context2.sessionName, context2.namespace)) {
     return void 0;
   }
   return { cwd, record };
@@ -16174,8 +16173,8 @@ function attachmentConnectionMatches(connection, record, status) {
   return isRecord(connection) && typeof connection.cdpUrl === "string" && (connection.cdpUrl === record.webSocketDebuggerUrl || status.targets.some((target) => target.webSocketDebuggerUrl === connection.cdpUrl));
 }
 async function verifyRestoredElectronAttachment(options) {
-  const { context, signal } = options;
-  const attachment = restoredAttachmentTarget(context, options.electronLaunchRecord);
+  const { context: context2, signal } = options;
+  const attachment = restoredAttachmentTarget(context2, options.electronLaunchRecord);
   if (!attachment) {
     return false;
   }
@@ -16186,10 +16185,10 @@ async function verifyRestoredElectronAttachment(options) {
   const connection = await withAttachedBrowserSessionContext(true, () => withOwnedManagedSessionContext(void 0, () => runSessionCommandData({
     args: ["get", "cdp-url"],
     cwd: attachment.cwd,
-    env: getHeadedManagedAutosaveEnv(context.headedManagedAutosaveInterval),
-    namespace: context.namespace,
+    env: getHeadedManagedAutosaveEnv(context2.headedManagedAutosaveInterval),
+    namespace: context2.namespace,
     pinNamespace: true,
-    sessionName: context.sessionName,
+    sessionName: context2.sessionName,
     signal,
     timeoutMs: options.electronVerificationTimeoutMs
   })));
@@ -16199,17 +16198,17 @@ async function verifyRestoredElectronAttachment(options) {
     !(signal?.aborted ?? false) && attachmentConnectionMatches(connection, attachment.record, status)
   );
 }
-function reconcileDaemonReceipt(context, daemon, receipt) {
+function reconcileDaemonReceipt(context2, daemon, receipt) {
   if (daemon.status === "inactive") {
-    context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
+    context2.restoreState.forgetDaemonRestoreKey(context2.sessionName, context2.namespace);
   }
-  if (daemon.status !== "active" || receipt === void 0 || context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace)) {
+  if (daemon.status !== "active" || receipt === void 0 || context2.restoreState.hasDaemonRestoreKey(context2.sessionName, context2.namespace)) {
     return;
   }
   if (daemon.generation === receipt.generation && daemon.restoreKey === receipt.restoreKey) {
-    context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey, daemon.generation);
+    context2.restoreState.recordDaemonRestoreKey(context2.sessionName, context2.namespace, daemon.restoreKey, daemon.generation);
   } else {
-    context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
+    context2.restoreState.forgetDaemonRestoreKey(context2.sessionName, context2.namespace);
   }
 }
 function daemonPolicyMismatch(daemon, restoreDisabledPolicyNeedsProvenance, hasKnownDaemonRestoreKey) {
@@ -16223,40 +16222,50 @@ function daemonPolicyMismatch(daemon, restoreDisabledPolicyNeedsProvenance, hasK
   };
 }
 async function validateReusableDaemonPolicy(options, daemon) {
-  const { context } = options;
-  const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
-  let hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
-  const knownDaemonRestoreKey = context.restoreState.getDaemonRestoreKey(context.sessionName, context.namespace);
-  const requestedDaemonRestoreKey = context.restoreDecision === "enabled" && stickyDisabled ? knownDaemonRestoreKey ?? null : context.expectedDaemonRestoreKey;
+  const { context: context2 } = options;
+  const stickyDisabled = context2.restoreState.isDisabled(context2.sessionName, context2.namespace);
+  let hasKnownDaemonRestoreKey = context2.restoreState.hasDaemonRestoreKey(context2.sessionName, context2.namespace);
+  const knownDaemonRestoreKey = context2.restoreState.getDaemonRestoreKey(context2.sessionName, context2.namespace);
+  const requestedDaemonRestoreKey = context2.restoreDecision === "enabled" && stickyDisabled ? knownDaemonRestoreKey ?? null : context2.expectedDaemonRestoreKey;
   if (daemon.status === "unknown") {
     return {
       error: `The wrapper could not verify this managed session's live daemon restore policy. Retry, close that session, or use sessionMode: "fresh".`
     };
   }
-  const restoreDisabledPolicyNeedsProvenance = stickyDisabled || context.restoreDecision !== "enabled";
-  if (daemon.status === "active" && restoreDisabledPolicyNeedsProvenance && !hasKnownDaemonRestoreKey && daemon.restoreKey === requestedDaemonRestoreKey) {
+  const restoreDisabledPolicyNeedsProvenance = stickyDisabled || context2.restoreDecision !== "enabled";
+  const verifyAttachment = daemon.status === "active" && restoreDisabledPolicyNeedsProvenance && !hasKnownDaemonRestoreKey && daemon.restoreKey === requestedDaemonRestoreKey;
+  if (verifyAttachment) {
     hasKnownDaemonRestoreKey = await verifyRestoredElectronAttachment(options);
   }
-  return finishReusableDaemonPolicy(context, daemon, {
+  return finishReusableDaemonPolicy(context2, daemon, {
     restoreDisabledPolicyNeedsProvenance,
-    requestedDaemonRestoreKey
+    requestedDaemonRestoreKey,
+    includeGeneration: options.includeGeneration,
+    verifyAttachment
   }, hasKnownDaemonRestoreKey);
 }
-function finishReusableDaemonPolicy(context, daemon, policy, hasKnownDaemonRestoreKey) {
+function finishReusableDaemonPolicy(context2, daemon, policy, hasKnownDaemonRestoreKey) {
   const activePolicyMatches = daemon.status === "active" && (!policy.restoreDisabledPolicyNeedsProvenance || hasKnownDaemonRestoreKey) && daemon.restoreKey === policy.requestedDaemonRestoreKey;
   if (activePolicyMatches) {
-    context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
+    context2.restoreState.recordDaemonRestoreKey(context2.sessionName, context2.namespace, daemon.restoreKey);
   }
-  return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches ? daemonPolicyMismatch(daemon, policy.restoreDisabledPolicyNeedsProvenance, hasKnownDaemonRestoreKey) : { daemonStatus: daemon.status };
+  return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches ? daemonPolicyMismatch(daemon, policy.restoreDisabledPolicyNeedsProvenance, hasKnownDaemonRestoreKey) : {
+    daemonStatus: daemon.status,
+    // The native CDP provenance helper can change the browser; never reuse its preceding sample.
+    generationInspection: policy.includeGeneration === true && !policy.verifyAttachment ? daemon : void 0
+  };
+}
+function daemonGenerationRequired(context2, receipt, includeGeneration) {
+  return includeGeneration === true || receipt !== void 0 && !context2.restoreState.hasDaemonRestoreKey(context2.sessionName, context2.namespace);
 }
 async function acquireOwnedManagedSessionDaemonPolicy(options) {
-  const { context, signal } = options;
-  if (context.cwd === void 0 || context.cwd === "") {
+  const { context: context2, signal } = options;
+  if (context2.cwd === void 0 || context2.cwd === "") {
     return { error: "Managed-session policy validation requires the wrapper-owned session cwd." };
   }
   const lock = await acquireManagedSessionPolicyLock({
-    namespace: context.namespace,
-    sessionName: context.sessionName,
+    namespace: context2.namespace,
+    sessionName: context2.sessionName,
     signal
   });
   if (!lock) {
@@ -16265,19 +16274,19 @@ async function acquireOwnedManagedSessionDaemonPolicy(options) {
     };
   }
   try {
-    const receipt = context.restoreState.getDaemonReceipt(context.sessionName, context.namespace);
+    const receipt = context2.restoreState.getDaemonReceipt(context2.sessionName, context2.namespace);
     const daemon = await inspectManagedSessionDaemon({
-      cwd: context.cwd,
-      includeGeneration: receipt !== void 0 && !context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace),
-      headedManagedAutosaveInterval: context.headedManagedAutosaveInterval,
-      namespace: context.namespace,
-      sessionName: context.sessionName,
+      cwd: context2.cwd,
+      includeGeneration: daemonGenerationRequired(context2, receipt, options.includeGeneration),
+      headedManagedAutosaveInterval: context2.headedManagedAutosaveInterval,
+      namespace: context2.namespace,
+      sessionName: context2.sessionName,
       signal
     });
-    reconcileDaemonReceipt(context, daemon, receipt);
+    reconcileDaemonReceipt(context2, daemon, receipt);
     if (options.mode === "close") {
       if (daemon.status === "active") {
-        context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
+        context2.restoreState.recordDaemonRestoreKey(context2.sessionName, context2.namespace, daemon.restoreKey);
       }
       return { daemonStatus: daemon.status, lock };
     }
@@ -16518,9 +16527,10 @@ function firstNonempty(values) {
 }
 async function inspectDarwinApp(appPath) {
   const framework = join22(appPath, "Contents", "Frameworks", "Electron Framework.framework");
-  const hasFramework = await isDirectory(framework);
-  const hasPayload = await hasElectronAppPayload(join22(appPath, "Contents", "Resources"));
-  if (!hasFramework || !hasPayload) {
+  if (!await isDirectory(framework)) {
+    return void 0;
+  }
+  if (!await hasElectronAppPayload(join22(appPath, "Contents", "Resources"))) {
     return void 0;
   }
   const info = await readMacInfoPlist(appPath);
@@ -17707,14 +17717,14 @@ function buildSourceLookupElectronNextActions(sourceLookup) {
   return actions;
 }
 function collectElectronBroadGetTextScopeDiagnostics(options) {
-  const context = getSourceLookupElectronContext(options);
-  if (!context) {
+  const context2 = getSourceLookupElectronContext(options);
+  if (!context2) {
     return [];
   }
   const electronContext = {
-    launchId: context.launchId,
-    sessionName: context.sessionName,
-    url: context.url
+    launchId: context2.launchId,
+    sessionName: context2.sessionName,
+    url: context2.url
   };
   return getSuccessfulGetTextSelectors(options).filter(isBroadGetTextSelector).map((selector) => ({
     electronContext,
@@ -19247,24 +19257,34 @@ async function statTimeoutArtifactPath(absolutePath) {
   return { exists: false };
 }
 async function collectTimeoutArtifactEvidence(cwd, steps) {
-  const evidence = [];
-  for (const step of steps) {
+  const paths = steps.flatMap((step) => {
     const path = getTimeoutStepArtifactPath(step.args);
     if (path === void 0 || path === "") {
-      continue;
+      return [];
     }
     const absolutePath = isAbsolute8(path) ? path : resolve11(cwd, path);
+    return [{ absolutePath, path, stepIndex: step.index }];
+  });
+  return Promise.all(paths.map(async ({ absolutePath, path, stepIndex }) => {
     const artifact = await statTimeoutArtifactPath(absolutePath);
-    evidence.push({
+    if (artifact.exists) {
+      return {
+        absolutePath,
+        exists: true,
+        path,
+        sizeBytes: artifact.sizeBytes,
+        state: "verified",
+        stepIndex
+      };
+    }
+    return {
       absolutePath,
-      exists: artifact.exists,
+      exists: false,
       path,
-      ...artifact.exists ? { sizeBytes: artifact.sizeBytes } : {},
-      state: artifact.exists ? "verified" : "missing",
-      stepIndex: step.index
-    });
-  }
-  return evidence;
+      state: "missing",
+      stepIndex
+    };
+  }));
 }
 function getPlannedCurrentPageUrl(steps) {
   for (let index = steps.length - 1; index >= 0; index -= 1) {
@@ -20425,10 +20445,10 @@ var init_final_result = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/electron-host/policy.js
-async function acquireElectronPolicy(options, context) {
+async function acquireElectronPolicy(options, context2) {
   try {
     return await acquireOwnedManagedSessionDaemonPolicy({
-      context,
+      context: context2,
       electronLaunchRecord: options.electronLaunchRecord,
       electronVerificationTimeoutMs: options.timeoutMs,
       signal: options.signal
@@ -20454,7 +20474,7 @@ async function withOwnedElectronManagedSessionPolicy(options, run) {
     if (autosavePolicyChangeError !== void 0 && autosavePolicyChangeError.length > 0) {
       throw new ElectronManagedSessionPolicyError(autosavePolicyChangeError);
     }
-    const context = buildOwnedManagedSessionRestoreContext({
+    const context2 = buildOwnedManagedSessionRestoreContext({
       args: [
         "--namespace",
         options.namespace ?? "",
@@ -20469,13 +20489,13 @@ async function withOwnedElectronManagedSessionPolicy(options, run) {
       namespace: options.namespace,
       restoreState: options.restoreState
     });
-    if (!context) {
+    if (!context2) {
       throw new ElectronManagedSessionPolicyError("Electron helper could not establish wrapper ownership for its managed session.");
     }
-    const policy = await acquireElectronPolicy(options, context);
+    const policy = await acquireElectronPolicy(options, context2);
     try {
       requirePolicyLock(policy, options.signal);
-      return await withOwnedManagedSessionContext(context, run);
+      return await withOwnedManagedSessionContext(context2, run);
     } finally {
       await policy.lock?.release();
     }
@@ -20946,17 +20966,17 @@ function formatElectronProbeFocusedElement(element) {
   const suffix = formatFocusedElementAttributes(element);
   return `Focused: ${descriptor}${label !== void 0 && label.length > 0 ? ` "${label}"` : ""}${suffix.length > 0 ? ` (${suffix})` : ""}`;
 }
-function formatElectronProbeContextText(context) {
-  if (context.mode === "launchId") {
-    return `Probe context: wrapper launch ${context.launchId ?? "undefined"} session ${context.sessionName}.`;
+function formatElectronProbeContextText(context2) {
+  if (context2.mode === "launchId") {
+    return `Probe context: wrapper launch ${context2.launchId ?? "undefined"} session ${context2.sessionName}.`;
   }
-  if (context.note !== void 0 && context.note.length > 0) {
-    return `Probe context: current managed session ${context.sessionName}; ${context.note}`;
+  if (context2.note !== void 0 && context2.note.length > 0) {
+    return `Probe context: current managed session ${context2.sessionName}; ${context2.note}`;
   }
-  if (context.launchId !== void 0 && context.launchId.length > 0) {
-    return `Probe context: current managed session ${context.sessionName} maps to Electron launch ${context.launchId}.`;
+  if (context2.launchId !== void 0 && context2.launchId.length > 0) {
+    return `Probe context: current managed session ${context2.sessionName} maps to Electron launch ${context2.launchId}.`;
   }
-  return `Probe context: current managed session ${context.sessionName} only; pass electron.probe.launchId to compare wrapper-tracked launch status.`;
+  return `Probe context: current managed session ${context2.sessionName} only; pass electron.probe.launchId to compare wrapper-tracked launch status.`;
 }
 function formatElectronProbeLaunchStatusText(status, probe) {
   if (!status) {
@@ -21200,7 +21220,7 @@ async function inspectProbeIdentity(options, identity, input, visibleInput) {
     record: identity.record,
     statusTargets: status.targets
   }) : void 0;
-  const context = probeContext(identity, input, probe);
+  const context2 = probeContext(identity, input, probe);
   const target = publishProbePageState(options.sessionPageState, probe, identity.namespace);
   return buildElectronProbeResult({
     compiledElectron: visibleInput,
@@ -21209,7 +21229,7 @@ async function inspectProbeIdentity(options, identity, input, visibleInput) {
     mismatch,
     namespace: identity.namespace,
     probe,
-    probeContext: context,
+    probeContext: context2,
     record: identity.record,
     sessionTabTarget: target,
     status
@@ -21354,11 +21374,11 @@ function formatSnapshotSummary(data) {
   if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
     return `Snapshot ${stringifyUnknown(data.snapshot.kind)}: revision ${stringifyUnknown(data.snapshot.revision)} on ${origin}`;
   }
-  return `Snapshot: ${getSnapshotRefEntries(data).length} refs on ${origin}`;
+  return `Snapshot: ${Object.keys(getSnapshotRefRecord(data) ?? {}).length} refs on ${origin}`;
 }
 function formatRawSnapshotText(data) {
   const origin = getSnapshotOrigin(data);
-  const refs = getSnapshotRefEntries(data).length;
+  const refs = Object.keys(getSnapshotRefRecord(data) ?? {}).length;
   const snapshot = getSnapshotText(data);
   if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
     return `Origin: ${origin}
@@ -21932,7 +21952,7 @@ var init_snapshot_spill = __esm({
 
 // dist/extensions/agent-browser/lib/results/snapshot.js
 function shouldCompactSnapshot(rawText, data) {
-  return rawText.length > 6e3 || countLines(getSnapshotText(data) ?? "") > 80 || getSnapshotRefEntries(data).length > 60;
+  return rawText.length > 6e3 || countLines(getSnapshotText(data) ?? "") > 80 || Object.keys(getSnapshotRefRecord(data) ?? {}).length > 60;
 }
 async function getSnapshotSpill(data, store) {
   try {
@@ -26007,7 +26027,7 @@ var init_launch_process = __esm({
 });
 
 // dist/extensions/agent-browser/lib/electron/launch.js
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { rm as rm13 } from "node:fs/promises";
 function normalizeTimeoutMs(timeoutMs) {
   if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
@@ -26265,7 +26285,7 @@ var init_launch = __esm({
           createdAtMs: Date.now(),
           desktopId: this.target.desktopId,
           executablePath: this.target.executablePath,
-          launchId: `electron-${randomUUID10()}`,
+          launchId: `electron-${randomUUID11()}`,
           launchedByWrapper: true,
           packageSource: this.target.packageSource,
           pid,
@@ -26783,6 +26803,7 @@ function prepareSessionPlan(owners, facts, preparedArgs, request) {
   return {
     plan,
     session: {
+      hasPriorRefs: (owners.pageState.get(getSessionContextKey(plan.sessionName, plan.namespace)).refSnapshot?.refIds.length ?? 0) > 0,
       browserIndependent,
       readConfirmation,
       recordedOwnedSession: recorded,
@@ -26828,12 +26849,12 @@ function daemonReuseError(plan, session, policy) {
   }
   return void 0;
 }
-function applyColdCompatibility(plan, session, context, status) {
+function applyColdCompatibility(plan, session, context2, status) {
   if (isCloseCommand(plan.commandInfo.command) || status !== "inactive" || session.compatibilityUserAgent === void 0 || session.compatibilityUserAgent === "" || session.compatibilityUserAgentApplied) {
-    return { plan, ownedManagedSession: context };
+    return { plan, ownedManagedSession: context2 };
   }
   return {
-    ownedManagedSession: { ...context, compatibilityUserAgent: session.compatibilityUserAgent },
+    ownedManagedSession: { ...context2, compatibilityUserAgent: session.compatibilityUserAgent },
     plan: {
       ...plan,
       effectiveArgs: ["--user-agent", session.compatibilityUserAgent, ...plan.effectiveArgs]
@@ -26842,25 +26863,28 @@ function applyColdCompatibility(plan, session, context, status) {
 }
 async function prepareDaemonPolicy(process2, electronLaunchRecord, planning) {
   const { plan, session } = planning;
-  const context = session.ownedManagedSession;
-  if (session.browserIndependent || planHasValidationError(plan) || !context) {
+  const context2 = session.ownedManagedSession;
+  if (session.browserIndependent || planHasValidationError(plan) || !context2) {
     return { plan, session, policy: { inactive: false } };
   }
+  const closeCommand = isCloseCommand(plan.commandInfo.command);
   const policy = await acquireOwnedManagedSessionDaemonPolicy({
-    context,
+    context: context2,
     electronLaunchRecord,
     electronVerificationTimeoutMs: process2.timeoutMs,
-    mode: isCloseCommand(plan.commandInfo.command) ? "close" : "reuse",
+    mode: closeCommand ? "close" : "reuse",
+    includeGeneration: session.hasPriorRefs && !closeCommand,
     signal: process2.signal
   });
   const error = daemonReuseError(plan, session, policy);
-  const resolved = error !== void 0 && error !== "" ? { plan: withPlanValidationError(plan, error), ownedManagedSession: context } : applyColdCompatibility(plan, session, context, policy.daemonStatus);
+  const resolved = error !== void 0 && error !== "" ? { plan: withPlanValidationError(plan, error), ownedManagedSession: context2 } : applyColdCompatibility(plan, session, context2, policy.daemonStatus);
   return {
     plan: resolved.plan,
     session: { ...session, ownedManagedSession: resolved.ownedManagedSession },
     policy: {
       lock: policy.lock,
       inactive: policy.daemonStatus === "inactive",
+      generationInspection: policy.generationInspection,
       cleanupOnlyReason: policy.error !== void 0 && policy.error !== "" ? policy.cleanupOnlyReason : void 0
     }
   };
@@ -26878,7 +26902,7 @@ async function prepareChromeStartupArgs(facts, planning, request) {
   const { plan, session, policy } = planning;
   let inactive = policy.inactive;
   if (!session.ownedManagedSession) {
-    inactive = facts.daemonInactive ?? (plan.sessionName !== void 0 && (await inspectManagedSessionDaemon({
+    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,
@@ -26891,6 +26915,7 @@ var init_prepare_daemon = __esm({
   "dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-daemon.js"() {
     "use strict";
     init_argv_descriptor();
+    init_argv_grammar();
     init_command_policy();
     init_command_taxonomy();
     init_managed_session_daemon_policy();
@@ -26899,8 +26924,8 @@ var init_prepare_daemon = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-page-state.js
-async function inspectPreparationGeneration(process2, identity) {
-  return inspectManagedSessionDaemon({
+async function inspectPreparationGeneration(process2, identity, priorInspection) {
+  return priorInspection ?? inspectManagedSessionDaemon({
     ...process2,
     namespace: identity.namespace,
     sessionName: identity.sessionName,
@@ -26937,7 +26962,7 @@ async function reconcileGeneration(pageState, process2, request) {
     namespace: plan.namespace,
     sessionName: name,
     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) {
@@ -26970,6 +26995,7 @@ async function preparePageState(state, process2, request) {
     plan,
     session,
     update,
+    generationInspection: request.generationInspection,
     page: {
       sessionStateKey: key,
       priorSessionTabTarget: prior.tabTarget,
@@ -27518,30 +27544,30 @@ var init_prompt_guards = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-guards.js
-function prepareGuardEvidence(preserveAttachedBrowserSession, context) {
-  const plan = context.semantic.selection.executionPlan;
+function prepareGuardEvidence(preserveAttachedBrowserSession, context2) {
+  const plan = context2.semantic.selection.executionPlan;
   return {
-    redactedEffectiveArgs: redactInvocationArgs(prepareAgentBrowserSpawnArgs(plan.effectiveArgs, void 0, preserveAttachedBrowserSession, context.chromeStartupArgs)),
+    redactedEffectiveArgs: redactInvocationArgs(prepareAgentBrowserSpawnArgs(plan.effectiveArgs, void 0, preserveAttachedBrowserSession, context2.chromeStartupArgs)),
     redactedRecoveryHint: redactRecoveryHint(plan.recoveryHint),
-    statePatch: plan.managedSessionName === context.freshSessionName ? { freshSessionOrdinal: context.freshSessionOrdinal + 1 } : {},
+    statePatch: plan.managedSessionName === context2.freshSessionName ? { freshSessionOrdinal: context2.freshSessionOrdinal + 1 } : {},
     exactSensitiveValues: getExactSensitiveStdinValues({
       command: plan.commandInfo.command,
-      commandTokens: context.semantic.commandTokens,
-      stdin: context.stdin
+      commandTokens: context2.semantic.commandTokens,
+      stdin: context2.stdin
     })
   };
 }
-function guardRequest(context, evidence) {
+function guardRequest(context2, evidence) {
   return {
-    plan: context.semantic.selection.executionPlan,
-    redactedArgs: context.input.redactedArgs,
+    plan: context2.semantic.selection.executionPlan,
+    redactedArgs: context2.input.redactedArgs,
     effectiveArgs: evidence.redactedEffectiveArgs,
-    sessionMode: context.sessionMode,
+    sessionMode: context2.sessionMode,
     statePatch: evidence.statePatch
   };
 }
-function planRecoveryActions(context, tabError) {
-  const { selection, scrollRecovery } = context.semantic;
+function planRecoveryActions(context2, tabError) {
+  const { selection, scrollRecovery } = context2.semantic;
   const plan = selection.executionPlan;
   return applyNamespaceToNextActions(tabError ? buildSessionTabRecoveryNextActions({
     kind: "tab-drift",
@@ -27551,17 +27577,17 @@ function planRecoveryActions(context, tabError) {
     target: selection.page.priorSessionTabTarget
   }) : scrollRecovery?.nextActions, plan.namespace);
 }
-function planFailure(restoreDisabled, context, evidence, cleanup) {
-  const { selection } = context.semantic;
+function planFailure(restoreDisabled, context2, evidence, cleanup) {
+  const { selection } = context2.semantic;
   const { executionPlan: plan, page } = selection;
   const error = plan.validationError;
   if (error === void 0 || error === "") {
     return void 0;
   }
   const tabError = selection.sessionTabSelectionError !== void 0 && selection.sessionTabSelectionError !== "";
-  const nextActions = planRecoveryActions(context, tabError);
+  const nextActions = planRecoveryActions(context2, tabError);
   const nextActionsText = formatAgentBrowserNextActionsText(nextActions);
-  const input = context.input;
+  const input = context2.input;
   return preparationFailure({
     message: [error, nextActionsText].filter((text3) => text3 !== void 0).join("\n\n"),
     statePatch: evidence.statePatch,
@@ -27577,7 +27603,7 @@ function planFailure(restoreDisabled, context, evidence, cleanup) {
       ...preparationSessionDetails(restoreDisabled, plan),
       ...cleanup.reason !== void 0 ? { namespace: cleanup.namespace ?? "" } : {},
       nextActions,
-      sessionMode: context.sessionMode,
+      sessionMode: context2.sessionMode,
       sessionRecoveryHint: evidence.redactedRecoveryHint,
       startupScopedFlags: plan.startupScopedFlags,
       ...tabError ? {
@@ -27597,41 +27623,41 @@ function planFailure(restoreDisabled, context, evidence, cleanup) {
     }
   });
 }
-function synchronousGuards(traceOwners, restoreDisabled, context, evidence) {
-  const plan = context.semantic.selection.executionPlan;
+function synchronousGuards(traceOwners, restoreDisabled, context2, evidence) {
+  const plan = context2.semantic.selection.executionPlan;
   const traceError = getTraceOwnerGuardMessage({
     command: plan.commandInfo.command,
-    sessionName: context.semantic.selection.page.sessionStateKey,
+    sessionName: context2.semantic.selection.page.sessionStateKey,
     subcommand: plan.commandInfo.subcommand,
     traceOwners
   });
   const error = traceError !== void 0 && traceError !== "" ? traceError : validateStdinCommandContract({
     command: plan.commandInfo.command,
-    commandTokens: context.semantic.commandTokens,
-    stdin: context.stdin
+    commandTokens: context2.semantic.commandTokens,
+    stdin: context2.stdin
   });
-  return error !== void 0 && error !== "" ? categorizedGuardFailure(restoreDisabled, guardRequest(context, evidence), {
+  return error !== void 0 && error !== "" ? categorizedGuardFailure(restoreDisabled, guardRequest(context2, evidence), {
     message: error,
     validationError: error
   }) : void 0;
 }
-async function artifactCloseGuard(artifactManifest, facts, context, evidence) {
+async function artifactCloseGuard(artifactManifest, facts, context2, evidence) {
   const violation = await findRequestedArtifactCloseViolation({
     artifactManifest,
-    command: context.semantic.selection.executionPlan.commandInfo.command,
+    command: context2.semantic.selection.executionPlan.commandInfo.command,
     cwd: facts.cwd,
     promptPolicy: facts.promptPolicy
   });
-  return violation ? categorizedGuardFailure(facts.isRestoreDisabled(), guardRequest(context, evidence), {
+  return violation ? categorizedGuardFailure(facts.isRestoreDisabled(), guardRequest(context2, evidence), {
     message: violation.message,
     validationError: violation.message,
     failureCategory: "policy-blocked",
     details: { promptGuard: violation }
   }) : void 0;
 }
-function staleRefFailure(restoreDisabled, context, evidence, request) {
-  const plan = context.semantic.selection.executionPlan;
-  return categorizedGuardFailure(restoreDisabled, guardRequest(context, evidence), {
+function staleRefFailure(restoreDisabled, context2, evidence, request) {
+  const plan = context2.semantic.selection.executionPlan;
+  return categorizedGuardFailure(restoreDisabled, guardRequest(context2, evidence), {
     message: request.stale.message,
     failureCategory: "stale-ref",
     details: {
@@ -27642,8 +27668,8 @@ function staleRefFailure(restoreDisabled, context, evidence, request) {
     }
   });
 }
-async function refGuards(owners, facts, context, evidence) {
-  const { commandTokens, resolvedSnapshot, selection } = context.semantic;
+async function refGuards(owners, facts, context2, evidence) {
+  const { commandTokens, resolvedSnapshot, selection } = context2.semantic;
   const { page, executionPlan: plan } = selection;
   const stale = buildStaleRefPreflight({
     commandTokens,
@@ -27651,10 +27677,10 @@ async function refGuards(owners, facts, context, evidence) {
     requireExactTargetUrl: page.reuseConfirmedCapture,
     refSnapshot: resolvedSnapshot ?? page.priorRefSnapshotState,
     refSnapshotInvalidation: resolvedSnapshot ? void 0 : page.priorRefSnapshotInvalidation,
-    stdin: context.stdin
+    stdin: context2.stdin
   });
   if (stale) {
-    return staleRefFailure(facts.isRestoreDisabled(), context, evidence, {
+    return staleRefFailure(facts.isRestoreDisabled(), context2, evidence, {
       stale,
       includeInvalidation: true
     });
@@ -27664,7 +27690,7 @@ async function refGuards(owners, facts, context, evidence) {
     cwd: facts.cwd,
     currentTarget: page.priorSessionTabTarget,
     previousSnapshot: resolvedSnapshot || page.reuseConfirmedCapture ? void 0 : page.priorRefSnapshotState,
-    stdin: context.stdin,
+    stdin: context2.stdin,
     namespace: plan.namespace,
     sessionName: plan.sessionName,
     signal: facts.signal
@@ -27680,53 +27706,53 @@ async function refGuards(owners, facts, context, evidence) {
       update: owners.update
     });
   }
-  return staleRefFailure(facts.isRestoreDisabled(), context, evidence, {
+  return staleRefFailure(facts.isRestoreDisabled(), context2, evidence, {
     stale: freshness,
     includeInvalidation: false
   });
 }
-async function qaAttachedGuard(facts, context, evidence) {
-  if (context.input.compiledQaPreset?.checks.attached !== true) {
+async function qaAttachedGuard(facts, context2, evidence) {
+  if (context2.input.compiledQaPreset?.checks.attached !== true) {
     return void 0;
   }
-  const plan = context.semantic.selection.executionPlan;
+  const plan = context2.semantic.selection.executionPlan;
   const failure = await validateQaAttachedPrecondition({
     cwd: facts.cwd,
     namespace: plan.namespace,
     sessionName: plan.sessionName,
     signal: facts.signal
   });
-  return failure ? categorizedGuardFailure(facts.isRestoreDisabled(), guardRequest(context, evidence), {
+  return failure ? categorizedGuardFailure(facts.isRestoreDisabled(), guardRequest(context2, evidence), {
     omitCommand: true,
     message: failure.error,
     validationError: failure.error,
     details: {
-      compiledQaPreset: context.input.redactedCompiledQaPreset,
+      compiledQaPreset: context2.input.redactedCompiledQaPreset,
       nextActions: applyNamespaceToNextActions(failure.nextActions, plan.namespace)
     }
   }) : void 0;
 }
-async function validatePreparationGuards(owners, facts, context, evidence) {
-  const invalidPlan = planFailure(facts.isRestoreDisabled(), context, evidence, {
-    reason: context.policy.cleanupOnlyReason,
-    namespace: context.session.ownedManagedSession?.namespace
+async function validatePreparationGuards(owners, facts, context2, evidence) {
+  const invalidPlan = planFailure(facts.isRestoreDisabled(), context2, evidence, {
+    reason: context2.policy.cleanupOnlyReason,
+    namespace: context2.session.ownedManagedSession?.namespace
   });
   if (invalidPlan) {
     return invalidPlan;
   }
-  const synchronous = synchronousGuards(owners.traceOwners, facts.isRestoreDisabled(), context, evidence);
+  const synchronous = synchronousGuards(owners.traceOwners, facts.isRestoreDisabled(), context2, evidence);
   if (synchronous) {
     return synchronous;
   }
-  const artifact = await artifactCloseGuard(owners.artifactManifest, facts, context, evidence);
+  const artifact = await artifactCloseGuard(owners.artifactManifest, facts, context2, evidence);
   if (artifact) {
     return artifact;
   }
-  const refs = await refGuards(owners, facts, context, evidence);
+  const refs = await refGuards(owners, facts, context2, evidence);
   if (refs) {
     return refs;
   }
-  return qaAttachedGuard(facts, context, evidence);
+  return qaAttachedGuard(facts, context2, evidence);
 }
 var init_prepare_guards = __esm({
   "dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-guards.js"() {
@@ -27861,14 +27887,14 @@ function formatRenderedTextSearchMatches(result) {
     return void 0;
   }
   const lines = result.matches.map((match) => {
-    const context = [
+    const context2 = [
       match.kind === "validation" ? "validation" : void 0,
       match.offscreen ? "outside viewport" : void 0,
       match.role,
       match.tagName,
       match.ref !== void 0 && match.ref !== "" ? `@${match.ref}` : void 0
     ].filter(Boolean).join(", ");
-    return `- ${JSON.stringify(match.text)}${context !== "" ? ` (${context})` : ""}`;
+    return `- ${JSON.stringify(match.text)}${context2 !== "" ? ` (${context2})` : ""}`;
   });
   if (result.truncated) {
     lines.push(`- ... (${result.totalMatches - result.matches.length} additional rendered-text matches omitted)`);
@@ -28611,24 +28637,24 @@ var init_scroll_shims = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-observations.js
-function observationRequest(process2, restoreDisabled, context, evidence) {
-  const plan = context.semantic.selection.executionPlan;
+function observationRequest(process2, restoreDisabled, context2, evidence) {
+  const plan = context2.semantic.selection.executionPlan;
   return {
-    commandTokens: [...context.semantic.commandTokens],
+    commandTokens: [...context2.semantic.commandTokens],
     compatibilityWorkaround: plan.compatibilityWorkaround,
     cwd: process2.cwd,
     effectiveArgs: [...evidence.redactedEffectiveArgs],
     managedSessionRestoreDisabled: restoreDisabled,
-    redactedArgs: context.input.redactedArgs,
-    sessionMode: context.sessionMode,
+    redactedArgs: context2.input.redactedArgs,
+    sessionMode: context2.sessionMode,
     namespace: plan.namespace,
     sessionName: plan.sessionName,
     signal: process2.signal,
     usedImplicitSession: plan.usedImplicitSession
   };
 }
-async function bindFilteredSnapshotGeneration(owners, process2, context) {
-  const { page, executionPlan: plan } = context.semantic.selection;
+async function bindFilteredSnapshotGeneration(owners, process2, context2) {
+  const { page, executionPlan: plan } = context2.semantic.selection;
   const key = page.sessionStateKey;
   if (key === void 0 || key === "" || plan.sessionName === void 0 || plan.sessionName === "") {
     return;
@@ -28636,18 +28662,18 @@ async function bindFilteredSnapshotGeneration(owners, process2, context) {
   const daemon = await inspectPreparationGeneration(process2, {
     namespace: plan.namespace,
     sessionName: plan.sessionName,
-    owned: context.session.ownedManagedSession
+    owned: context2.session.ownedManagedSession
   });
   owners.pageState.bindSnapshotGeneration(key, daemon.status === "active" ? daemon.generation : void 0);
-  if (context.session.ownedManagedSession && daemon.status === "active" && daemon.generation !== void 0 && daemon.generation !== "") {
+  if (context2.session.ownedManagedSession && daemon.status === "active" && daemon.generation !== void 0 && daemon.generation !== "") {
     owners.restoreState.recordDaemonRestoreKey(plan.sessionName, plan.namespace, daemon.restoreKey, daemon.generation);
   }
   return { refSnapshot: owners.pageState.get(key).refSnapshot };
 }
-async function filteredSnapshot(owners, process2, context, evidence) {
-  const { page } = context.semantic.selection;
+async function filteredSnapshot(owners, process2, context2, evidence) {
+  const { page } = context2.semantic.selection;
   const result = await trySnapshotFilter({
-    ...observationRequest(process2, () => owners.restoreState.isDisabled(context.semantic.selection.executionPlan.sessionName, context.semantic.selection.executionPlan.namespace), context, evidence),
+    ...observationRequest(process2, () => owners.restoreState.isDisabled(context2.semantic.selection.executionPlan.sessionName, context2.semantic.selection.executionPlan.namespace), context2, evidence),
     modelVisible: process2.modelVisible,
     artifactManifest: owners.artifactManifest,
     persistentArtifactStore: owners.artifactStore,
@@ -28659,7 +28685,7 @@ async function filteredSnapshot(owners, process2, context, evidence) {
   if (!result) {
     return void 0;
   }
-  const generation = await bindFilteredSnapshotGeneration(owners, process2, context);
+  const generation = await bindFilteredSnapshotGeneration(owners, process2, context2);
   const toolResult = generation && isRecord(result.result.details) ? { ...result.result, details: { ...result.result.details, ...generation } } : result.result;
   return {
     kind: "early-result",
@@ -28670,17 +28696,17 @@ async function filteredSnapshot(owners, process2, context, evidence) {
     result: toolResult
   };
 }
-async function prepareObservations(owners, process2, context, evidence) {
-  const snapshot = await filteredSnapshot(owners, process2, context, evidence);
+async function prepareObservations(owners, process2, context2, evidence) {
+  const snapshot = await filteredSnapshot(owners, process2, context2, evidence);
   if (snapshot) {
     return snapshot;
   }
-  const request = observationRequest(process2, () => owners.restoreState.isDisabled(context.semantic.selection.executionPlan.sessionName, context.semantic.selection.executionPlan.namespace), context, evidence);
+  const request = observationRequest(process2, () => owners.restoreState.isDisabled(context2.semantic.selection.executionPlan.sessionName, context2.semantic.selection.executionPlan.namespace), context2, evidence);
   const network = await tryNetworkRequestsPageFilter(request);
   if (network) {
     return { kind: "early-result", statePatch: evidence.statePatch, result: network };
   }
-  if (context.semantic.selection.executionPlan.startupScopedFlags.length !== 0) {
+  if (context2.semantic.selection.executionPlan.startupScopedFlags.length !== 0) {
     return void 0;
   }
   const container = await tryContainerScroll(request);
@@ -28768,30 +28794,30 @@ var init_prepare_timeouts = __esm({
 });
 
 // dist/extensions/agent-browser/lib/orchestration/browser-run/prepare-command.js
-function shouldProbeScrollNoop(managedSessionActive, context) {
-  const plan = context.semantic.selection.executionPlan;
-  const amount = Number(context.semantic.commandTokens.find((token) => /^\d+(?:\.\d+)?$/.test(token)));
-  return plan.commandInfo.command === "scroll" && plan.startupScopedFlags.length === 0 && (managedSessionActive || context.sessionMode === "fresh") && (!Number.isFinite(amount) || amount >= 500);
-}
-function redactedSemanticAction(context) {
-  const compiled = context.input.redactedCompiledSemanticAction;
-  return context.semantic.resolution && compiled?.action === "select" ? { ...compiled, args: redactInvocationArgs(context.semantic.resolution.args) } : compiled;
-}
-async function nativeCommandEvidence(facts, context) {
-  const plan = context.semantic.selection.executionPlan;
-  const page = context.semantic.selection.page;
-  const promptSnapshot = context.semantic.resolvedSnapshot ?? page.priorRefSnapshotState;
-  const processStdin = context.preparedArgs.stdin ?? context.stdin;
+function shouldProbeScrollNoop(managedSessionActive, context2) {
+  const plan = context2.semantic.selection.executionPlan;
+  const amount = Number(context2.semantic.commandTokens.find((token) => /^\d+(?:\.\d+)?$/.test(token)));
+  return plan.commandInfo.command === "scroll" && plan.startupScopedFlags.length === 0 && (managedSessionActive || context2.sessionMode === "fresh") && (!Number.isFinite(amount) || amount >= 500);
+}
+function redactedSemanticAction(context2) {
+  const compiled = context2.input.redactedCompiledSemanticAction;
+  return context2.semantic.resolution && compiled?.action === "select" ? { ...compiled, args: redactInvocationArgs(context2.semantic.resolution.args) } : compiled;
+}
+async function nativeCommandEvidence(facts, context2) {
+  const plan = context2.semantic.selection.executionPlan;
+  const page = context2.semantic.selection.page;
+  const promptSnapshot = context2.semantic.resolvedSnapshot ?? page.priorRefSnapshotState;
+  const processStdin = context2.preparedArgs.stdin ?? context2.stdin;
   const processTimeoutMs = await prepareProcessTimeout(facts, {
-    commandTokens: context.semantic.commandTokens,
+    commandTokens: context2.semantic.commandTokens,
     namespace: plan.namespace,
     sessionName: plan.sessionName,
     stdin: processStdin,
     pageUrl: page.priorSessionTabTarget?.url,
     refSnapshot: promptSnapshot
   });
-  const clickDispatchProbe = context.input.compiledElectron === void 0 ? await prepareClickDispatchProbe({
-    commandTokens: [...context.semantic.commandTokens],
+  const clickDispatchProbe = context2.input.compiledElectron === void 0 ? await prepareClickDispatchProbe({
+    commandTokens: [...context2.semantic.commandTokens],
     cwd: facts.cwd,
     namespace: plan.namespace,
     refSnapshot: promptSnapshot,
@@ -28799,8 +28825,8 @@ async function nativeCommandEvidence(facts, context) {
     signal: facts.signal,
     timeoutMs: processTimeoutMs
   }) : void 0;
-  const redactedProcessArgs = redactInvocationArgs(prepareAgentBrowserSpawnArgs(plan.effectiveArgs, context.session.ownedManagedSession?.compatibilityUserAgent, facts.preserveAttachedBrowserSession, context.chromeStartupArgs));
-  const probeScroll = shouldProbeScrollNoop(facts.managedSessionActive, context);
+  const redactedProcessArgs = redactInvocationArgs(prepareAgentBrowserSpawnArgs(plan.effectiveArgs, context2.session.ownedManagedSession?.compatibilityUserAgent, facts.preserveAttachedBrowserSession, context2.chromeStartupArgs));
+  const probeScroll = shouldProbeScrollNoop(facts.managedSessionActive, context2);
   const scrollPositionBefore = probeScroll ? await collectScrollPositionSnapshot({
     cwd: facts.cwd,
     namespace: plan.namespace,
@@ -28817,8 +28843,8 @@ async function nativeCommandEvidence(facts, context) {
     details: {
       compatibilityWorkaround: plan.compatibilityWorkaround,
       effectiveArgs: redactedProcessArgs,
-      sessionMode: context.sessionMode,
-      sessionTabCorrection: context.semantic.selection.sessionTabCorrection,
+      sessionMode: context2.sessionMode,
+      sessionTabCorrection: context2.semantic.selection.sessionTabCorrection,
       ...preparationSessionDetails(facts.isRestoreDisabled(), plan)
     }
   });
@@ -28832,11 +28858,11 @@ async function nativeCommandEvidence(facts, context) {
     scrollPositionBefore
   };
 }
-async function prepareNativeCommand(facts, context, evidence) {
-  const native = await nativeCommandEvidence(facts, context);
-  const plan = context.semantic.selection.executionPlan;
-  const page = context.semantic.selection.page;
-  const input = context.input;
+async function prepareNativeCommand(facts, context2, evidence) {
+  const native = await nativeCommandEvidence(facts, context2);
+  const plan = context2.semantic.selection.executionPlan;
+  const page = context2.semantic.selection.page;
+  const input = context2.input;
   return {
     kind: "ready",
     prepared: {
@@ -28853,32 +28879,32 @@ async function prepareNativeCommand(facts, context, evidence) {
       redactedCompiledQaPreset: input.redactedCompiledQaPreset,
       redactedCompiledSourceLookup: input.redactedCompiledSourceLookup,
       ...native,
-      chromeStartupArgs: context.chromeStartupArgs,
-      commandTokens: [...context.semantic.commandTokens],
-      headedLaunch: context.session.headedLaunch,
-      providerLaunch: context.session.providerLaunch,
-      managedSessionPolicyLock: context.policy.lock,
+      chromeStartupArgs: context2.chromeStartupArgs,
+      commandTokens: [...context2.semantic.commandTokens],
+      headedLaunch: context2.session.headedLaunch,
+      providerLaunch: context2.session.providerLaunch,
+      managedSessionPolicyLock: context2.policy.lock,
       compatibilityWorkaround: plan.compatibilityWorkaround,
-      electronLaunch: context.electronLaunch,
+      electronLaunch: context2.electronLaunch,
       exactSensitiveValues: [...evidence.exactSensitiveValues],
       executionPlan: plan,
-      ownedManagedSessionContext: context.session.ownedManagedSession,
-      preparedArgs: context.preparedArgs,
-      readConfirmation: context.session.readConfirmation,
+      ownedManagedSessionContext: context2.session.ownedManagedSession,
+      preparedArgs: context2.preparedArgs,
+      readConfirmation: context2.session.readConfirmation,
       priorRefSnapshotState: page.priorRefSnapshotState,
       priorSessionTabTarget: page.priorSessionTabTarget,
       priorSessionTabTargetUnknown: page.priorSessionTabTargetUnknown,
-      redactedCompiledSemanticAction: redactedSemanticAction(context),
+      redactedCompiledSemanticAction: redactedSemanticAction(context2),
       redactedEffectiveArgs: [...evidence.redactedEffectiveArgs],
       redactedRecoveryHint: evidence.redactedRecoveryHint,
-      resolvedSemanticActionRefSnapshot: context.semantic.resolvedSnapshot,
-      runtimeToolArgs: [...context.runtimeToolArgs],
-      runtimeToolStdin: context.stdin,
-      sessionMode: context.sessionMode,
-      sessionTabCorrection: context.semantic.selection.sessionTabCorrection,
+      resolvedSemanticActionRefSnapshot: context2.semantic.resolvedSnapshot,
+      runtimeToolArgs: [...context2.runtimeToolArgs],
+      runtimeToolStdin: context2.stdin,
+      sessionMode: context2.sessionMode,
+      sessionTabCorrection: context2.semantic.selection.sessionTabCorrection,
       sessionTabPinningReason: page.sessionTabPinningReason,
       statePatch: evidence.statePatch,
-      userRequestedJson: getBooleanFlagValue(context.runtimeToolArgs, "--json") === true
+      userRequestedJson: getBooleanFlagValue(context2.runtimeToolArgs, "--json") === true
     }
   };
 }
@@ -28930,39 +28956,41 @@ function rawPageFailure(input) {
     }
   });
 }
-async function prepareCommandPhases(state, controls, context) {
-  const plan = context.semantic.selection.executionPlan;
+async function prepareCommandPhases(state, controls, context2) {
+  const plan = context2.semantic.selection.executionPlan;
   const isRestoreDisabled = () => state.managedSessionRestoreState.isDisabled(plan.sessionName, plan.namespace);
-  const evidence = prepareGuardEvidence(controls.preserveAttachedBrowserSession, context);
+  const evidence = prepareGuardEvidence(controls.preserveAttachedBrowserSession, context2);
   const guarded = await validatePreparationGuards({
     pageState: state.sessionPageState,
-    update: context.update,
+    update: context2.update,
     traceOwners: state.traceOwners,
     artifactManifest: state.artifactManifest
-  }, { ...controls, isRestoreDisabled }, context, evidence);
+  }, { ...controls, isRestoreDisabled }, context2, evidence);
   if (guarded) {
     return guarded;
   }
   const observation2 = await prepareObservations({
     pageState: state.sessionPageState,
     restoreState: state.managedSessionRestoreState,
-    update: context.update,
+    update: context2.update,
     artifactManifest: state.artifactManifest,
     artifactStore: controls.artifactStore
-  }, controls, context, evidence);
+  }, controls, context2, evidence);
   if (observation2) {
     return observation2;
   }
-  return prepareNativeCommand({ ...controls, managedSessionActive: state.managedSessionActive, isRestoreDisabled }, context, evidence);
+  return prepareNativeCommand({ ...controls, managedSessionActive: state.managedSessionActive, isRestoreDisabled }, context2, evidence);
 }
 async function preparePagePhases(state, controls, planning, request) {
   const { plan, session, policy } = planning;
+  const initial = controls.initialDaemonObservation;
   const page = await preparePageState(state, controls, {
     plan,
     session,
     inactive: policy.inactive,
     update: request.update,
-    preserveAttachedBrowserSession: controls.preserveAttachedBrowserSession
+    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, {
     ...request,
@@ -29019,7 +29047,8 @@ function preparationControls(options) {
     promptPolicy: options.promptPolicy,
     preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
     establishAttachedBrowserSession: options.establishAttachedBrowserSession,
-    artifactStore: getPersistentSessionArtifactStore(options.ctx)
+    artifactStore: getPersistentSessionArtifactStore(options.ctx),
+    initialDaemonObservation: options.initialDaemonObservation
   };
 }
 function preparationSessionFacts(state) {
@@ -29067,8 +29096,7 @@ async function prepareBrowserRun(options) {
     const chromeStartupArgs = await prepareChromeStartupArgs({
       ...controls,
       chromeStartupArgs: options.input.chromeStartupArgs,
-      configuredChromeLaunch: options.input.configuredChromeLaunch,
-      daemonInactive: options.daemonInactive
+      configuredChromeLaunch: options.input.configuredChromeLaunch
     }, planning, { preparedArgs: artifacts.preparedArgs, stdin: request.stdin });
     const result = await withChromeStartupArgs(chromeStartupArgs, () => withOwnedManagedSessionContext(planning.session.ownedManagedSession, () => preparePagePhases(state, controls, planning, {
       ...request,
@@ -29097,6 +29125,7 @@ var init_prepare = __esm({
     init_categories();
     init_process();
     init_managed_session_restore();
+    init_argv_grammar();
     init_session_state();
     init_prepare_input();
     init_prepare_failure();
@@ -32443,9 +32472,6 @@ import { open as open2, stat as stat2 } from "node:fs/promises";
 
 // dist/extensions/agent-browser/lib/browser-journal-projection.js
 init_parsing();
-init_process_errors();
-import { Readable, Writable } from "node:stream";
-import { pipeline } from "node:stream/promises";
 var ENVELOPE_MAX_BYTES = 16 * 1024 * 1024;
 function matches(field, key) {
   return field === key || field === "*" && typeof key === "number";
@@ -32627,30 +32653,27 @@ var JsonProjection = class {
   }
 };
 async function projectJson(input, fields, maxBytes = ENVELOPE_MAX_BYTES) {
-  const { parser } = await import("stream-json/parser.js");
-  async function* decode() {
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    for await (const chunk of input) {
-      yield decoder.decode(chunk, { stream: true });
-    }
-    const tail = decoder.decode();
-    if (tail.length > 0) {
-      yield tail;
-    }
-  }
+  const { jsonParser } = await import("stream-json/core/parser.js");
+  const chain = await import("stream-chain/defs.js");
+  const tokenize = jsonParser({ packValues: false, streamValues: true });
   const projection = new JsonProjection(fields, maxBytes);
-  const sink = new Writable({
-    objectMode: true,
-    write(token, _encoding, done) {
-      try {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const consume = (text3) => {
+    const tokens = tokenize(text3);
+    if (tokens !== chain.none) {
+      for (const token of chain.getManyValues(tokens)) {
         projection.consume(token);
-        done();
-      } catch (error) {
-        done(normalizeProcessError(error));
       }
     }
-  });
-  await pipeline(Readable.from(decode()), parser.asStream({ packValues: false, streamValues: true }), sink);
+  };
+  for await (const chunk of input) {
+    consume(decoder.decode(chunk, { stream: true }));
+  }
+  const tail = decoder.decode();
+  if (tail.length > 0) {
+    consume(tail);
+  }
+  consume(chain.none);
   return projection.result();
 }
 
@@ -32743,6 +32766,566 @@ init_parsing();
 init_process_errors();
 import { constants } from "node:fs";
 import { open, stat } from "node:fs/promises";
+
+// dist/extensions/agent-browser/lib/browser-conversion-branches.js
+var BrowserConversionBranches = class {
+  states = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Map();
+  constructor(parentIds) {
+    for (const id of parentIds) {
+      if (typeof id === "string") {
+        this.children.set(id, (this.children.get(id) ?? 0) + 1);
+      }
+    }
+  }
+  get(id) {
+    return this.states.get(id);
+  }
+  advance(id, parentId, projection) {
+    if (typeof parentId === "string") {
+      const remaining = (this.children.get(parentId) ?? 0) - 1;
+      if (remaining > 0) {
+        this.children.set(parentId, remaining);
+      } else {
+        this.children.delete(parentId);
+        this.states.delete(parentId);
+      }
+    }
+    if (this.children.has(id)) {
+      this.states.set(id, projection);
+    }
+  }
+};
+
+// dist/extensions/agent-browser/lib/browser-legacy-projection.js
+init_argv_descriptor();
+init_argv_grammar();
+init_batch_lifecycle();
+init_browser_transcript();
+init_command_taxonomy();
+init_parsing();
+init_artifact_manifest();
+init_native_confirmation();
+init_browser_value_parsing();
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// dist/extensions/agent-browser/lib/browser-legacy-pages.js
+init_browser_transcript();
+init_browser_value_parsing();
+init_parsing();
+init_command_taxonomy();
+init_session_page_observation();
+import { createHash } from "node:crypto";
+function legacyTarget(value) {
+  return normalizeSessionTabTarget({
+    url: typeof value.url === "string" ? value.url : void 0,
+    title: typeof value.title === "string" ? value.title : void 0,
+    targetId: typeof value.targetId === "string" ? value.targetId : void 0
+  });
+}
+function legacySnapshot(value, id) {
+  if (!isRecord(value) || !Array.isArray(value.refIds)) {
+    return void 0;
+  }
+  const refIds = browserStringArray(value.refIds).filter((ref) => /^e\d+$/.test(ref));
+  const sourceRefs = isRecord(value.refs) ? value.refs : {};
+  return snapshotDefinition({
+    snapshotId: typeof value.snapshotId === "string" ? value.snapshotId : id,
+    refIds,
+    generation: typeof value.generation === "string" ? value.generation : void 0,
+    refs: Object.fromEntries(refIds.flatMap((refId) => {
+      const ref = sourceRefs[refId];
+      if (!isRecord(ref) || typeof ref.name !== "string" || typeof ref.role !== "string") {
+        return [];
+      }
+      return [
+        [
+          refId,
+          {
+            name: ref.name,
+            role: ref.role,
+            ...typeof ref.isEditable === "boolean" ? { isEditable: ref.isEditable } : {},
+            ...typeof ref.isContentEditable === "boolean" ? { isContentEditable: ref.isContentEditable } : {}
+          }
+        ]
+      ];
+    })),
+    target: isRecord(value.target) ? legacyTarget(value.target) : void 0
+  });
+}
+function snapshotDigest(definition) {
+  return createHash("sha256").update(JSON.stringify({
+    refs: definition.refs,
+    target: definition.target,
+    generation: definition.generation
+  })).digest("hex");
+}
+function canonicalPage(prior, canonical, page) {
+  const definition = isRecord(canonical.snapshot) ? canonical.snapshot : void 0;
+  const digest = definition !== void 0 && Boolean(definition.refs) ? snapshotDigest(definition) : prior.snapshot?.digest ?? "";
+  let snapshot;
+  if (page.refs.kind === "replace" || page.refs.kind === "reuse") {
+    snapshot = { id: page.refs.snapshotId, digest, usable: true, candidate: false };
+  } else if (prior.snapshot) {
+    snapshot = { ...prior.snapshot, usable: false, candidate: canonical.event.phase === "begin" };
+  }
+  return {
+    target: page.target,
+    unknown: page.unknown,
+    reopenPending: page.reopenPending,
+    snapshot,
+    pending: canonical.event.phase === "begin" ? {
+      operationId: canonical.event.operationId,
+      toolCallId: canonical.event.toolCallId,
+      index: canonical.event.commandIndex
+    } : void 0
+  };
+}
+function parseInvalidation2(value, fallbackSummary) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  if (value.reason !== "no-active-page" && value.reason !== "page-transition") {
+    throw new Error("Invalid legacy browser ref invalidation.");
+  }
+  if (typeof value.summary === "string") {
+    return { reason: value.reason, summary: value.summary };
+  }
+  if (fallbackSummary) {
+    return {
+      reason: value.reason,
+      summary: "The prior refs were invalidated; take a fresh snapshot."
+    };
+  }
+  throw new Error("Invalid legacy browser ref invalidation summary.");
+}
+function observedInvalidation(ctx) {
+  const value = ctx.details.refSnapshotInvalidation;
+  if (isRecord(value) && (value.reason === "no-active-page" || value.reason === "page-transition")) {
+    return parseInvalidation2(value, true);
+  }
+  let error;
+  if (typeof ctx.details.error === "string") {
+    error = ctx.details.error;
+  } else if (typeof ctx.details.summary === "string") {
+    error = ctx.details.summary;
+  }
+  return isNoActivePageSnapshotFailure(ctx.command, error) ? buildNoActivePageRefSnapshotInvalidation() : void 0;
+}
+function snapshotReusable(page, details, digest) {
+  return page.snapshot?.digest === digest && (page.snapshot.usable || page.snapshot.candidate) && (!isRecord(details.refSnapshot) || typeof details.refSnapshot.snapshotId !== "string" || details.refSnapshot.snapshotId === page.snapshot.id);
+}
+var LegacyPageConversion = class {
+  ctx;
+  page;
+  definition;
+  constructor(ctx, prior) {
+    this.ctx = ctx;
+    this.page = { ...prior };
+  }
+  knownTarget() {
+    const { details, command, subcommand } = this.ctx;
+    if (!isRecord(details.compiledNetworkSourceLookup) && !isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) && isRecord(details.sessionTabTarget)) {
+      this.page.target = legacyTarget(details.sessionTabTarget) ?? this.page.target;
+    } else if (command === "batch" && !isRecord(details.compiledNetworkSourceLookup)) {
+      this.page.target = extractSessionTabTargetFromBatchResults(details.data) ?? this.page.target;
+    }
+    if (this.page.target) {
+      this.page.unknown = void 0;
+    }
+    if (typeof details.sessionTabReopenPending === "boolean") {
+      this.page.reopenPending = details.sessionTabReopenPending;
+    }
+  }
+  knownRefs() {
+    const invalidation = observedInvalidation(this.ctx);
+    const candidate = invalidation ? void 0 : legacySnapshot(this.ctx.details.refSnapshot, `snapshot-${this.ctx.nativeId}`);
+    if (candidate) {
+      const digest = snapshotDigest(candidate);
+      let refs;
+      if (snapshotReusable(this.page, this.ctx.details, digest) && this.page.snapshot) {
+        refs = { kind: "reuse", snapshotId: this.page.snapshot.id };
+      } else {
+        this.definition = candidate;
+        refs = { kind: "replace", snapshotId: candidate.id };
+      }
+      this.page.snapshot = { id: refs.snapshotId, digest, usable: true, candidate: false };
+      return refs;
+    }
+    if (invalidation) {
+      this.disableSnapshot(false);
+      return { kind: "invalidate", invalidation };
+    }
+    return this.page.snapshot?.usable === true ? { kind: "reuse", snapshotId: this.page.snapshot.id } : { kind: "invalidate" };
+  }
+  disableSnapshot(candidate) {
+    if (this.page.snapshot) {
+      this.page.snapshot = { ...this.page.snapshot, usable: false, candidate };
+    }
+  }
+  change(key) {
+    return {
+      ...this.pageChange(key),
+      ...typeof this.ctx.details.sessionConfirmActions === "string" || this.ctx.details.sessionConfirmActions === null ? { confirmActions: this.ctx.details.sessionConfirmActions } : {}
+    };
+  }
+  pageChange(key) {
+    const ctx = this.ctx;
+    if (ctx.begin) {
+      this.page.target = void 0;
+      this.page.unknown = true;
+      this.page.snapshot = ctx.prior.snapshot ? { ...ctx.prior.snapshot, usable: false, candidate: true } : void 0;
+      this.page.pending = {
+        toolCallId: ctx.toolCallId,
+        operationId: ctx.operationId,
+        index: ctx.commandIndex
+      };
+      return { key, refs: { kind: "unknown" }, unknown: true };
+    }
+    if (ctx.details.sessionTabTargetUnknown === true) {
+      this.page.target = void 0;
+      this.page.unknown = true;
+      this.page.pending = void 0;
+      this.disableSnapshot(false);
+      return {
+        key,
+        refs: {
+          kind: "unknown",
+          invalidation: parseInvalidation2(ctx.details.refSnapshotInvalidation, false)
+        },
+        unknown: true
+      };
+    }
+    this.knownTarget();
+    const refs = this.knownRefs();
+    this.page.pending = void 0;
+    return {
+      key,
+      target: this.page.target,
+      unknown: this.page.unknown,
+      reopenPending: this.page.reopenPending,
+      refs
+    };
+  }
+};
+
+// dist/extensions/agent-browser/lib/browser-legacy-projection.js
+var emptyProjection = () => ({ pages: /* @__PURE__ */ new Map(), nextIndex: 0 });
+function legacyMessage(entry) {
+  if (entry.type === "custom" && entry.customType === BROWSER_TRANSITION_ENTRY && isRecord(entry.data) && isRecord(entry.data.details)) {
+    return entry.data;
+  }
+  const message = entry.type === "message" && isRecord(entry.message) ? entry.message : void 0;
+  return isLegacyToolMessage(message) ? message : void 0;
+}
+function isLegacyToolMessage(message) {
+  return message !== void 0 && typeof message.toolName === "string" && BROWSER_RESULT_TOOLS.has(message.toolName) && isRecord(message.details) && message.details.browserEventVersion !== 1;
+}
+function applyCanonical(current, parent, canonical) {
+  current.manifest = applyArtifactChanges(parent.manifest, canonical.event.artifacts);
+  for (const page of canonical.event.pages ?? []) {
+    if (page.clear === true) {
+      current.pages.delete(page.key);
+      continue;
+    }
+    current.pages.set(page.key, canonicalPage(current.pages.get(page.key) ?? {}, canonical, page));
+  }
+}
+function scriptRecord(entry, nativeId, ownerSessionId) {
+  if (entry.type !== "custom" || entry.customType !== "agent-browser-script-session" || !isRecord(entry.data)) {
+    return void 0;
+  }
+  return {
+    event: {
+      version: 1,
+      phase: "state",
+      operationId: `legacy-${nativeId}`,
+      toolCallId: `legacy-${nativeId}`,
+      commandIndex: 0,
+      isError: entry.data.cleanup !== "closed",
+      state: {
+        scriptLease: { ...entry.data, ownerSessionId: entry.data.ownerSessionId ?? ownerSessionId }
+      }
+    }
+  };
+}
+function isLegacyBegin(entry, details) {
+  return entry.type === "custom" && details.sessionTabTargetUnknown === true && details.command === void 0 && details.exitCode === void 0 && details.agentBrowserStarted === void 0;
+}
+function legacyIdentity(details) {
+  const sessionName = typeof details.sessionName === "string" ? details.sessionName : void 0;
+  const namespace = typeof details.namespace === "string" ? details.namespace : void 0;
+  const key = sessionName !== void 0 && sessionName.length > 0 ? getAgentBrowserSessionIdentityKey(sessionName, namespace) : void 0;
+  const tokens = extractUpstreamCommandTokens(browserStringArray(details.args));
+  return {
+    key,
+    namespace,
+    tokens,
+    command: typeof details.command === "string" ? details.command : tokens[0],
+    subcommand: typeof details.subcommand === "string" ? details.subcommand : tokens[1]
+  };
+}
+function legacyPrior(key, current) {
+  return key === void 0 ? {} : current.pages.get(key) ?? {};
+}
+function operationIdentity(options, current) {
+  const prior = legacyPrior(options.key, current);
+  const begin = isLegacyBegin(options.entry, options.details);
+  const pending = prior.pending?.toolCallId === options.toolCallId ? prior.pending : void 0;
+  let phase = "state";
+  if (begin) {
+    phase = "begin";
+  } else if (pending) {
+    phase = "finish";
+  }
+  let commandIndex = pending?.index ?? 0;
+  if (begin) {
+    commandIndex = current.nextIndex;
+    current.nextIndex++;
+  }
+  return {
+    prior,
+    begin,
+    phase,
+    commandIndex,
+    operationId: pending?.operationId ?? `legacy-${options.nativeId}`
+  };
+}
+function normalizeLegacyBatchStep(step) {
+  return step.success === true && isSuccessfulNativeConfirmedClose(browserStringArray(step.command), step.data) ? { ...step, command: ["close"] } : step;
+}
+function normalizeLegacyDetails(details, isError) {
+  const closed = !isError && isSuccessfulNativeConfirmedClose(extractUpstreamCommandTokens(browserStringArray(details.args)), details.data);
+  const batchSteps = Array.isArray(details.batchSteps) ? details.batchSteps.filter(isRecord).map(normalizeLegacyBatchStep) : void 0;
+  return {
+    ...details,
+    ...closed ? { command: "close", subcommand: void 0 } : {},
+    ...batchSteps !== void 0 ? { batchSteps } : {}
+  };
+}
+function context(entry, message, details, current) {
+  const nativeId = typeof entry.id === "string" ? entry.id : randomUUID2();
+  const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : `legacy-${nativeId}`;
+  const replayDetails = normalizeLegacyDetails(details, message.isError === true);
+  const identity = legacyIdentity(replayDetails);
+  const operation = operationIdentity({ entry, details: replayDetails, key: identity.key, toolCallId, nativeId }, current);
+  return {
+    ...identity,
+    ...operation,
+    nativeId,
+    details: replayDetails,
+    isError: message.isError === true,
+    toolCallId
+  };
+}
+function closingLifecycle(ctx) {
+  const close = getSuccessfulBatchCloseLifecycle(ctx.details.batchSteps);
+  const closeAll = ctx.details.closeAllApplied === true || !ctx.isError && isCloseAllCommand(ctx.tokens) || batchHasSuccessfulCloseAll(ctx.details.batchSteps);
+  return {
+    closeAll,
+    lifecycleReset: !ctx.isError && isCloseCommand(ctx.command) || close !== void 0,
+    endsClosed: close?.endsClosed === true
+  };
+}
+function closePages(current, ctx) {
+  const closing = closingLifecycle(ctx);
+  const pages = [];
+  if (closing.closeAll) {
+    for (const key of current.pages.keys()) {
+      if (isAgentBrowserSessionIdentityKeyInNamespace(key, ctx.namespace)) {
+        current.pages.delete(key);
+        pages.push({ key, clear: true, refs: { kind: "invalidate" } });
+      }
+    }
+  } else if (ctx.key !== void 0 && closing.lifecycleReset) {
+    current.pages.delete(ctx.key);
+    pages.push({ key: ctx.key, clear: true, refs: { kind: "invalidate" } });
+  }
+  return { ...closing, pages };
+}
+function hasPageEffects(ctx) {
+  return ctx.begin || [
+    "sessionTabTargetUnknown",
+    "sessionTabTarget",
+    "sessionTabReopenPending",
+    "sessionConfirmActions",
+    "refSnapshot",
+    "refSnapshotInvalidation"
+  ].some((field) => ctx.details[field] !== void 0) || ctx.command === "batch" && Array.isArray(ctx.details.data);
+}
+function stampElectronState(state, ownerSessionId) {
+  if (!isRecord(state.electron)) {
+    return state;
+  }
+  const stamp = (value) => isRecord(value) ? { ...value, ownerSessionId: value.ownerSessionId ?? ownerSessionId } : value;
+  const cleanup = isRecord(state.electron.cleanup) ? state.electron.cleanup : void 0;
+  return {
+    ...state,
+    electron: {
+      ...state.electron,
+      launch: stamp(state.electron.launch),
+      ...cleanup ? {
+        cleanup: {
+          ...cleanup,
+          records: Array.isArray(cleanup.records) ? cleanup.records.map(stamp) : cleanup.records,
+          results: Array.isArray(cleanup.results) ? cleanup.results.map((row) => isRecord(row) ? { ...row, record: stamp(row.record) } : row) : cleanup.results
+        }
+      } : {}
+    }
+  };
+}
+function updateManifest(current, parent, details) {
+  if (isSessionArtifactManifest(details.artifactManifest) && (!parent.manifest || details.artifactManifest.updatedAtMs >= parent.manifest.updatedAtMs)) {
+    current.manifest = details.artifactManifest;
+  }
+  const changes = artifactChanges(parent.manifest, current.manifest);
+  if (!changes) {
+    current.manifest = parent.manifest;
+  }
+  return changes;
+}
+function convertMessage(ctx, parent, current, ownerSessionId) {
+  const closing = closePages(current, ctx);
+  const pages = closing.pages;
+  let definition;
+  const suppressPage = (closing.closeAll || closing.lifecycleReset) && (isCloseCommand(ctx.command) || closing.endsClosed);
+  if (ctx.key !== void 0 && hasPageEffects(ctx) && !suppressPage) {
+    const conversion = new LegacyPageConversion(ctx, current.pages.get(ctx.key) ?? {});
+    pages.push(conversion.change(ctx.key));
+    current.pages.set(ctx.key, conversion.page);
+    definition = conversion.definition;
+  }
+  const artifacts = updateManifest(current, parent, ctx.details);
+  return {
+    event: {
+      version: 1,
+      phase: ctx.phase,
+      operationId: ctx.operationId,
+      toolCallId: ctx.toolCallId,
+      commandIndex: ctx.commandIndex,
+      isError: ctx.isError,
+      state: stampElectronState(browserStateEffects(ctx.details), ownerSessionId),
+      pages,
+      artifacts
+    },
+    ...definition ? { snapshot: definition } : {}
+  };
+}
+function hasCanonicalBrowserEvent(entry) {
+  return isRecord(entry.data) && Object.hasOwn(entry.data, "event") && (entry.type === "message" || entry.customType === BROWSER_TRANSITION_ENTRY);
+}
+function convertLegacyBrowserEntry(entry, parent = emptyProjection(), ownerSessionId) {
+  const current = {
+    pages: new Map(parent.pages),
+    manifest: parent.manifest,
+    nextIndex: parent.nextIndex
+  };
+  const canonical = getBrowserRecord(entry);
+  if (canonical) {
+    applyCanonical(current, parent, canonical);
+    return { projection: current };
+  }
+  if (hasCanonicalBrowserEvent(entry)) {
+    throw new Error("Invalid browser event; legacy replay cannot bypass canonical validation.");
+  }
+  const script = scriptRecord(entry, typeof entry.id === "string" ? entry.id : randomUUID2(), ownerSessionId);
+  if (script) {
+    return { record: script, projection: current };
+  }
+  const message = legacyMessage(entry);
+  if (!message || !isRecord(message.details)) {
+    return { projection: parent };
+  }
+  return {
+    record: convertMessage(context(entry, message, message.details, current), parent, current, ownerSessionId),
+    projection: current
+  };
+}
+function archiveParent(value, branches, linear) {
+  if (typeof value.parentId === "string") {
+    return branches.get(value.parentId) ?? emptyProjection();
+  }
+  return Object.hasOwn(value, "parentId") ? emptyProjection() : linear;
+}
+function convertBrowserEntries(entries, ownerSessionId) {
+  const branches = new BrowserConversionBranches(entries.map((value) => isRecord(value) ? value.parentId : void 0));
+  let linear = emptyProjection();
+  return entries.map((value, index) => {
+    if (!isRecord(value)) {
+      return value;
+    }
+    const entry = {
+      ...value,
+      id: typeof value.id === "string" ? value.id : `archive-${index}`,
+      parentId: value.parentId ?? null
+    };
+    const converted = convertLegacyBrowserEntry(entry, archiveParent(value, branches, linear), ownerSessionId);
+    branches.advance(entry.id, value.parentId, converted.projection);
+    linear = converted.projection;
+    return converted.record ? {
+      ...entry,
+      ...entry.type === "custom" ? { customType: BROWSER_TRANSITION_ENTRY } : {},
+      data: converted.record
+    } : entry;
+  });
+}
+
+// dist/extensions/agent-browser/lib/browser-legacy-fields.js
+init_browser_transcript_contracts();
+var DETAILS_FIELDS = [
+  ...BROWSER_STATE_FIELDS,
+  "browserEventVersion",
+  "electron",
+  "compiledNetworkSourceLookup",
+  "sessionTabTarget",
+  "sessionTabTargetUnknown",
+  "sessionTabReopenPending",
+  "sessionConfirmActions",
+  "refSnapshot",
+  "refSnapshotInvalidation",
+  "artifactManifest",
+  "error",
+  "summary"
+];
+var CONFIRMED_CLOSE_FIELDS = [
+  ["confirmed"],
+  ["action"],
+  ["result", "success"],
+  ["result", "data", "closed"]
+];
+var LEGACY_BROWSER_FIELDS = [
+  ["data", "event"],
+  ["data", "snapshot"],
+  ["data", "cleanup"],
+  ["data", "sessionName"],
+  ["data", "ownerSessionId"],
+  ["data", "closeCommandArgs"],
+  ["data", "launchAttempted"],
+  ["data", "toolCallId"],
+  ["data", "isError"],
+  ["message", "toolName"],
+  ["message", "toolCallId"],
+  ["message", "isError"],
+  ...["data", "message"].flatMap((root) => DETAILS_FIELDS.map((field) => [root, "details", field])),
+  ...["data", "message"].flatMap((root) => CONFIRMED_CLOSE_FIELDS.flatMap((field) => [
+    [root, "details", "data", ...field],
+    [root, "details", "batchSteps", "*", "data", ...field]
+  ])),
+  ...["data", "message"].flatMap((root) => ["command", "success", "lifecycle"].map((field) => [root, "details", "batchSteps", "*", field]).concat([
+    ["data", "lifecycle"],
+    ["result", "lifecycle"]
+  ].map((field) => [root, "details", "batchSteps", "*"].concat(field)))),
+  ...["data", "message"].flatMap((root) => ["command", "success", "error"].map((field) => [root, "details", "data", "*", field]).concat(["url", "title", "origin", "targetId"].map((field) => [
+    root,
+    "details",
+    "data",
+    "*",
+    "result",
+    field
+  ])))
+];
+
+// dist/extensions/agent-browser/lib/browser-journal-replay.js
 var REPLAY_CUSTOM_TYPES = /* @__PURE__ */ new Set([
   BROWSER_TRANSITION_ENTRY,
   "agent-browser-recording-reservation",
@@ -32795,18 +33378,6 @@ function legacyBrowserResult(entry) {
   }
   return message.details.sessionName !== void 0 || message.details.artifactManifest !== void 0 || message.details.electron !== void 0;
 }
-function validateMemoryEntry(entry) {
-  if (!isRecord(entry)) {
-    return;
-  }
-  if (legacyCustom(entry) && !getBrowserRecord(entry)) {
-    throw new Error("Legacy browser records require stopped separate-copy conversion before replay.");
-  }
-  const message = browserMessage(entry);
-  if (entry.type === "message" && message && isRecord(message.details) && message.details.browserEventVersion !== 1 && !getBrowserRecord(entry)) {
-    throw new Error("Legacy browser observations require stopped separate-copy conversion before replay.");
-  }
-}
 function inMemoryEntries(manager, physical) {
   const entries = physical ? manager.getEntries() : [];
   if (!physical) {
@@ -32826,17 +33397,53 @@ function inMemoryEntries(manager, physical) {
     }
     entries.reverse();
   }
-  for (const entry of entries) {
-    validateMemoryEntry(entry);
+  return convertBrowserEntries(entries, legacyOwner(manager));
+}
+function legacyOwner(manager) {
+  const header = manager.getHeader();
+  return header?.parentSession !== void 0 ? void 0 : header?.id ?? manager.getSessionId();
+}
+function replayFields(value, legacy) {
+  if (legacy) {
+    return LEGACY_BROWSER_FIELDS;
   }
-  return entries;
+  return value.customType === BROWSER_TRANSITION_ENTRY || value.type === "message" ? [
+    ["data", "event"],
+    ["data", "snapshot", "id"]
+  ] : [["data"]];
+}
+function projectedRecord(value, record) {
+  return {
+    ...value,
+    ...value.type === "custom" ? { customType: BROWSER_TRANSITION_ENTRY } : {},
+    data: {
+      ...record,
+      ...isRecord(record.snapshot) ? { snapshot: { id: record.snapshot.id } } : {}
+    }
+  };
+}
+function winningSnapshot(body, source) {
+  if (!source.legacy) {
+    return isRecord(body?.data) ? body.data.snapshot : void 0;
+  }
+  const value = body?.[source.root];
+  return isRecord(value) && isRecord(value.details) ? legacySnapshot(value.details.refSnapshot, source.id) : void 0;
 }
 var PublishedJournalReplay = class {
   file;
+  ownerSessionId;
   projected = [];
   definitions = /* @__PURE__ */ new Map();
-  constructor(file) {
+  branches;
+  constructor(file, entries, ownerSessionId) {
     this.file = file;
+    this.ownerSessionId = ownerSessionId;
+    if (entries.some(({ value }) => legacyCustom(value) || legacyBrowserResult(value))) {
+      this.branches = new BrowserConversionBranches(entries.map(({ value }) => value.parentId));
+    }
+  }
+  parentProjection(parentId) {
+    return typeof parentId === "string" ? this.branches?.get(parentId) ?? emptyProjection() : emptyProjection();
   }
   async project(entries) {
     for (const entry of entries) {
@@ -32845,25 +33452,35 @@ var PublishedJournalReplay = class {
   }
   async projectEntry(entry) {
     const { value } = entry;
-    const definition = isRecord(value.data) && isRecord(value.data.snapshot) ? value.data.snapshot.id : void 0;
-    if (typeof definition === "string") {
-      if (this.definitions.has(definition)) {
+    const parent = this.parentProjection(value.parentId);
+    const legacy = legacyCustom(value) || legacyBrowserResult(value);
+    if (!legacy && !replayRelevant(value)) {
+      this.advance(value, parent);
+      return;
+    }
+    const body = await projectJson(readRange(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);
+    this.projected.push(record ? projectedRecord(value, record) : candidate);
+  }
+  normalizeRecord(candidate, parent) {
+    const conversion = this.branches ? convertLegacyBrowserEntry(candidate, parent, this.ownerSessionId) : void 0;
+    this.advance(candidate, conversion?.projection ?? parent);
+    return conversion?.record ?? getBrowserRecord(candidate);
+  }
+  rememberSnapshot(entry, legacy, snapshot) {
+    if (isRecord(snapshot) && typeof snapshot.id === "string") {
+      if (this.definitions.has(snapshot.id)) {
         throw new Error("Browser snapshot identity is defined more than once on this ancestry.");
       }
-      this.definitions.set(definition, entry);
+      this.definitions.set(snapshot.id, { entry, legacy });
     }
-    if (legacyCustom(value) || legacyBrowserResult(value)) {
-      throw new Error("This session contains legacy browser records. Convert a stopped separate copy with npm exec --package pi-agent-browser-native -- pi-agent-browser-convert before resuming browser work; the original journal is retained.");
-    }
-    if (!replayRelevant(value, definition)) {
-      return;
+  }
+  advance(value, projection) {
+    if (typeof value.id === "string") {
+      this.branches?.advance(value.id, value.parentId, projection);
     }
-    const fields = value.customType === BROWSER_TRANSITION_ENTRY || value.type === "message" ? [
-      ["data", "event"],
-      ["data", "snapshot", "id"]
-    ] : [["data"]];
-    const body = await projectJson(readRange(this.file, entry), fields);
-    this.projected.push({ ...value, ...body });
   }
   async resolveWinningDefinitions(physical) {
     const { SessionPageState: SessionPageState2 } = await Promise.resolve().then(() => (init_session_page_state(), session_page_state_exports));
@@ -32879,24 +33496,27 @@ var PublishedJournalReplay = class {
     return this.projected;
   }
   async resolveDefinition(id) {
-    const entry = this.definitions.get(id);
-    if (!entry) {
+    const definition = this.definitions.get(id);
+    if (!definition) {
       throw new Error(`Browser snapshot ${id} has no ancestral definition; inspect and take a fresh snapshot.`);
     }
-    const body = await projectJson(readRange(this.file, entry), [["data", "snapshot"]], Infinity);
+    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 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) || !isRecord(body?.data)) {
+    if (!isRecord(destination) || !isRecord(destination.data)) {
       throw new Error("Winning browser snapshot could not be read.");
     }
-    destination.data.snapshot = body.data.snapshot;
-    if (!isRecord(body.data.snapshot) || body.data.snapshot.id !== id) {
+    destination.data.snapshot = resolved;
+    if (!isRecord(resolved) || resolved.id !== id) {
       throw new Error("Winning browser snapshot identity is invalid.");
     }
-    snapshotFromDefinition(body.data.snapshot);
+    snapshotFromDefinition(resolved);
   }
 };
-function replayRelevant(value, definition) {
-  return value.type === "custom" && typeof value.customType === "string" && REPLAY_CUSTOM_TYPES.has(value.customType) || isRecord(value.data) && isRecord(value.data.event) || definition !== void 0;
+function replayRelevant(value) {
+  return value.type === "custom" && typeof value.customType === "string" && REPLAY_CUSTOM_TYPES.has(value.customType) || isRecord(value.data) && isRecord(value.data.event) || isRecord(value.data) && isRecord(value.data.snapshot) && value.data.snapshot.id !== void 0;
 }
 async function verifyCapturedFile(file, path, captured) {
   const current = await file.stat();
@@ -32939,8 +33559,9 @@ async function readBrowserEntries(manager, physical = false) {
     const metadata = await scanJournalMetadata(file, captured.size);
     validateJournalHeader(metadata, manager.getHeader()?.id ?? manager.getSessionId());
     const records = metadata.filter((entry) => entry.value.type !== "session");
-    const replay = new PublishedJournalReplay(file);
-    await replay.project(physical ? records : branchEntries(records, leaf));
+    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);
     return entries;
@@ -33432,14 +34053,14 @@ function artifactKind(path) {
   }
   return void 0;
 }
-function intentClause(context) {
-  return context.split(CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context;
+function intentClause(context2) {
+  return context2.split(CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context2;
 }
-function trailingClause(context) {
-  return context.split(CLAUSE_BOUNDARY_PATTERN)[0] ?? context;
+function trailingClause(context2) {
+  return context2.split(CLAUSE_BOUNDARY_PATTERN)[0] ?? context2;
 }
-function hasOutputIntent(context) {
-  const clause = intentClause(context).replace(/\[[^\]\r\n]*\]\(\s*$/, "").replace(/[([{"'`]+\s*$/, "");
+function hasOutputIntent(context2) {
+  const clause = intentClause(context2).replace(/\[[^\]\r\n]*\]\(\s*$/, "").replace(/[([{"'`]+\s*$/, "");
   const match = clause.match(OUTPUT_INTENT_PATTERN) ?? clause.match(COLON_OUTPUT_INTENT_PATTERN);
   if (!match) {
     return false;
@@ -33451,8 +34072,8 @@ function hasOutputIntent(context) {
   }
   return governingPrefix.trim().length === 0 || AFFIRMATIVE_PREFIX_PATTERN.test(governingPrefix.trim()) || AFFIRMATIVE_LEAD_IN_PATTERN.test(governingPrefix);
 }
-function stripListPrefix(context) {
-  return context.replace(LIST_PREFIX_PATTERN, "");
+function stripListPrefix(context2) {
+  return context2.replace(LIST_PREFIX_PATTERN, "");
 }
 function pathMatches(line) {
   PATH_PATTERN.lastIndex = 0;
@@ -33499,10 +34120,10 @@ ${localContext}`;
     }
     return localContext;
   }
-  selectGroup(direct, priorLine, context) {
+  selectGroup(direct, priorLine, context2) {
     if (direct) {
       const group = this.nextGroup++;
-      this.groupOptional.set(group, this.input.recordingOptional || OPTIONAL_RECORDING_PATTERN.test(intentClause(context)));
+      this.groupOptional.set(group, this.input.recordingOptional || OPTIONAL_RECORDING_PATTERN.test(intentClause(context2)));
       return group;
     }
     if (priorLine) {
@@ -33512,30 +34133,30 @@ ${localContext}`;
     }
     return void 0;
   }
-  excludesCandidate(path, context, trailing, direct) {
+  excludesCandidate(path, context2, trailing, direct) {
     if (/(?:^|[\\/])pi-(?:attachment|clipboard|paste|upload)-/i.test(path)) {
       return true;
     }
-    return direct && (REFERENCE_INTENT_PATTERN.test(intentClause(context)) || EXPLICIT_OPTIONAL_PATTERN.test(intentClause(context)) || EXPLICIT_OPTIONAL_PATTERN.test(trailing));
+    return direct && (REFERENCE_INTENT_PATTERN.test(intentClause(context2)) || EXPLICIT_OPTIONAL_PATTERN.test(intentClause(context2)) || EXPLICIT_OPTIONAL_PATTERN.test(trailing));
   }
-  continuesPriorLine(index, kind, context) {
-    return index === 0 && this.isPathList && kind === this.input.continuation?.kind && LIST_CONNECTOR_PATTERN.test(context);
+  continuesPriorLine(index, kind, context2) {
+    return index === 0 && this.isPathList && kind === this.input.continuation?.kind && LIST_CONNECTOR_PATTERN.test(context2);
   }
-  continuesSameLine(kind, context) {
-    return kind === this.previousKind && this.previousGroup !== void 0 && LIST_CONNECTOR_PATTERN.test(context);
+  continuesSameLine(kind, context2) {
+    return kind === this.previousKind && this.previousGroup !== void 0 && LIST_CONNECTOR_PATTERN.test(context2);
   }
   collectCandidate(index) {
     const { end, path, start } = this.input.matches[index];
     const localContext = stripListPrefix(this.input.line.slice(this.previousPathEnd, start));
-    const context = this.candidateContext(index, localContext);
+    const context2 = this.candidateContext(index, localContext);
     const kind = artifactKind(path);
-    const direct = hasOutputIntent(context);
+    const direct = hasOutputIntent(context2);
     const sameLine = this.continuesSameLine(kind, localContext);
     const priorLine = this.continuesPriorLine(index, kind, localContext);
-    const group = !direct && sameLine ? this.previousGroup : this.selectGroup(direct, priorLine, context);
+    const group = !direct && sameLine ? this.previousGroup : this.selectGroup(direct, priorLine, context2);
     const trailing = trailingClause(this.input.line.slice(end, this.input.matches[index + 1]?.start ?? this.input.line.length));
     this.previousPathEnd = end;
-    if (kind === void 0 || group === void 0 || this.excludesCandidate(path, context, trailing, direct)) {
+    if (kind === void 0 || group === void 0 || this.excludesCandidate(path, context2, trailing, direct)) {
       this.previousGroup = void 0;
       this.previousKind = void 0;
       return;
@@ -34631,9 +35252,9 @@ function registerCoreTools(pi, options, execute) {
     parameters: AGENT_BROWSER_CODE_PARAMS,
     execute: async (id, params, signal, onUpdate, ctx) => finalizeAgentBrowserNativeResult(await options.executeCode(id, params, signal, onUpdate, ctx), params),
     executionMode: options.executionMode,
-    renderCall(args, theme, context) {
-      const text3 = context.lastComponent instanceof Text2 ? context.lastComponent : new Text2("", 0, 0);
-      text3.setText(formatAgentBrowserRenderCall(args, theme, context.expanded));
+    renderCall(args, theme, context2) {
+      const text3 = context2.lastComponent instanceof Text2 ? context2.lastComponent : new Text2("", 0, 0);
+      text3.setText(formatAgentBrowserRenderCall(args, theme, context2.expanded));
       return text3;
     },
     renderResult: options.renderResult
@@ -38415,7 +39036,7 @@ async function runAgentBrowserScript(options) {
 
 // dist/extensions/agent-browser/lib/orchestration/script-mode.js
 import { stat as stat13 } from "node:fs/promises";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 init_parsing();
 init_browser_transcript();
 init_runtime();
@@ -38623,7 +39244,7 @@ function appendScriptSessionLease(pi, sessionName, cleanup, ownerSessionId) {
     event: {
       version: 1,
       phase: "state",
-      operationId: randomUUID7(),
+      operationId: randomUUID8(),
       toolCallId: "cleanup",
       commandIndex: 0,
       isError: cleanup !== "closed",
@@ -38724,7 +39345,7 @@ var BrowserCodeOutput = class {
     }
     return run.failureCategory ?? (run.rejectedCallCount > 0 ? "validation-error" : void 0);
   }
-  observation(run, context, output) {
+  observation(run, context2, output) {
     const failureCategory3 = this.failureCategory(run, output.error);
     const success = run.ok && failureCategory3 === void 0;
     return {
@@ -38733,7 +39354,7 @@ var BrowserCodeOutput = class {
       failureCategory: failureCategory3,
       data: output.data,
       error: output.error ?? (run.error !== void 0 && run.error.length > 0 ? redactSensitiveText(run.error) : void 0),
-      ...context,
+      ...context2,
       codeRun: {
         callCount: run.callCount,
         emitCount: run.emitCount,
@@ -39520,7 +40141,7 @@ import { Text as Text3 } from "@earendil-works/pi-tui";
 
 // dist/extensions/agent-browser/lib/orchestration/extension-observation.js
 init_browser_transcript();
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 init_runtime();
 init_argv_grammar();
 init_parsing();
@@ -39547,9 +40168,9 @@ function observedResult(observation2, manifest) {
 var ObservationPublication = class {
   resources;
   context;
-  constructor(resources, context) {
+  constructor(resources, context2) {
     this.resources = resources;
-    this.context = context;
+    this.context = context2;
   }
   async render(result, params) {
     const details = observationDetails(result);
@@ -39588,7 +40209,7 @@ var ObservationPublication = class {
       event: {
         version: 1,
         phase: "state",
-        operationId: randomUUID8(),
+        operationId: randomUUID9(),
         toolCallId: "observation",
         commandIndex: 0,
         isError: observation2.result.isError === true,
@@ -39623,8 +40244,8 @@ var ObservationPublication = class {
     return this.resources.queue.run(() => this.publish(observation2));
   }
 };
-function finalizeObservation(resources, result, params, context) {
-  return new ObservationPublication(resources, context).run(result, params);
+function finalizeObservation(resources, result, params, context2) {
+  return new ObservationPublication(resources, context2).run(result, params);
 }
 
 // dist/extensions/agent-browser/lib/orchestration/extension-code.js
@@ -39641,7 +40262,7 @@ init_batch_stdin();
 init_launch_scoped_flags();
 init_process_environment();
 init_runtime();
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir4 } from "node:os";
 import { join as join28, resolve as resolve13 } from "node:path";
 
@@ -40141,12 +40762,25 @@ function rootRestoreKey(policy, status, restoreKey) {
   }
   return status === "inactive" ? policy.rootName : void 0;
 }
-async function withRootBrowserLaunch(policy, browserRun, signal) {
+function rootLaunchEnvironment(policy, daemon) {
+  const bootstrap = daemon.status === "inactive";
+  const restore = rootRestoreKey(policy, daemon.status, daemon.status === "active" ? daemon.restoreKey : void 0);
+  const profile = bootstrapProfile(policy, bootstrap);
+  const executablePath = bootstrapExecutable(policy, bootstrap);
+  return {
+    ...restore !== void 0 ? { AGENT_BROWSER_RESTORE: restore } : {},
+    ...profile !== void 0 ? { AGENT_BROWSER_PROFILE: profile } : {},
+    ...executablePath !== void 0 ? { AGENT_BROWSER_EXECUTABLE_PATH: executablePath } : {}
+  };
+}
+async function withRootBrowserLaunch(policy, browserRun, signal, includeGeneration = false) {
+  const namespace = cliValue(policy.input.toolArgs, "--namespace") ?? policy.namespace;
   const daemon = await inspectManagedSessionDaemon({
     cwd: policy.cwd,
     signal,
     sessionName: policy.rootName,
-    namespace: cliValue(policy.input.toolArgs, "--namespace") ?? policy.namespace,
+    namespace,
+    includeGeneration,
     timeoutMs: 5e3
   });
   if (daemon.status === "missing-binary") {
@@ -40171,15 +40805,11 @@ async function withRootBrowserLaunch(policy, browserRun, signal) {
       validationError: "qa.attached requires an active attached session. Open the root browser first, or select an existing native session."
     });
   }
-  const bootstrap = daemon.status === "inactive";
-  const restore = rootRestoreKey(policy, daemon.status, daemon.status === "active" ? daemon.restoreKey : void 0);
-  const profile = bootstrapProfile(policy, bootstrap);
-  const executablePath = bootstrapExecutable(policy, bootstrap);
-  return withAgentBrowserProcessEnvironment({
-    ...restore !== void 0 ? { AGENT_BROWSER_RESTORE: restore } : {},
-    ...profile !== void 0 ? { AGENT_BROWSER_PROFILE: profile } : {},
-    ...executablePath !== void 0 ? { AGENT_BROWSER_EXECUTABLE_PATH: executablePath } : {}
-  }, () => withChromeStartupArgs(bootstrap || policy.configuredChromeLaunch ? policy.chromeStartupArgs : void 0, () => browserRun(bootstrap)));
+  return withAgentBrowserProcessEnvironment(rootLaunchEnvironment(policy, daemon), () => withChromeStartupArgs(daemon.status === "inactive" || policy.configuredChromeLaunch ? policy.chromeStartupArgs : void 0, () => browserRun({
+    identity: getAgentBrowserSessionIdentityKey(policy.rootName, namespace),
+    daemon,
+    generationInspected: includeGeneration
+  })));
 }
 
 // dist/extensions/agent-browser/lib/orchestration/native-session-defaults.js
@@ -40190,7 +40820,7 @@ function requestsConnection(tokens, stdin) {
   return tokens[0] === "connect" || getUpstreamEffectiveBatchSteps(tokens, stdin).some((step) => requestsConnection(step));
 }
 function rootBrowserSessionName(rootSessionId) {
-  return `pi-root-${createHash5("sha256").update(rootSessionId).digest("hex").slice(0, 24)}`;
+  return `pi-root-${createHash6("sha256").update(rootSessionId).digest("hex").slice(0, 24)}`;
 }
 function nativeBooleanOverrides(args) {
   const overrides = [];
@@ -40213,20 +40843,20 @@ var NativeSessionCall = class {
   browserCommand;
   rootFallback;
   identity = {};
-  constructor(input, context, runner) {
+  constructor(input, context2, runner) {
     this.input = input;
-    this.context = context;
+    this.context = context2;
     this.runner = runner;
     const configArg = scanUpstreamGlobalFlagOccurrences([...input.toolArgs], "--config").at(0);
     this.configPath = configArg?.value ?? this.env.AGENT_BROWSER_CONFIG;
-    this.configPaths = this.configPath !== void 0 ? [resolve13(context.cwd, this.configPath)] : [
+    this.configPaths = this.configPath !== void 0 ? [resolve13(context2.cwd, this.configPath)] : [
       join28(homedir4(), ".agent-browser", "config.json"),
-      join28(context.cwd, "agent-browser.json")
+      join28(context2.cwd, "agent-browser.json")
     ];
-    this.rootName = context.root === void 0 ? void 0 : rootBrowserSessionName(context.root.id);
+    this.rootName = context2.root === void 0 ? void 0 : rootBrowserSessionName(context2.root.id);
     this.browserCommand = input.kind !== "electron" && needsManagedSession(parseArgvDescriptor([...input.toolArgs]), input.toolStdin);
     const session = extractExplicitSessionName([...input.toolArgs]);
-    this.rootFallback = context.root !== void 0 && this.env.AGENT_BROWSER_SESSION === void 0 && (session === void 0 || session === this.rootName) && this.browserCommand;
+    this.rootFallback = context2.root !== void 0 && this.env.AGENT_BROWSER_SESSION === void 0 && (session === void 0 || session === this.rootName) && this.browserCommand;
   }
   attachment() {
     const autoConnect = getBooleanFlagValue([...this.input.toolArgs], "--auto-connect") ?? (isUpstreamEnvFlagEnabled(this.env.AGENT_BROWSER_AUTO_CONNECT) || this.identity.autoConnect === true);
@@ -40336,7 +40966,7 @@ var NativeSessionCall = class {
     return withAgentBrowserProcessEnvironment(this.executionEnvironment(args, session, namespace), () => this.runner(input, defaults), nativeBooleanOverrides(args));
   }
   rootLaunchRunner(policy) {
-    return (browserRun, signal = this.context.signal) => withRootBrowserLaunch(policy, browserRun, signal);
+    return (browserRun, signal = this.context.signal, includeGeneration) => withRootBrowserLaunch(policy, browserRun, signal, includeGeneration);
   }
   async run() {
     this.identity = await loadNativeIdentity(this.configPaths, {
@@ -40348,11 +40978,11 @@ var NativeSessionCall = class {
     return this.input.kind === "electron" ? this.runElectron() : this.runBrowser();
   }
 };
-async function withNativeSessionDefaults(input, context, run) {
+async function withNativeSessionDefaults(input, context2, run) {
   if (isPlainTextInspectionArgs([...input.toolArgs])) {
     return run(input);
   }
-  return new NativeSessionCall(input, context, run).run();
+  return new NativeSessionCall(input, context2, run).run();
 }
 
 // dist/extensions/agent-browser/lib/execution-cwd.js
@@ -41101,7 +41731,7 @@ init_managed_session_policy_lock();
 
 // dist/extensions/agent-browser/lib/orchestration/extension-host-run.js
 init_browser_transcript();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 init_runtime();
 init_argv_grammar();
 init_parsing();
@@ -41135,7 +41765,7 @@ var ElectronHostTransaction = class {
     this.workingPageState = this.runtime.sessions.pages.fork();
     this.priorPages = this.workingPageState.views();
     this.priorManifest = this.runtime.artifacts.manifest;
-    this.operationId = randomUUID9();
+    this.operationId = randomUUID10();
     this.launchId = this.call.compiledElectron && "launchId" in this.call.compiledElectron ? this.call.compiledElectron.launchId : void 0;
     this.selected = this.launchId !== void 0 && this.launchId !== "" ? [this.electronHostLaunchRecords.get(this.launchId)].filter((record) => record !== void 0) : getActiveElectronRecords(this.electronHostLaunchRecords);
     this.keys = this.selectedKeys();
@@ -41451,13 +42081,14 @@ init_runtime();
 init_runtime();
 init_argv_grammar();
 init_process();
+init_command_taxonomy();
 init_wait_timeouts();
 init_process_environment();
 init_managed_session_policy_lock();
 
 // dist/extensions/agent-browser/lib/orchestration/extension-command-run.js
 init_browser_transcript();
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 init_runtime();
 init_argv_grammar();
 init_argv_descriptor();
@@ -42369,7 +43000,7 @@ function prepareBrowserCommand(runtime, call, executionSignal) {
   const priorPages = workingPageState.views();
   const sessionPageStateUpdate = workingPageState.beginUpdate();
   const selectedPlan = selectCommandPlan(browserRunState, call);
-  const operationId = randomUUID11();
+  const operationId = randomUUID12();
   const selectedKey = getAgentBrowserSessionIdentityKey(selectedPlan.sessionName ?? "default", selectedPlan.namespace);
   browserRunState.confirmationPolicyIdentity = selectedKey;
   const confirmActions = getAgentBrowserProcessEnvironment().AGENT_BROWSER_CONFIRM_ACTIONS;
@@ -42433,7 +43064,7 @@ function captureDispatch(attachedSessionKeys, call, prepared) {
 async function dispatchBrowserCommand(timeouts, call, prepared, dispatch) {
   try {
     return await runAgentBrowserTool({
-      daemonInactive: dispatch.daemonInactive,
+      initialDaemonObservation: dispatch.initialDaemonObservation,
       ctx: call.ctx,
       cwd: call.browserCwd,
       operationCwd: call.operationCwd,
@@ -42463,7 +43094,7 @@ async function dispatchBrowserCommand(timeouts, call, prepared, dispatch) {
     };
   }
 }
-async function runBrowserCommand(runtime, call, daemonInactive, executionSignal = call.signal) {
+async function runBrowserCommand(runtime, call, initialDaemonObservation, executionSignal = call.signal) {
   const prepared = prepareBrowserCommand(runtime, call, executionSignal);
   const admissionFailure = await admitBrowserCommand(runtime.pi, runtime.sessions.pages, call, prepared);
   if (admissionFailure) {
@@ -42472,7 +43103,7 @@ async function runBrowserCommand(runtime, call, daemonInactive, executionSignal
   const dispatch = captureDispatch(runtime.sessions.attached, call, prepared);
   const result = await dispatchBrowserCommand({ close: runtime.implicitSessionCloseTimeoutMs, idle: runtime.implicitSessionIdleTimeoutMs }, call, prepared, {
     ...dispatch,
-    daemonInactive
+    initialDaemonObservation
   });
   const completion = new BrowserCommandResult(runtime, call, prepared, { ...dispatch, result });
   completion.reconcileNativeIdentity();
@@ -42516,7 +43147,7 @@ var BrowserCommandCoordinator = class {
     };
   }
   execute(signal) {
-    return this.call.withLaunchDefaults ? this.call.withLaunchDefaults((inactive) => runBrowserCommand(this.runtime, this.call, inactive, signal), signal) : runBrowserCommand(this.runtime, this.call, void 0, signal);
+    return this.call.withLaunchDefaults ? this.call.withLaunchDefaults((observation2) => runBrowserCommand(this.runtime, this.call, observation2, signal), signal, !isCloseCommand(this.plan.commandInfo.command) && (this.runtime.sessions.pages.get(this.key).refSnapshot?.refIds.length ?? 0) > 0) : runBrowserCommand(this.runtime, this.call, void 0, signal);
   }
   async preflightAndExecute(signal) {
     const error = getArtifactPreflightValidationError({
@@ -43122,15 +43753,15 @@ function executeCode(runtime, invocation) {
 
 // dist/extensions/agent-browser/lib/orchestration/extension-tool-boundary.js
 function registerBrowserTools(runtime) {
-  const renderResult = (result, options, theme, context) => {
-    const component = context.lastComponent instanceof AgentBrowserResultComponent ? context.lastComponent : new AgentBrowserResultComponent();
-    component.setResult(result, options, theme, context.isError);
+  const renderResult = (result, options, theme, context2) => {
+    const component = context2.lastComponent instanceof AgentBrowserResultComponent ? context2.lastComponent : new AgentBrowserResultComponent();
+    component.setResult(result, options, theme, context2.isError);
     return component;
   };
   const renderers = {
-    renderCall: (args, theme, context) => {
-      const text3 = context.lastComponent instanceof Text3 ? context.lastComponent : new Text3("", 0, 0);
-      text3.setText(formatAgentBrowserRenderCall(args, theme, context.expanded));
+    renderCall: (args, theme, context2) => {
+      const text3 = context2.lastComponent instanceof Text3 ? context2.lastComponent : new Text3("", 0, 0);
+      text3.setText(formatAgentBrowserRenderCall(args, theme, context2.expanded));
       return text3;
     },
     renderResult