pi-agent-browser-native 0.8.3 → 0.9.1

package/dist/extensions/agent-browser/lib/argv-grammar.js

@@ -38,7 +38,7 @@ export const GLOBAL_VALUE_FLAGS = [
     "--idle-timeout",
     "--input-mode",
 ];
-export const COMMAND_VALUE_FLAGS = [
+const COMMAND_VALUE_FLAGS = [
     "--allowed-origins",
     "--baseline",
     "--body",
@@ -79,7 +79,7 @@ export const COMMAND_VALUE_FLAGS = [
     "--password",
     "--wait-until",
 ];
-export const OPTIONAL_GLOBAL_VALUE_FLAGS = new Set(["--restore"]);
+const OPTIONAL_GLOBAL_VALUE_FLAGS = new Set(["--restore"]);
 export const VALUE_FLAGS = new Set([...GLOBAL_VALUE_FLAGS, ...COMMAND_VALUE_FLAGS]);
 export const PREVALIDATED_VALUE_FLAGS = new Set(GLOBAL_VALUE_FLAGS);
 export const GLOBAL_VALUE_FLAGS_ALLOWING_DASH_VALUE = new Set(["--args", "--session"]);
@@ -246,7 +246,7 @@ export function extractRequestedRestoreKey(args, sessionName, envValue) {
     }
     return restoreKey;
 }
-export function getFlagName(token) {
+function getFlagName(token) {
     return token.split("=", 1)[0] ?? token;
 }
 export function isNonFlagToken(token) {

package/dist/extensions/agent-browser/lib/browser-journal.js

@@ -241,14 +241,7 @@ export async function readBrowserEntries(manager, physical = false) {
         const header = metadata.find(entry => entry.value.type === "session");
         if (header?.value.id !== (manager.getHeader()?.id ?? manager.getSessionId()))
             throw new Error("Pi session journal identity does not match the active session.");
-        const publicManager = manager;
         const selected = physical ? metadata.filter(entry => entry.value.type !== "session") : branchEntries(metadata.filter(entry => entry.value.type !== "session"), leaf);
-        if (publicManager.iterateEntryMetadata) {
-            const native = new Map([...publicManager.iterateEntryMetadata(physical ? {} : { branchFrom: leaf })].map(entry => [entry.id, entry.parentId]));
-            for (const entry of selected)
-                if (typeof entry.value.id !== "string" || native.get(entry.value.id) !== entry.value.parentId)
-                    throw new Error("Published browser journal ancestry differs from the native selected boundary.");
-        }
         const projected = [];
         const definitions = new Map();
         for (const entry of selected) {
@@ -285,9 +278,7 @@ export async function readBrowserEntries(manager, physical = false) {
                 throw new Error(`Browser snapshot ${id} has no ancestral definition; inspect and take a fresh snapshot.`);
             // ponytail: a requested individual snapshot must fit its consumer's memory. Metadata
             // scans skip unlimited unrelated values; upgrade with native per-value paging if needed.
-            const native = publicManager.getEntryMetadata && typeof entry.value.id === "string" ? manager.getEntry(entry.value.id) : undefined;
-            const body = native && isRecord(native) && isRecord(native.data) ? { data: native.data }
-                : await projectJson(readRange(file, entry), [["data", "snapshot"]], Infinity);
+            const body = await projectJson(readRange(file, entry), [["data", "snapshot"]], Infinity);
             const destination = projected.find(candidate => isRecord(candidate) && candidate.id === entry.value.id);
             if (!isRecord(destination) || !isRecord(destination.data) || !isRecord(body?.data))
                 throw new Error("Winning browser snapshot could not be read.");
@@ -342,13 +333,22 @@ export function hasPublishedBrowserJournal(manager) {
 /** Capture before waiting: native selection precedes sequential session_tree handlers. */
 export function captureBrowserBranch(manager, isGenerationCurrent) {
     const sessionId = manager.getSessionId();
-    const branch = { sessionId, anchorId: manager.getLeafId(), isCurrent() {
+    let anchorId = manager.getLeafId();
+    let validatedAnchor;
+    let validatedLeaf;
+    const branch = { sessionId, anchorId, isCurrent() {
             if (!isGenerationCurrent() || manager.getSessionId() !== sessionId)
                 return false;
+            if (branch.anchorId !== anchorId) {
+                validatedAnchor = validatedLeaf = undefined;
+                anchorId = branch.anchorId;
+            }
             let leaf = manager.getLeafId();
             // Empty selection is not a universal ancestor of other independent roots.
             let current = branch.anchorId === null && leaf === null;
             const seen = new Set();
+            let selected;
+            let anchor;
             while (leaf !== null) {
                 if (typeof leaf !== "string" || seen.has(leaf))
                     throw new Error("Selected Pi journal ancestry is invalid or cyclic.");
@@ -356,10 +356,31 @@ export function captureBrowserBranch(manager, isGenerationCurrent) {
                 const entry = manager.getEntry(leaf);
                 if (!entry || entry.id !== leaf || entry.parentId !== null && typeof entry.parentId !== "string")
                     throw new Error("Selected Pi journal ancestry is incomplete.");
-                if (leaf === branch.anchorId)
+                selected ??= { entry, parentId: entry.parentId };
+                const cached = leaf === branch.anchorId ? validatedAnchor : leaf === validatedLeaf?.entry.id ? validatedLeaf : undefined;
+                if (cached) {
+                    // Keep the native indexed lookup: it also refreshes fork journal identity.
+                    if (cached.entry === entry && cached.parentId === entry.parentId) {
+                        current = true;
+                        break;
+                    }
+                    validatedAnchor = validatedLeaf = undefined;
+                }
+                if (leaf === branch.anchorId) {
                     current = true;
+                    anchor = { entry, parentId: entry.parentId };
+                }
                 leaf = entry.parentId;
             }
+            // Native entries/parents are append-only. Cache only after validating through
+            // the root (or an already validated endpoint), never merely on leaf === anchor.
+            // ponytail: behind-host mutation of an old ancestor without native reseed or
+            // generation change is outside this contract; durable file proofs
+            // remain in replay/append. Upgrade if Pi exposes a separate ancestry revision.
+            if (current && selected) {
+                validatedAnchor = anchor ?? validatedAnchor;
+                validatedLeaf = selected;
+            }
             return current;
         } };
     return branch;

package/dist/extensions/agent-browser/lib/browser-transcript.js

@@ -4,7 +4,7 @@ import { buildPageTransitionRefSnapshotInvalidation, normalizeSessionTabTarget,
 import { getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, isSessionArtifactManifest } from "./results/artifact-manifest.js";
 import { extractAgentBrowserLifecycle } from "./results/presentation/common.js";
 export const BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
-export const BROWSER_EVENT_VERSION = 1;
+const BROWSER_EVENT_VERSION = 1;
 export const BROWSER_RESULT_TOOLS = new Set([
     "agent_browser", "agent_browser_code", "agent_browser_action", "agent_browser_qa", "agent_browser_electron",
     "agent_browser_source", "agent_browser_network_source",

package/dist/extensions/agent-browser/lib/command-taxonomy.js

@@ -295,9 +295,6 @@ function getCommandCapability(command) {
 function hasCommandCapability(command, capability) {
     return getCommandCapability(command)?.[capability] === true;
 }
-export function normalizeCommandName(command) {
-    return getCommandCapability(command)?.command ?? command;
-}
 export function isCloseCommand(command) {
     return hasCommandCapability(command, "closesSession");
 }

package/dist/extensions/agent-browser/lib/config-policy.js

@@ -229,19 +229,6 @@ function validateBrowserDefaultProfile(value, path, errors) {
     }
     return { name, policy: /** @type {BrowserDefaultProfilePolicy} */ (policy) };
 }
-/** @param {string} rawValue */
-export function isPlaintextCredentialValue(rawValue) {
-    const trimmed = rawValue.trim();
-    return Boolean(trimmed) && !trimmed.startsWith("!") && !trimmed.startsWith("$");
-}
-/**
- * @param {string} rawValue
- * @param {WebSearchProvider} provider
- */
-export function isProjectSafeCredentialValueForProvider(rawValue, provider) {
-    void provider;
-    return rawValue.trim().length > 0;
-}
 /**
  * @param {unknown} value
  * @param {string} path

package/dist/extensions/agent-browser/lib/config.js

@@ -1,53 +1,8 @@
 import { exec as execCallback } from "node:child_process";
-import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
-import { SECRET_COMMAND_TIMEOUT_MS, buildAgentBrowserConfigState, getAgentBrowserConfigPaths, getWebSearchCredentialSource, getWebSearchProviderOrder, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, } from "./config-policy.js";
-export { AGENT_BROWSER_CONFIG_ENV, BRAVE_API_KEY_ENV, CONFIG_RELATIVE_PATH, DEFAULT_WEB_SEARCH_PROVIDER, EXA_API_KEY_ENV, EXA_SEARCH_TYPES, GLOBAL_CONFIG_RELATIVE_PATH, SECRET_COMMAND_TIMEOUT_MS, WEB_SEARCH_PROVIDER_CONFIG_KEYS, WEB_SEARCH_PROVIDER_DESCRIPTORS, WEB_SEARCH_PROVIDER_ENV_VARS, WEB_SEARCH_PROVIDERS, buildAgentBrowserConfigState, buildWebSearchCredentialSources, canRegisterWebSearchTool, classifyCredentialSource, formatBrowserExecutableStatus, formatBrowserProfileStatus, getAgentBrowserConfigPaths, getCredentialSourceSummary, getGlobalAgentBrowserConfigPath, getProjectAgentBrowserConfigPath, getWebSearchCredentialSource, getWebSearchProviderConfigKey, getWebSearchProviderDescriptor, getWebSearchProviderEnvVar, getWebSearchProviderLabel, getWebSearchProviderOrder, hasPotentialCredentialSource, isPlaintextCredentialValue, isProjectSafeCredentialValueForProvider, isWebSearchProvider, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, summarizeConfigFiles, validateAgentBrowserConfig, validateWebSearchProvider, } from "./config-policy.js";
+import { SECRET_COMMAND_TIMEOUT_MS, getWebSearchCredentialSource, getWebSearchProviderOrder, loadAgentBrowserConfigStateSync, resolveEnvInterpolations, } from "./config-policy.js";
+export { AGENT_BROWSER_CONFIG_ENV, BRAVE_API_KEY_ENV, CONFIG_RELATIVE_PATH, DEFAULT_WEB_SEARCH_PROVIDER, EXA_API_KEY_ENV, EXA_SEARCH_TYPES, GLOBAL_CONFIG_RELATIVE_PATH, SECRET_COMMAND_TIMEOUT_MS, WEB_SEARCH_PROVIDER_CONFIG_KEYS, WEB_SEARCH_PROVIDER_DESCRIPTORS, WEB_SEARCH_PROVIDER_ENV_VARS, WEB_SEARCH_PROVIDERS, buildAgentBrowserConfigState, buildWebSearchCredentialSources, canRegisterWebSearchTool, classifyCredentialSource, formatBrowserExecutableStatus, formatBrowserProfileStatus, getAgentBrowserConfigPaths, getCredentialSourceSummary, getGlobalAgentBrowserConfigPath, getProjectAgentBrowserConfigPath, getWebSearchCredentialSource, getWebSearchProviderConfigKey, getWebSearchProviderDescriptor, getWebSearchProviderEnvVar, getWebSearchProviderLabel, getWebSearchProviderOrder, hasPotentialCredentialSource, isWebSearchProvider, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, summarizeConfigFiles, validateAgentBrowserConfig, validateWebSearchProvider, } from "./config-policy.js";
 const exec = promisify(execCallback);
-async function readConfigLayer(path, scope, errors, warnings) {
-    let raw;
-    try {
-        raw = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-            return undefined;
-        }
-        errors.push(`Could not read ${scope} config ${path}: ${error instanceof Error ? error.message : String(error)}`);
-        return undefined;
-    }
-    return parseAgentBrowserConfigLayer(raw, path, scope, errors, warnings);
-}
-export async function loadAgentBrowserConfig(options = {}) {
-    const env = options.env ?? process.env;
-    const paths = getAgentBrowserConfigPaths({ cwd: options.cwd, env });
-    const includeProjectConfig = options.includeProjectConfig !== false;
-    const errors = [];
-    const warnings = [];
-    const layerCandidates = [
-        { path: paths.global, scope: "global" },
-        ...(includeProjectConfig ? [{ path: paths.project, scope: "project" }] : []),
-        ...(paths.override ? [{ path: paths.override, scope: "override" }] : []),
-    ];
-    const layers = [];
-    let mergedConfig = {};
-    for (const candidate of layerCandidates) {
-        const layer = await readConfigLayer(candidate.path, candidate.scope, errors, warnings);
-        if (!layer)
-            continue;
-        layers.push(layer);
-        mergedConfig = mergeAgentBrowserConfig(mergedConfig, layer.config);
-    }
-    return buildAgentBrowserConfigState({
-        env,
-        errors,
-        layers,
-        mergedConfig,
-        paths,
-        projectConfigIncluded: includeProjectConfig,
-        warnings,
-    });
-}
 export function loadAgentBrowserConfigSync(options = {}) {
     return loadAgentBrowserConfigStateSync(options);
 }
@@ -70,7 +25,7 @@ async function resolveCommandCredential(rawValue, signal) {
         throw new Error("Credential command failed without exposing command output. Check pi-agent-browser-config web-search status and the configured secret manager command.");
     }
 }
-export async function resolveCredentialSource(source, options = {}) {
+async function resolveCredentialSource(source, options = {}) {
     if (!source)
         return undefined;
     let value;

package/dist/extensions/agent-browser/lib/electron/launch.js

@@ -6,8 +6,8 @@ import { fetchCdpJson, parseCdpTargets, parseCdpVersion, } from "./cdp.js";
 import { discoverElectronApps, inspectElectronAppPath, inspectElectronExecutablePath, } from "./discovery.js";
 import { createSecureTempDirectory, preserveSecureTempDirectory } from "../temp.js";
 export const ELECTRON_LAUNCH_RECORD_VERSION = 1;
-export const ELECTRON_LAUNCH_DEFAULT_TIMEOUT_MS = 15_000;
-export const ELECTRON_LAUNCH_MAX_TIMEOUT_MS = 120_000;
+const ELECTRON_LAUNCH_DEFAULT_TIMEOUT_MS = 15_000;
+const ELECTRON_LAUNCH_MAX_TIMEOUT_MS = 120_000;
 const DEVTOOLS_ACTIVE_PORT_FILE = "DevToolsActivePort";
 export const ELECTRON_PROFILE_DIR_PREFIX = "electron-profile-";
 const ELECTRON_DEFAULT_APP_ARGS = ["--disable-extensions", "--no-first-run", "--no-default-browser-check"];
@@ -46,7 +46,7 @@ function policyEntryMatchesApp(entry, app) {
         return false;
     return appIdentifiers(app).some((identifier) => identifier.toLowerCase().includes(normalizedEntry));
 }
-export function evaluateElectronLaunchPolicy(options) {
+function evaluateElectronLaunchPolicy(options) {
     const denyEntry = options.deny?.find((entry) => policyEntryMatchesApp(entry, options.target));
     if (denyEntry) {
         return {
@@ -66,7 +66,7 @@ export function evaluateElectronLaunchPolicy(options) {
     }
     return undefined;
 }
-export async function resolveElectronLaunchTarget(options) {
+async function resolveElectronLaunchTarget(options) {
     if (options.appPath)
         return inspectElectronAppPath(options.appPath);
     if (options.executablePath)

package/dist/extensions/agent-browser/lib/execution-cwd.js

@@ -1,8 +1,6 @@
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
 import { isRecord } from "./parsing.js";
-import { getBrowserResultMessage } from "./browser-transcript.js";
-import { getAgentBrowserSessionIdentityKey } from "./argv-grammar.js";
 function isDirectoryOwner(source) {
     if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source))
         return true;
@@ -50,17 +48,3 @@ export function getBrowserCwdError(cwd) {
     }
     return `Browser launch directory is unavailable: ${cwd}. Restore that directory, or explicitly use sessionMode: "fresh" without --session, or --config from the selected execution directory. The existing browser was left untouched.`;
 }
-export function restoreManagedSessionCwd(branch, sessionName, namespace, fallback) {
-    const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
-    for (const entry of [...branch].reverse()) {
-        const message = getBrowserResultMessage(entry);
-        if (!message)
-            continue;
-        const details = message.details;
-        if (!isRecord(details) || typeof details.sessionName !== "string" || typeof details.managedSessionCwd !== "string" || !isAbsolute(details.managedSessionCwd))
-            continue;
-        if (getAgentBrowserSessionIdentityKey(details.sessionName, typeof details.namespace === "string" ? details.namespace : undefined) === key)
-            return details.managedSessionCwd;
-    }
-    return fallback;
-}

package/dist/extensions/agent-browser/lib/input-modes/params.js

@@ -1,9 +1,8 @@
 import { JsonSchema } from "../json-schema.js";
 import { StringEnum as localStringEnum } from "../string-enum-schema.js";
 import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS } from "../electron/discovery.js";
-import { AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
-export const AGENT_BROWSER_ADVANCED_TOOLS = ["action", "qa", "electron", "source", "network"];
-export const AGENT_BROWSER_CODE_MAX_TIMEOUT_MS = 300_000;
+import { AGENT_BROWSER_CODE_MAX_TIMEOUT_MS, AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
+const AGENT_BROWSER_ADVANCED_TOOLS = ["action", "qa", "electron", "source", "network"];
 function outputProperties(Type) {
     return {
         outputPath: Type.Optional(Type.String({ description: "Result-data path, separate from browser artifact paths.", minLength: 1 })),

package/dist/extensions/agent-browser/lib/input-modes/script.js

@@ -2,20 +2,34 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import which from "which";
 import { isRecord } from "../parsing.js";
 import { extractExplicitNamespace, extractExplicitSessionName, scanUpstreamGlobalFlagOccurrences } from "../argv-grammar.js";
 import { getUpstreamEffectiveBatchSteps } from "../orchestration/batch-stdin.js";
 import { extractUpstreamCommandTokens } from "../argv-descriptor.js";
 import { isCloseAllCommand } from "../command-taxonomy.js";
 import { redactSensitiveText, validateToolArgs } from "../runtime.js";
+import { AGENT_BROWSER_CODE_MAX_TIMEOUT_MS } from "./types.js";
 export const AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES = 64 * 1_024;
 export const AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS = 120_000;
 export const AGENT_BROWSER_SCRIPT_NAMESPACE = "";
-export const AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS = 300_000;
 export const AGENT_BROWSER_SCRIPT_MAX_CALLS = 25;
 export const AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES = 64 * 1_024;
 export const AGENT_BROWSER_SCRIPT_IPC_MESSAGE_MAX_BYTES = 1 * 1_024 * 1_024;
-export const AGENT_BROWSER_SCRIPT_IPC_CUMULATIVE_MAX_BYTES = 8 * 1_024 * 1_024;
+const AGENT_BROWSER_SCRIPT_IPC_CUMULATIVE_MAX_BYTES = 8 * 1_024 * 1_024;
+/**
+ * Resolve the Node runtime that hosts the permissioned code child. A Bun-compiled Pi binary
+ * points `process.execPath` at the pi executable, which rejects Node-only flags like
+ * `--permission`, so those hosts must spawn a real `node` from PATH instead.
+ */
+export function resolveScriptChildNodePath(options) {
+    if (options.runtime.bun === undefined)
+        return options.execPath;
+    const nodePath = options.whichNode();
+    if (nodePath === null)
+        throw new Error("agent_browser_code requires a `node` runtime on PATH when pi runs on a Bun binary.");
+    return nodePath;
+}
 function findPackageRoot(startDir) {
     let currentDir = startDir;
     for (;;) {
@@ -34,7 +48,7 @@ function resolveScriptWorkerPath() {
     return workerPath;
 }
 const SCRIPT_SESSION_NAME_PATTERN = /^piab-script-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-export function validateAgentBrowserScriptSource(input) {
+function validateAgentBrowserScriptSource(input) {
     if (typeof input !== "string")
         return { error: "script must be a string." };
     const bytes = Buffer.byteLength(input, "utf8");
@@ -175,8 +189,8 @@ export async function runAgentBrowserScript(options) {
         return buildFailedRun({ callCount: 0, emitCount: 0, error: compiled.error, failureCategory: "validation-error", rejectedCallCount: 0, steps: [] });
     }
     const timeoutMs = options.timeoutMs ?? AGENT_BROWSER_SCRIPT_DEFAULT_TIMEOUT_MS;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS) {
-        return buildFailedRun({ callCount: 0, emitCount: 0, error: `script timeoutMs must be between 1 and ${AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS}.`, failureCategory: "validation-error", rejectedCallCount: 0, steps: [] });
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > AGENT_BROWSER_CODE_MAX_TIMEOUT_MS) {
+        return buildFailedRun({ callCount: 0, emitCount: 0, error: `script timeoutMs must be between 1 and ${AGENT_BROWSER_CODE_MAX_TIMEOUT_MS}.`, failureCategory: "validation-error", rejectedCallCount: 0, steps: [] });
     }
     if (options.signal?.aborted) {
         return buildFailedRun({ aborted: true, callCount: 0, emitCount: 0, error: "Script execution was aborted.", failureCategory: "aborted", rejectedCallCount: 0, steps: [] });
@@ -189,7 +203,15 @@ export async function runAgentBrowserScript(options) {
         const message = error instanceof Error ? error.message : "Compiled script worker is missing.";
         return buildFailedRun({ callCount: 0, emitCount: 0, error: message, failureCategory: "missing-binary", rejectedCallCount: 0, steps: [] });
     }
-    const child = spawn(process.execPath, [
+    let childNodePath;
+    try {
+        childNodePath = resolveScriptChildNodePath({ runtime: { bun: process.versions.bun }, execPath: process.execPath, whichNode: () => which.sync("node", { nothrow: true }) });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "No Node runtime is available for the code child.";
+        return buildFailedRun({ callCount: 0, emitCount: 0, error: message, failureCategory: "missing-binary", rejectedCallCount: 0, steps: [] });
+    }
+    const child = spawn(childNodePath, [
         "--permission",
         "--max-old-space-size=64",
         workerPath,

package/dist/extensions/agent-browser/lib/input-modes/types.js

@@ -1,8 +1,8 @@
 export const DEFAULT_SESSION_MODE = "auto";
+export const AGENT_BROWSER_CODE_MAX_TIMEOUT_MS = 300_000;
 export const AGENT_BROWSER_SEMANTIC_ACTIONS = ["check", "click", "fill", "select"];
 export const AGENT_BROWSER_SEMANTIC_LOCATORS = ["alt", "label", "placeholder", "role", "testid", "text", "title"];
-export const AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS = 200;
-export const AGENT_BROWSER_JOB_STEP_ACTIONS = ["open", "click", "fill", "type", "select", "wait", "assertText", "assertUrl", "waitForDownload", "screenshot", "snapshot"];
+const AGENT_BROWSER_JOB_STEP_ACTIONS = ["open", "click", "fill", "type", "select", "wait", "assertText", "assertUrl", "waitForDownload", "screenshot", "snapshot"];
 export const AGENT_BROWSER_QA_LOAD_STATES = ["domcontentloaded", "load", "networkidle"];
 export const AGENT_BROWSER_ELECTRON_ACTIONS = ["list", "launch", "status", "cleanup", "probe"];
 export const AGENT_BROWSER_ELECTRON_HANDOFFS = ["connect", "tabs", "snapshot"];

package/dist/extensions/agent-browser/lib/managed-session-restore.js

@@ -82,9 +82,6 @@ const ownedManagedSessionStorage = new AsyncLocalStorage();
 export async function withOwnedManagedSessionContext(context, run) {
     return await ownedManagedSessionStorage.run(context, run);
 }
-export function getOwnedManagedSessionRestoreKey() {
-    return ownedManagedSessionStorage.getStore()?.restoreKey;
-}
 export function resolveOwnedManagedSessionContext(options) {
     const namespace = canonicalizeAgentBrowserNamespace(options.namespace);
     const currentNamespace = canonicalizeAgentBrowserNamespace(options.currentManagedSessionNamespace);
@@ -115,7 +112,7 @@ function hasExplicitConfigArg(args) {
 function closesBrowserSession(args) {
     return ["close", "exit", "quit"].includes(parseCommandInfo(args).command ?? "");
 }
-export function agentBrowserExplicitConfigIsPresent(parentEnv = getAgentBrowserProcessEnvironment(), args = []) {
+function agentBrowserExplicitConfigIsPresent(parentEnv = getAgentBrowserProcessEnvironment(), args = []) {
     return hasExplicitConfigArg(args) || hasUpstreamEnvValue(parentEnv, AGENT_BROWSER_CONFIG_ENV);
 }
 /** Caller-selected upstream config disables the wrapper's automatic restore injection without blocking that config. */

package/dist/extensions/agent-browser/lib/native-output.js

@@ -0,0 +1,46 @@
+import { JsonSchema } from "./json-schema.js";
+import { isRecord } from "./parsing.js";
+import { finalizeAgentBrowserFailure } from "./pi-tool-rendering.js";
+import { isPlainTextInspectionArgs } from "./runtime.js";
+import { projectAgentBrowserObservation, OBSERVATION_INLINE_MAX_CHARS } from "./results/presentation/content.js";
+export const AGENT_BROWSER_NAMESPACE = {
+    name: "browser",
+    description: "Browser commands, bounded browser code, advanced UI checks, Electron, and optional web search.",
+    instructions: "Use agent_browser for native commands and batch --bail for fixed sequences. Use agent_browser_code for a fresh bounded JS cell with a persistent browser. Enable advanced direct tools with agent_browser_tools before calling them. Check success and nextActions; structured imageObservations are capture metadata, not inline images. Optional web search is available only when configured. Full browser instructions remain in the agent_browser prompt section.",
+};
+export const AGENT_BROWSER_OUTPUT_SCHEMA = JsonSchema.Object({
+    success: JsonSchema.Boolean(),
+    resultCategory: JsonSchema.Union([JsonSchema.Literal("success"), JsonSchema.Literal("failure")]),
+    data: JsonSchema.Optional(JsonSchema.Unsafe({})),
+    error: JsonSchema.Optional(JsonSchema.Unsafe({})),
+    summary: JsonSchema.Optional(JsonSchema.String()),
+    nextActions: JsonSchema.Optional(JsonSchema.Array(JsonSchema.Object({}))),
+}, { additionalProperties: true });
+/** Final public boundary, after execution, persistence, and any requested output export. */
+export async function finalizeAgentBrowserNativeResult(result, input) {
+    const finalized = finalizeAgentBrowserFailure(result, input);
+    // Native help/version stays plain text; the entrypoint intentionally skips observation rendering for it.
+    if (isRecord(input) && Array.isArray(input.args) && isPlainTextInspectionArgs(input.args))
+        return finalized;
+    const succeeded = finalized.isError !== true;
+    // The normal entrypoint supplies the exact bounded projection, including its complete spill.
+    if (isRecord(result.structuredContent) && result.structuredContent.success === succeeded)
+        return finalized;
+    const details = isRecord(result.details) ? result.details : {};
+    const observation = projectAgentBrowserObservation(details, succeeded);
+    if (JSON.stringify(observation).length > OBSERVATION_INLINE_MAX_CHARS) {
+        const { renderAgentBrowserObservation } = await import("./results/presentation/large-output.js");
+        const rendered = await renderAgentBrowserObservation({
+            content: finalized.content, details, succeeded,
+            json: isRecord(input) && ("code" in input || Array.isArray(input.args) && input.args.includes("--json")),
+            // The caller's exact visible output stays inline (for example formatted search results); only the structured field is bounded.
+            preserveContent: true,
+        });
+        const { artifactManifest, ...renderedResult } = rendered;
+        return finalizeAgentBrowserFailure({
+            ...finalized, ...renderedResult,
+            details: artifactManifest ? { ...details, artifactManifest } : details,
+        }, input);
+    }
+    return { ...finalized, structuredContent: JSON.parse(JSON.stringify(observation)) };
+}

package/dist/extensions/agent-browser/lib/orchestration/batch-stdin.js

@@ -139,12 +139,3 @@ export function getUpstreamEffectiveBatchSteps(commandTokens, stdin) {
         return argumentSteps;
     return parseUserBatchStdin(stdin).steps ?? [];
 }
-export function parseValidBatchStepEntries(stdin) {
-    const parsed = parseBatchStdinJsonArray(stdin);
-    if (parsed.error || parsed.steps === undefined)
-        return [];
-    return parsed.steps.flatMap((step, index) => {
-        const validated = validateUserBatchStep(step, index);
-        return validated.ok ? [{ index, step: validated.step }] : [];
-    });
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/artifact-merge.js

@@ -0,0 +1,22 @@
+import { getSessionArtifactManifestEntryKey, isPendingRecordingCommand, mergeSessionArtifactManifest } from "../../results/artifact-manifest.js";
+export function mergeBrowserRunArtifactManifest(current, initial, updated) {
+    if (!updated || updated === initial)
+        return current;
+    if (current === initial)
+        return updated;
+    const initialEntries = new Map((initial?.entries ?? []).map((entry) => [getSessionArtifactManifestEntryKey(entry), entry]));
+    const changedEntries = updated.entries
+        .map((entry, index) => ({ entry, index }))
+        .filter(({ entry }) => initialEntries.get(getSessionArtifactManifestEntryKey(entry)) !== entry)
+        .sort((left, right) => left.entry.createdAtMs - right.entry.createdAtMs
+        || Number(isPendingRecordingCommand(left.entry.command, left.entry.subcommand, left.entry.kind)) - Number(isPendingRecordingCommand(right.entry.command, right.entry.subcommand, right.entry.kind))
+        || left.index - right.index)
+        .map(({ entry }) => entry);
+    return changedEntries.length === 0
+        ? current
+        : mergeSessionArtifactManifest({
+            base: current,
+            entries: changedEntries,
+            nowMs: Math.max(Date.now(), (current?.updatedAtMs ?? 0) + 1, updated.updatedAtMs),
+        });
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/diagnostics.js

@@ -566,7 +566,7 @@ export function formatQaAttachedTargetText(target) {
         return undefined;
     return ["QA attached target:", target.sessionName, target.title, target.url].filter((part) => typeof part === "string" && part.length > 0).join(" — ");
 }
-export function buildQaAttachedRecoveryNextActions(sessionName) {
+function buildQaAttachedRecoveryNextActions(sessionName) {
     const sessionArgs = (args) => withOptionalSessionArgs(sessionName, args);
     return [
         buildNextToolAction({

package/dist/extensions/agent-browser/lib/orchestration/browser-run/final-result.js

@@ -26,13 +26,13 @@ export function buildMissingBinaryMessage() {
     ].join("\n");
 }
 const SEMANTIC_ACTION_CANDIDATE_ACTION_IDS = new Set(["try-button-name-candidate", "try-link-name-candidate"]);
-export function formatSemanticActionCandidateText(actions) {
+function formatSemanticActionCandidateText(actions) {
     const candidateActions = actions.filter((action) => SEMANTIC_ACTION_CANDIDATE_ACTION_IDS.has(action.id) && action.params?.args);
     if (candidateActions.length === 0)
         return undefined;
     return ["Agent-browser candidate fallbacks:", ...candidateActions.map((action) => `- ${action.id}: agent_browser ${JSON.stringify({ args: action.params?.args })} — ${action.reason}`)].join("\n");
 }
-export function buildSemanticActionCandidateActions(compiled) {
+function buildSemanticActionCandidateActions(compiled) {
     const commandIndex = getCompiledSemanticActionCommandIndex(compiled);
     if (commandIndex < 0 || compiled.args[commandIndex] !== "find")
         return [];

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare.js

@@ -333,7 +333,7 @@ function resolveSemanticActionVisibleRefArgsFromSnapshot(compiled, snapshotData)
         return undefined;
     return { args: [...getCompiledSemanticActionSessionPrefix(compiled), ...resolution.args], snapshot: resolution.snapshot };
 }
-export async function resolveSemanticActionVisibleRefArgs(options) {
+async function resolveSemanticActionVisibleRefArgs(options) {
     if (!options.compiled || !options.sessionName)
         return undefined;
     const snapshotData = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal });

package/dist/extensions/agent-browser/lib/orchestration/execution-queue.js

@@ -0,0 +1,86 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../argv-grammar.js";
+// Serializes managed-session read/modify/write work so overlapping tool calls cannot promote stale state or close an in-use session.
+export class AsyncExecutionQueue {
+    tail = Promise.resolve();
+    active = new AsyncLocalStorage();
+    isCurrent() { return this.active.getStore()?.active === true; }
+    run(work, signal, barrier = Promise.resolve()) {
+        if (this.isCurrent()) {
+            signal?.throwIfAborted();
+            return work();
+        }
+        const previous = this.tail;
+        let release;
+        this.tail = new Promise((resolve) => {
+            release = resolve;
+        });
+        let rejectWaiting;
+        const cancelled = new Promise((_resolve, reject) => { rejectWaiting = reject; });
+        const abortWaiting = () => rejectWaiting(signal?.reason);
+        signal?.addEventListener("abort", abortWaiting, { once: true });
+        if (signal?.aborted)
+            abortWaiting();
+        const execution = (async () => {
+            await Promise.all([previous, barrier]);
+            signal?.removeEventListener("abort", abortWaiting);
+            try {
+                signal?.throwIfAborted();
+                const scope = { active: true };
+                try {
+                    return await this.active.run(scope, work);
+                }
+                finally {
+                    scope.active = false;
+                }
+            }
+            finally {
+                release();
+            }
+        })();
+        return signal ? Promise.race([execution, cancelled]) : execution;
+    }
+}
+export class KeyedAsyncExecutionQueue {
+    barriers = new Map();
+    entries = new Map();
+    async run(key, namespace, work, signal) {
+        const entry = this.entries.get(key) ?? { queue: new AsyncExecutionQueue(), users: 0 };
+        if (entry.queue.isCurrent())
+            return work();
+        const barrier = this.barriers.get(getAgentBrowserSessionIdentityKey("", namespace)) ?? Promise.resolve();
+        entry.users += 1;
+        this.entries.set(key, entry);
+        try {
+            return await entry.queue.run(work, signal, barrier);
+        }
+        finally {
+            entry.users -= 1;
+            if (entry.users === 0 && this.entries.get(key) === entry)
+                this.entries.delete(key);
+        }
+    }
+    async runExclusive(namespace, work) {
+        const namespaceKey = getAgentBrowserSessionIdentityKey("", namespace);
+        const previous = this.barriers.get(namespaceKey) ?? Promise.resolve();
+        let release;
+        const blocked = new Promise((resolve) => {
+            release = resolve;
+        });
+        const barrier = previous.then(() => blocked);
+        this.barriers.set(namespaceKey, barrier);
+        const drains = [...this.entries]
+            .filter(([key]) => isAgentBrowserSessionIdentityKeyInNamespace(key, namespace))
+            .map(([, { queue }]) => queue.run(async () => undefined));
+        await previous;
+        await Promise.all(drains);
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.barriers.get(namespaceKey) === barrier)
+                this.barriers.delete(namespaceKey);
+        }
+    }
+}