pi-agent-browser-native 0.6.16 → 0.7.0

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

@@ -1,149 +1,153 @@
 import { JsonSchema } from "../json-schema.js";
 import { StringEnum as localStringEnum } from "../string-enum-schema.js";
-import { AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES } from "./script.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_JOB_STEP_ACTIONS, AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
-// Keep descriptions terse: Pi sends this schema every turn; workflows belong in prompt guidance and docs.
+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;
+function outputProperties(Type) {
+    return {
+        outputPath: Type.Optional(Type.String({ description: "Result-data path, separate from browser artifact paths.", minLength: 1 })),
+        timeoutMs: Type.Optional(Type.Integer({ description: "Timeout in ms; exceed explicit waits.", minimum: 1 })),
+    };
+}
+function sessionModeProperty(Type, StringEnum) {
+    return Type.Optional(StringEnum(["auto", "fresh"], {
+        description: "Native configured sessions win; auto reuses the browser, fresh intentionally launches a separate managed browser.",
+        default: DEFAULT_SESSION_MODE,
+    }));
+}
+// Keep the always-on schemas small; specialized guidance belongs to each advanced tool.
 export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
-    return Type.Object({
-        script: Type.Optional(Type.String({
-            description: "One-shot JavaScript orchestration with async browser({ args, stdin?, timeoutMs? }) and emit(value); isolated session and no host access.",
-            maxLength: AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES,
-        })),
-        args: Type.Optional(Type.Array(Type.String(), {
-            description: "Raw agent-browser argv only: no binary, shell operators, or --json. Start with open → snapshot -i → act on current @refs; re-snapshot after page changes. Input: type <selector> <text>, or keyboard type <text> at current focus. Wait duration: wait <ms> (no --time). Artifacts: screenshot [selector] [path] [--full/-f]; record start <path> [url]; record restart <path> [url]; record stop. Paths are positional (no --path); use --full, not --full-page.",
-            minItems: 1,
-        })),
-        semanticAction: Type.Optional(Type.Object({
-            action: StringEnum(AGENT_BROWSER_SEMANTIC_ACTIONS),
-            locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Locator for check/click/fill; select supports role or label." })),
-            value: Type.Optional(Type.String({ description: "Locator value or one select option; for select by label, this is the label text." })),
-            values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
-            selector: Type.Optional(Type.String({ description: "Direct selector or @ref." })),
-            text: Type.Optional(Type.String({ description: "Fill text." })),
-            role: Type.Optional(Type.String({ description: "Role for locator=role; select needs combobox or listbox." })),
-            name: Type.Optional(Type.String({ description: "Accessible name." })),
-            session: Type.Optional(Type.String({ description: "Upstream session name." })),
-        }, {
-            additionalProperties: false,
-            // Pi normalizes optional nulls through properties, not union branches.
-            anyOf: [
-                Type.Object({
-                    action: StringEnum(["select"]),
-                    locator: Type.Optional(StringEnum(["role", "label"])),
-                }, { not: { required: ["text"] } }),
-                Type.Object({
-                    action: StringEnum(["check", "click", "fill"]),
-                }, { not: { required: ["values"] } }),
-            ],
-            description: "Stable locator or direct-selector action. values only with action=select.",
-        })),
-        qa: Type.Optional(Type.Union([
-            Type.Object({
-                attached: Type.Literal(true),
-                expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
-                expectedSelector: Type.Optional(Type.String()),
-                screenshotPath: Type.Optional(Type.String()),
-                checkConsole: Type.Optional(Type.Boolean()),
-                checkErrors: Type.Optional(Type.Boolean()),
-                checkNetwork: Type.Optional(Type.Boolean()),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
-            }, { additionalProperties: false }),
-            Type.Object({
-                url: Type.String(),
-                attached: Type.Optional(Type.Literal(false)),
-                expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
-                expectedSelector: Type.Optional(Type.String()),
-                screenshotPath: Type.Optional(Type.String()),
-                checkConsole: Type.Optional(Type.Boolean()),
-                checkErrors: Type.Optional(Type.Boolean()),
-                checkNetwork: Type.Optional(Type.Boolean()),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
-            }, { additionalProperties: false }),
-        ], { description: "QA a URL or current session (attached=true). Default readiness: domcontentloaded; use networkidle only without long-lived requests. URL diagnostics default on, attached diagnostics off." })),
-        sourceLookup: Type.Optional(Type.Object({
-            selector: Type.Optional(Type.String({ description: "Visible selector or @ref." })),
-            reactFiberId: Type.Optional(Type.String({ description: "React fiber id; requires --enable react-devtools." })),
-            componentName: Type.Optional(Type.String({ description: "Component for local source search." })),
-            includeDomHints: Type.Optional(Type.Boolean({ description: "Inspect DOM source hints; default true." })),
-            maxWorkspaceFiles: Type.Optional(Type.Number({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        }, { additionalProperties: false, description: "EXPERIMENTAL UI-to-source candidates; not guaranteed mappings." })),
-        networkSourceLookup: Type.Optional(Type.Object({
-            filter: Type.Optional(Type.String({ description: "Network request filter." })),
-            namespace: Type.Optional(Type.String()),
-            requestId: Type.Optional(Type.String({ description: "Request id to inspect." })),
-            session: Type.Optional(Type.String()),
-            url: Type.Optional(Type.String({ description: "Failed URL or fragment." })),
-            maxWorkspaceFiles: Type.Optional(Type.Number({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        }, { additionalProperties: false, description: "EXPERIMENTAL failed-request-to-source candidates; not proof." })),
-        electron: Type.Optional(Type.Union([
-            Type.Object({
-                action: StringEnum(["list"]),
-                query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
-                maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, values over ${ELECTRON_DISCOVERY_MAX_RESULTS} are clamped.`, minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["launch"]),
-                appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
-                appName: Type.Optional(Type.String({ description: "Name from electron.list.", minLength: 1 })),
-                bundleId: Type.Optional(Type.String({ description: "Bundle id from electron.list.", minLength: 1 })),
-                executablePath: Type.Optional(Type.String({ description: "Executable path.", minLength: 1 })),
-                appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-                handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
-                targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-                allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-                deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                launchId: Type.String({ description: "Tracked launch id.", minLength: 1 }),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                all: Type.Literal(true),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["status", "cleanup"]),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-            Type.Object({
-                action: StringEnum(["probe"]),
-                launchId: Type.Optional(Type.String({ description: "Tracked launch id.", minLength: 1 })),
-                timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
-            }, { additionalProperties: false }),
-        ], { description: "Electron discovery, isolated-profile launch, status, probe, or cleanup. Launch defaults: handoff=snapshot, targetType=page; deny wins over allow; lifecycle/debug appArgs rejected." })),
-        job: Type.Optional(Type.Object({
-            failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure; default true." })),
-            steps: Type.Array(Type.Object({
-                action: StringEnum(AGENT_BROWSER_JOB_STEP_ACTIONS),
-                url: Type.Optional(Type.String({ description: "Open URL, or assertUrl exact URL/glob that distinguishes the expected state from the starting page." })),
-                loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES, { description: "Readiness wait after open." })),
-                selector: Type.Optional(Type.String({ description: "Selector or @ref." })),
-                locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Locator when selector is omitted." })),
-                role: Type.Optional(Type.String({ description: "Role locator." })),
-                name: Type.Optional(Type.String({ description: "Accessible name." })),
-                text: Type.Optional(Type.String({ description: "Fill/type text; assertText uses only text, not selector/locator fields." })),
-                value: Type.Optional(Type.String({ description: "Select option or locator value." })),
-                values: Type.Optional(Type.Array(Type.String(), { description: "Select options.", minItems: 1 })),
-                path: Type.Optional(Type.String({ description: "Download or screenshot path." })),
-                delayMs: Type.Optional(Type.Integer({ description: `Per-character type delay; text is capped at ${AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS} characters.`, minimum: 1 })),
-                press: Type.Optional(Type.String({ description: "Key to press after typing." })),
-                milliseconds: Type.Optional(Type.Number({ description: "Wait duration in milliseconds." })),
-            }, { additionalProperties: false }), { minItems: 1 }),
-        }, { additionalProperties: false, description: "Constrained multi-step batch. Clicks can stale later refs; split and re-snapshot before using them." })),
-        stdin: Type.Optional(Type.String({ description: "For batch, a JSON array of token arrays, e.g. [[\"get\",\"title\"]]. Raw text only for eval --stdin or auth save --password-stdin; unavailable with structured modes and electron." })),
-        outputPath: Type.Optional(Type.String({ description: "Workspace-relative or absolute result-data path; keep it distinct from screenshot, download, recording, and other browser artifact destinations.", minLength: 1 })),
-        timeoutMs: Type.Optional(Type.Integer({ description: "Wrapper timeout in ms; exceed explicit waits. electron.list has no configurable timeout; other Electron actions use electron.timeoutMs.", minimum: 1 })),
-        sessionMode: Type.Optional(StringEnum(["auto", "fresh"], {
-            description: "Native configured sessions win; otherwise auto reuses the managed session and fresh starts a new managed browser for launch-only flags.",
-            default: DEFAULT_SESSION_MODE,
-        })),
+    return Type.Unsafe(Type.Object({
+        args: Type.Array(Type.String(), { description: "Native agent-browser argv without the binary or shell syntax. Fixed sequences: batch --bail with JSON-array stdin.", minItems: 1 }),
+        stdin: Type.Optional(Type.String({ description: "Native batch JSON, eval --stdin source, or auth save --password-stdin text." })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserCodeParamsSchema(Type = JsonSchema) {
+    return Type.Unsafe(Type.Object({
+        code: Type.String({ description: "JavaScript with await browser({args, stdin?, timeoutMs?}), emit(JSON), and emitImage(image handle). Fresh JS context; persistent browser.", minLength: 1, maxLength: 65_536 }),
+        session: Type.Optional(Type.String({ description: "Explicit native session; omitted uses the ordinary default browser.", minLength: 1 })),
+        namespace: Type.Optional(Type.String({ description: "Native namespace; empty string selects the default namespace." })),
+        ...outputProperties(Type),
+        timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: AGENT_BROWSER_CODE_MAX_TIMEOUT_MS })),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserActionParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        action: StringEnum(AGENT_BROWSER_SEMANTIC_ACTIONS),
+        locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Select supports role or label." })),
+        value: Type.Optional(Type.String({ description: "Locator value or select option; label text for select by label." })),
+        values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
+        selector: Type.Optional(Type.String({ description: "Direct selector or current @ref." })),
+        text: Type.Optional(Type.String({ description: "Fill text." })),
+        role: Type.Optional(Type.String({ description: "Role locator; select needs combobox or listbox." })),
+        name: Type.Optional(Type.String({ description: "Accessible name." })),
+        session: Type.Optional(Type.String({ description: "Upstream session name." })),
+        ...outputProperties(Type),
     }, {
         additionalProperties: false,
-        description: "Choose one input mode: script, args, semanticAction, job, qa, sourceLookup, networkSourceLookup, or electron.",
-    });
+        // Top-level properties let Pi normalize optional nulls before validating branches.
+        anyOf: [
+            Type.Object({ action: StringEnum(["select"]), locator: Type.Optional(StringEnum(["role", "label"])) }, { not: { required: ["text"] } }),
+            Type.Object({ action: StringEnum(["check", "click", "fill"]) }, { not: { required: ["values"] } }),
+        ],
+    }));
+}
+export function createAgentBrowserQaParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        url: Type.Optional(Type.String()),
+        attached: Type.Optional(Type.Boolean()),
+        expectedText: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
+        expectedSelector: Type.Optional(Type.String()),
+        screenshotPath: Type.Optional(Type.String()),
+        checkConsole: Type.Optional(Type.Boolean()),
+        checkErrors: Type.Optional(Type.Boolean()),
+        checkNetwork: Type.Optional(Type.Boolean()),
+        loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, {
+        additionalProperties: false,
+        anyOf: [
+            Type.Object({ attached: Type.Literal(true), sessionMode: Type.Optional(StringEnum(["auto"])) }, { not: { required: ["url"] } }),
+            Type.Object({ url: Type.String(), attached: Type.Optional(Type.Literal(false)) }),
+        ],
+    }));
+}
+export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    const common = { outputPath: outputProperties(Type).outputPath };
+    const timeoutMs = Type.Optional(Type.Integer({ minimum: 1 }));
+    return Type.Unsafe(Type.Union([
+        Type.Object({
+            action: StringEnum(["list"]),
+            query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
+            maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`, minimum: 1 })),
+            ...common,
+        }, { additionalProperties: false }),
+        Type.Object({
+            action: StringEnum(["launch"]),
+            appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
+            appName: Type.Optional(Type.String({ description: "Name from agent_browser_electron list.", minLength: 1 })),
+            bundleId: Type.Optional(Type.String({ minLength: 1 })),
+            executablePath: Type.Optional(Type.String({ minLength: 1 })),
+            appArgs: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            handoff: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_HANDOFFS)),
+            targetType: Type.Optional(StringEnum(AGENT_BROWSER_ELECTRON_TARGET_TYPES)),
+            timeoutMs,
+            allow: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            deny: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+            ...common,
+        }, { additionalProperties: false }),
+        Type.Object({
+            action: StringEnum(["status", "cleanup"]),
+            launchId: Type.Optional(Type.String({ minLength: 1 })),
+            all: Type.Optional(Type.Literal(true)),
+            timeoutMs,
+            ...common,
+        }, { additionalProperties: false, not: { required: ["launchId", "all"] } }),
+        Type.Object({
+            action: StringEnum(["probe"]),
+            launchId: Type.Optional(Type.String({ minLength: 1 })),
+            timeoutMs,
+            ...common,
+        }, { additionalProperties: false }),
+    ]));
+}
+export function createAgentBrowserSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        selector: Type.Optional(Type.String({ description: "Visible selector or @ref." })),
+        reactFiberId: Type.Optional(Type.String({ description: "React fiber id; requires --enable react-devtools." })),
+        componentName: Type.Optional(Type.String({ description: "Component for local source search." })),
+        includeDomHints: Type.Optional(Type.Boolean({ description: "Inspect DOM hints; default true." })),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserNetworkSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        filter: Type.Optional(Type.String({ description: "Network request filter." })),
+        namespace: Type.Optional(Type.String()),
+        requestId: Type.Optional(Type.String({ description: "Request id to inspect." })),
+        session: Type.Optional(Type.String()),
+        url: Type.Optional(Type.String({ description: "Failed URL or fragment." })),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
+        ...outputProperties(Type),
+        sessionMode: sessionModeProperty(Type, StringEnum),
+    }, { additionalProperties: false }));
+}
+export function createAgentBrowserToolsParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+    return Type.Unsafe(Type.Object({
+        enable: Type.Optional(Type.Array(StringEnum(AGENT_BROWSER_ADVANCED_TOOLS), { description: "Add capabilities to active tools; omit to list inventory." })),
+    }, { additionalProperties: false }));
 }
 export const AGENT_BROWSER_PARAMS = createAgentBrowserParamsSchema();
+export const AGENT_BROWSER_CODE_PARAMS = createAgentBrowserCodeParamsSchema();
+export const AGENT_BROWSER_ACTION_PARAMS = createAgentBrowserActionParamsSchema();
+export const AGENT_BROWSER_QA_PARAMS = createAgentBrowserQaParamsSchema();
+export const AGENT_BROWSER_ELECTRON_PARAMS = createAgentBrowserElectronParamsSchema();
+export const AGENT_BROWSER_SOURCE_PARAMS = createAgentBrowserSourceParamsSchema();
+export const AGENT_BROWSER_NETWORK_SOURCE_PARAMS = createAgentBrowserNetworkSourceParamsSchema();
+export const AGENT_BROWSER_TOOLS_PARAMS = createAgentBrowserToolsParamsSchema();

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

@@ -1,15 +1,13 @@
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseArgvDescriptor } from "../argv-descriptor.js";
-import { getFlagName } from "../argv-grammar.js";
-import { isBrowserIndependentRead, needsManagedSession } from "../command-policy.js";
-import { isCloseCommand } from "../command-taxonomy.js";
-import { LAUNCH_SCOPED_FLAGS, MANAGED_RESTORE_INCOMPATIBLE_FLAGS } from "../launch-scoped-flags.js";
 import { isRecord } from "../parsing.js";
-import { validateToolArgs } from "../runtime.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";
 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 = "";
@@ -18,7 +16,6 @@ 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;
-export const AGENT_BROWSER_SCRIPT_SPILL_MAX_BYTES = 512 * 1_024;
 function findPackageRoot(startDir) {
     let currentDir = startDir;
     for (;;) {
@@ -37,25 +34,13 @@ 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}$/;
-const SCRIPT_ALLOWED_LAUNCH_FLAG = "--allowed-domains";
-const SCRIPT_FORBIDDEN_COMMANDS = new Set(["attach", "auth", "batch", "connect", "script", "session", "state"]);
-const SCRIPT_FORBIDDEN_FLAGS = new Set([
-    ...LAUNCH_SCOPED_FLAGS.filter((flag) => flag !== SCRIPT_ALLOWED_LAUNCH_FLAG),
-    ...MANAGED_RESTORE_INCOMPATIBLE_FLAGS.filter((flag) => flag !== SCRIPT_ALLOWED_LAUNCH_FLAG),
-    "--namespace",
-    "--session",
-    "--config",
-]);
-export function compileAgentBrowserScript(input) {
+export function validateAgentBrowserScriptSource(input) {
     if (typeof input !== "string")
         return { error: "script must be a string." };
     const bytes = Buffer.byteLength(input, "utf8");
     return bytes > AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES
         ? { error: `script must be ${AGENT_BROWSER_SCRIPT_CODE_MAX_BYTES} bytes or less.` }
-        : { compiled: { code: input } };
-}
-export function createAgentBrowserScriptSessionName() {
-    return `piab-script-${randomUUID()}`;
+        : {};
 }
 export function createAgentBrowserScriptCloseArgs(sessionName) {
     return ["--namespace", AGENT_BROWSER_SCRIPT_NAMESPACE, "--session", sessionName, "close"];
@@ -63,25 +48,6 @@ export function createAgentBrowserScriptCloseArgs(sessionName) {
 export function isAgentBrowserScriptSessionName(value) {
     return typeof value === "string" && SCRIPT_SESSION_NAME_PATTERN.test(value);
 }
-function getScriptCallPolicyError(args) {
-    const descriptor = parseArgvDescriptor(args);
-    const command = descriptor.commandInfo.command;
-    if (!command)
-        return "script browser call args must contain an agent-browser command.";
-    if (isCloseCommand(command))
-        return "script browser calls cannot close, quit, or exit their isolated session.";
-    if (SCRIPT_FORBIDDEN_COMMANDS.has(command))
-        return `script browser calls cannot use ${command}.`;
-    if (!needsManagedSession(descriptor) && !isBrowserIndependentRead(descriptor.upstreamCommandTokens))
-        return `script browser calls cannot use sessionless/local command ${command}.`;
-    for (const token of args) {
-        const flag = getFlagName(token);
-        if (SCRIPT_FORBIDDEN_FLAGS.has(flag)) {
-            return `script browser calls cannot use ${flag}; the parent owns the isolated session identity and launch policy.`;
-        }
-    }
-    return undefined;
-}
 export function validateAgentBrowserScriptBrowserParams(input) {
     if (!isRecord(input))
         return { error: "script browser(params) requires an object." };
@@ -102,53 +68,51 @@ export function validateAgentBrowserScriptBrowserParams(input) {
         stdin: input.stdin,
         timeoutMs: input.timeoutMs,
     };
-    const policyError = getScriptCallPolicyError(params.args);
-    if (policyError)
-        return { error: policyError, policyBlocked: true };
     const validationError = validateToolArgs(params.args);
     return validationError ? { error: validationError } : { params };
 }
-function buildRejectedCallEnvelope(error, policyBlocked) {
+export function bindBrowserCodeCall(params, identity) {
+    const explicitSession = extractExplicitSessionName(params.args);
+    const namespaceFlags = scanUpstreamGlobalFlagOccurrences(params.args, "--namespace");
+    const explicitNamespace = extractExplicitNamespace(params.args);
+    if ((explicitSession !== undefined && explicitSession !== identity.sessionName)
+        || (namespaceFlags.length > 0 && (explicitNamespace || undefined) !== (identity.namespace || undefined))) {
+        throw new Error("A code call uses one browser identity. Set session/namespace on agent_browser_code to choose another browser.");
+    }
+    const tokens = extractUpstreamCommandTokens(params.args);
+    if (isCloseAllCommand(tokens) || getUpstreamEffectiveBatchSteps(tokens, params.stdin).some(isCloseAllCommand)) {
+        throw new Error("Run namespace-wide close --all directly with agent_browser, outside a session-scoped code call.");
+    }
+    return { ...params, args: [
+            ...(namespaceFlags.length === 0 ? ["--namespace", identity.namespace ?? ""] : []),
+            ...(explicitSession === undefined ? ["--session", identity.sessionName] : []),
+            ...params.args,
+        ] };
+}
+function buildRejectedCallEnvelope(error) {
     return {
         data: null,
-        details: { failureCategory: policyBlocked ? "policy-blocked" : "validation-error", resultCategory: "failure" },
         error,
-        failureCategory: policyBlocked ? "policy-blocked" : "validation-error",
-        ok: false,
+        failureCategory: "validation-error",
+        success: false,
         resultCategory: "failure",
         summary: error,
-        text: error,
     };
 }
 function normalizeBrowserEnvelope(value) {
-    if (!isRecord(value)
-        || typeof value.ok !== "boolean"
-        || typeof value.text !== "string"
-        || typeof value.summary !== "string"
-        || (value.resultCategory !== "success" && value.resultCategory !== "failure")) {
-        return buildRejectedCallEnvelope("The ordinary agent_browser executor returned an invalid script envelope.", false);
+    if (!isRecord(value) || typeof value.success !== "boolean" || (value.resultCategory !== "success" && value.resultCategory !== "failure")) {
+        return buildRejectedCallEnvelope("The browser executor returned an invalid code observation.");
     }
-    return {
-        data: value.data ?? null,
-        details: isRecord(value.details) ? value.details : undefined,
-        error: typeof value.error === "string" ? value.error : undefined,
-        failureCategory: value.failureCategory,
-        nextActions: Array.isArray(value.nextActions) ? value.nextActions : undefined,
-        ok: value.ok,
-        resultCategory: value.resultCategory,
-        successCategory: value.successCategory,
-        summary: value.summary,
-        text: value.text,
-    };
+    return value;
 }
 function buildStepSummary(index, envelope) {
     return {
         failureCategory: envelope.failureCategory,
         index,
-        ok: envelope.ok,
+        ok: envelope.success,
         resultCategory: envelope.resultCategory,
         successCategory: envelope.successCategory,
-        summary: envelope.summary,
+        summary: envelope.summary ?? (typeof envelope.error === "string" ? envelope.error : "Browser call completed."),
     };
 }
 function buildFailedRun(options) {
@@ -168,7 +132,7 @@ function isScriptChildMessage(value) {
         return true;
     if (value.type === "call")
         return typeof value.id === "number" && Number.isSafeInteger(value.id) && value.id > 0;
-    if (value.type === "emit")
+    if (value.type === "emit" || value.type === "image")
         return true;
     return value.type === "complete";
 }
@@ -206,7 +170,7 @@ function serializeFinalOutput(value) {
     return JSON.stringify(value);
 }
 export async function runAgentBrowserScript(options) {
-    const compiled = compileAgentBrowserScript(options.code);
+    const compiled = validateAgentBrowserScriptSource(options.code);
     if (compiled.error) {
         return buildFailedRun({ callCount: 0, emitCount: 0, error: compiled.error, failureCategory: "validation-error", rejectedCallCount: 0, steps: [] });
     }
@@ -241,12 +205,12 @@ export async function runAgentBrowserScript(options) {
     let cumulativeBytes = 0;
     let callCount = 0;
     let rejectedCallCount = 0;
-    let leaseStarted = false;
     let ready = false;
     let stopping = false;
     let activeCallController;
     const emissions = [];
     const steps = [];
+    const failures = [];
     const messages = [];
     let draining = false;
     let drainPromise = Promise.resolve();
@@ -275,10 +239,11 @@ export async function runAgentBrowserScript(options) {
         if (timeout)
             clearTimeout(timeout);
         options.signal?.removeEventListener("abort", abortListener);
-        activeCallController?.abort();
+        activeCallController?.abort(result.timedOut ? new DOMException("Browser code deadline exceeded.", "TimeoutError") : options.signal?.reason);
         killTimer = terminateChild(child);
+        // The caller holds the browser lease until dispatch actually settles.
         if (waitForDrain)
-            await settleWithin(drainPromise, 5_000);
+            await drainPromise.catch(() => undefined);
         await settleWithin(childExit, 1_000);
         clearTimeout(killTimer);
         resolveResult(result);
@@ -287,13 +252,16 @@ export async function runAgentBrowserScript(options) {
         ...flags,
         callCount,
         emitCount: emissions.length,
+        ...(emissions.length ? { data: emissions.length === 1 ? emissions[0] : emissions } : {}),
         error,
         failureCategory,
+        failures,
         rejectedCallCount,
         steps,
     }), waitForDrain);
     const abortListener = () => {
-        void fail("Script execution was aborted.", "aborted", { aborted: true }, true);
+        const timedOut = options.signal?.reason instanceof Error && options.signal.reason.name === "TimeoutError";
+        void fail(timedOut ? "Browser code deadline exceeded." : "Browser code was aborted.", timedOut ? "timeout" : "aborted", timedOut ? { timedOut: true } : { aborted: true }, true);
     };
     options.signal?.addEventListener("abort", abortListener, { once: true });
     timeout = setTimeout(() => {
@@ -333,6 +301,18 @@ export async function runAgentBrowserScript(options) {
                     emissions.push(message.value);
                     continue;
                 }
+                if (message.type === "image") {
+                    try {
+                        if (!options.emitImage)
+                            throw new Error("Image emission is unavailable.");
+                        await options.emitImage(message.value);
+                    }
+                    catch (error) {
+                        await fail(error instanceof Error ? error.message : "Invalid image handle.", "validation-error");
+                        return;
+                    }
+                    continue;
+                }
                 if (message.type === "complete") {
                     if (message.error) {
                         await fail(describeScriptError(message.error), "script-error");
@@ -353,7 +333,7 @@ export async function runAgentBrowserScript(options) {
                         await fail(`Final script output exceeds ${AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES} bytes.`, "validation-error");
                         return;
                     }
-                    await finish({ callCount, data, emitCount: emissions.length, ok: true, rejectedCallCount, steps }, false);
+                    await finish({ callCount, data, emitCount: emissions.length, failures, ok: true, rejectedCallCount, steps }, false);
                     return;
                 }
                 callCount += 1;
@@ -365,38 +345,30 @@ export async function runAgentBrowserScript(options) {
                 let envelope;
                 if (!validated.params) {
                     rejectedCallCount += 1;
-                    envelope = buildRejectedCallEnvelope(validated.error ?? "Invalid script browser call.", validated.policyBlocked === true);
+                    envelope = buildRejectedCallEnvelope(validated.error ?? "Invalid script browser call.");
                 }
                 else {
-                    if (!leaseStarted) {
-                        try {
-                            options.beforeFirstCall?.();
-                            leaseStarted = true;
-                        }
-                        catch {
-                            await fail("Unable to persist the isolated script session lease.", "upstream-error");
-                            return;
-                        }
-                    }
                     activeCallController = new AbortController();
                     try {
                         envelope = normalizeBrowserEnvelope(await options.dispatch(validated.params, activeCallController.signal));
                     }
-                    catch {
-                        envelope = buildRejectedCallEnvelope("The ordinary agent_browser executor failed while dispatching this call.", false);
+                    catch (error) {
+                        envelope = buildRejectedCallEnvelope(redactSensitiveText(error instanceof Error ? error.message : "The browser executor failed while dispatching this call."));
                     }
                     finally {
                         activeCallController = undefined;
                     }
-                    if (stopping)
-                        return;
                 }
                 steps.push(buildStepSummary(callCount - 1, envelope));
+                if (!envelope.success)
+                    failures.push({ ...envelope, index: callCount - 1 });
+                if (stopping)
+                    return;
                 try {
                     await sendParentMessage({ envelope, id: message.id, type: "response" });
                 }
                 catch {
-                    await fail("Unable to return a browser result to the script sandbox.", "upstream-error");
+                    await fail("Unable to return a browser result within the code IPC limit. Narrow the native extraction or use agent_browser with outputPath; already-dispatched effects are not rolled back.", "upstream-error");
                     return;
                 }
             }