pi-agent-browser-native 0.6.17 → 0.7.1

package/dist/extensions/agent-browser/lib/orchestration/input-plan.js

@@ -3,10 +3,9 @@ import { normalizeUrlLessOpen } from "./batch-stdin.js";
 import { isPlainTextInspectionArgs, validateToolArgs, redactInvocationArgs, redactSensitiveText } from "../runtime.js";
 import { buildAgentBrowserResultCategoryDetails } from "../results/categories.js";
 import { compileAgentBrowserElectron } from "../input-modes/electron.js";
-import { compileAgentBrowserJob, compileAgentBrowserQaPreset } from "../input-modes/job.js";
+import { compileAgentBrowserQaPreset } from "../input-modes/job.js";
 import { compileAgentBrowserNetworkSourceLookup, compileAgentBrowserSourceLookup, redactNetworkSourceLookupArgs, redactNetworkSourceLookupUrl } from "../input-modes/lookups.js";
 import { compileAgentBrowserSemanticAction } from "../input-modes/semantic-action.js";
-import { AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS, compileAgentBrowserScript } from "../input-modes/script.js";
 function redactCompiledElectron(compiled) {
     if (!compiled)
         return undefined;
@@ -68,46 +67,39 @@ function normalizeExplicitEvalStdinArgs(args, stdin) {
 export function resolveAgentBrowserInput(options) {
     const { getBatchPreflightValidationError, params } = options;
     const semanticActionResult = params.semanticAction === undefined ? {} : compileAgentBrowserSemanticAction(params.semanticAction);
-    const jobResult = params.job === undefined ? {} : compileAgentBrowserJob(params.job);
     const qaResult = params.qa === undefined ? {} : compileAgentBrowserQaPreset(params.qa);
     const sourceLookupResult = params.sourceLookup === undefined ? {} : compileAgentBrowserSourceLookup(params.sourceLookup);
     const networkSourceLookupResult = params.networkSourceLookup === undefined ? {} : compileAgentBrowserNetworkSourceLookup(params.networkSourceLookup);
     const electronResult = params.electron === undefined ? {} : compileAgentBrowserElectron(params.electron);
-    const scriptResult = params.script === undefined ? {} : compileAgentBrowserScript(params.script);
     const hasExplicitArgs = Array.isArray(params.args);
     const explicitInputModes = [
         hasExplicitArgs,
         Boolean(semanticActionResult.compiled),
-        Boolean(jobResult.compiled),
         Boolean(qaResult.compiled),
         Boolean(sourceLookupResult.compiled),
         Boolean(networkSourceLookupResult.compiled),
         Boolean(electronResult.compiled),
-        Boolean(scriptResult.compiled),
     ].filter(Boolean).length;
     const inputModeError = explicitInputModes !== 1
-        ? "Provide exactly one of script, args, semanticAction, job, qa, sourceLookup, networkSourceLookup, or electron."
+        ? "Provide exactly one of args, semanticAction, qa, sourceLookup, networkSourceLookup, or electron."
         : undefined;
     const compiledSemanticAction = semanticActionResult.compiled;
     const compiledQaPreset = qaResult.compiled;
     const compiledSourceLookup = sourceLookupResult.compiled;
     const compiledNetworkSourceLookup = networkSourceLookupResult.compiled;
     const compiledElectron = electronResult.compiled;
-    const compiledScript = scriptResult.compiled;
-    const compiledJob = jobResult.compiled ?? compiledQaPreset;
+    const compiledJob = compiledQaPreset;
     const compiledGeneratedBatch = compiledNetworkSourceLookup ?? compiledSourceLookup ?? compiledJob;
     const normalizedExplicitArgs = normalizeExplicitEvalStdinArgs(params.args ?? [], params.stdin);
-    const toolArgs = compiledElectron || compiledScript ? [] : compiledSemanticAction?.args ?? compiledGeneratedBatch?.args ?? normalizedExplicitArgs.args;
+    const toolArgs = compiledElectron ? [] : compiledSemanticAction?.args ?? compiledGeneratedBatch?.args ?? normalizedExplicitArgs.args;
     const toolStdin = compiledGeneratedBatch?.stdin ?? normalizedExplicitArgs.stdin;
     const redactedArgs = redactInvocationArgs(toolArgs);
     const generatedStdinError = params.stdin !== undefined
         ? compiledGeneratedBatch
-            ? "Do not provide stdin with job, qa, sourceLookup, or networkSourceLookup; those modes generate their own batch stdin."
+            ? "Do not provide stdin with qa, sourceLookup, or networkSourceLookup; those modes generate their own batch stdin."
             : compiledElectron
                 ? "Do not provide stdin with electron; electron mode is host-only or manages its own input."
-                : compiledScript
-                    ? "Do not provide stdin with script; browser call stdin belongs inside browser({ args, stdin })."
-                    : undefined
+                : undefined
         : undefined;
     const outputPathError = params.outputPath !== undefined && (typeof params.outputPath !== "string" || params.outputPath.trim().length === 0)
         ? "outputPath must be a non-empty string when provided."
@@ -118,52 +110,40 @@ export function resolveAgentBrowserInput(options) {
             ? compiledElectron.action === "list"
                 ? "electron.list has no configurable timeout; remove top-level timeoutMs."
                 : "Use electron.timeoutMs for this action; top-level timeoutMs applies only to browser CLI subprocess calls."
-            : compiledScript && params.timeoutMs !== undefined && params.timeoutMs > AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS
-                ? `script timeoutMs must be ${AGENT_BROWSER_SCRIPT_MAX_TIMEOUT_MS} or less.`
-                : undefined;
-    const scriptSessionModeError = compiledScript && params.sessionMode !== undefined
-        ? "Do not provide sessionMode with script; script always uses its own isolated session."
-        : undefined;
+            : undefined;
     const attachedQaSessionError = compiledQaPreset?.checks.attached
         ? params.sessionMode === "fresh"
             ? "qa.attached cannot be used with sessionMode=fresh; attach or launch a session first, then run qa.attached with the current session."
             : undefined
         : undefined;
     const validationError = semanticActionResult.error
-        ?? jobResult.error
         ?? qaResult.error
         ?? sourceLookupResult.error
         ?? networkSourceLookupResult.error
         ?? electronResult.error
-        ?? scriptResult.error
         ?? inputModeError
         ?? generatedStdinError
         ?? outputPathError
         ?? timeoutMsError
-        ?? scriptSessionModeError
         ?? attachedQaSessionError
-        ?? (compiledElectron || compiledScript ? undefined : validateToolArgs(toolArgs) ?? getBatchPreflightValidationError(toolArgs, toolStdin));
+        ?? (compiledElectron ? undefined : validateToolArgs(toolArgs) ?? getBatchPreflightValidationError(toolArgs, toolStdin));
     const redactedCompiledJob = redactCompiledJob(compiledJob);
     const redactedCompiledSemanticAction = compiledSemanticAction
         ? { ...compiledSemanticAction, args: redactInvocationArgs(compiledSemanticAction.args) }
         : undefined;
     const attemptedKind = compiledElectron
         ? "electron"
-        : compiledScript
-            ? "script"
-            : compiledNetworkSourceLookup
-                ? "networkSourceLookup"
-                : compiledSourceLookup
-                    ? "sourceLookup"
-                    : compiledQaPreset
-                        ? "qa"
-                        : jobResult.compiled
-                            ? "job"
-                            : compiledSemanticAction
-                                ? "semanticAction"
-                                : hasExplicitArgs
-                                    ? "args"
-                                    : undefined;
+        : compiledNetworkSourceLookup
+            ? "networkSourceLookup"
+            : compiledSourceLookup
+                ? "sourceLookup"
+                : compiledQaPreset
+                    ? "qa"
+                    : compiledSemanticAction
+                        ? "semanticAction"
+                        : hasExplicitArgs
+                            ? "args"
+                            : undefined;
     const redactedCompiledElectron = redactCompiledElectron(compiledElectron);
     const redactedCompiledNetworkSourceLookup = redactCompiledNetworkSourceLookup(compiledNetworkSourceLookup);
     const redactedCompiledQaPreset = compiledQaPreset && redactedCompiledJob ? { ...redactedCompiledJob, checks: compiledQaPreset.checks } : undefined;
@@ -195,9 +175,6 @@ export function resolveAgentBrowserInput(options) {
     if (compiledElectron && redactedCompiledElectron) {
         return { ...resolvedBase, compiledElectron, kind: "electron", redactedCompiledElectron, status: "valid" };
     }
-    if (compiledScript) {
-        return { ...resolvedBase, compiledScript, kind: "script", status: "valid" };
-    }
     if (compiledNetworkSourceLookup && redactedCompiledNetworkSourceLookup) {
         return {
             ...resolvedBase,
@@ -230,16 +207,6 @@ export function resolveAgentBrowserInput(options) {
             status: "valid",
         };
     }
-    if (jobResult.compiled && redactedCompiledJob) {
-        return {
-            ...resolvedBase,
-            compiledGeneratedBatch: jobResult.compiled,
-            compiledJob: jobResult.compiled,
-            kind: "job",
-            redactedCompiledJob,
-            status: "valid",
-        };
-    }
     if (compiledSemanticAction && redactedCompiledSemanticAction) {
         return { ...resolvedBase, compiledSemanticAction, kind: "semanticAction", redactedCompiledSemanticAction, status: "valid" };
     }

package/dist/extensions/agent-browser/lib/orchestration/native-session-defaults.js

@@ -75,7 +75,7 @@ async function readNativeIdentity(path, cwd, signal, rootFallback, browserComman
 export async function withNativeSessionDefaults(input, cwd, signal, run, root) {
     if (input.kind === "electron" && input.compiledElectron.action === "launch")
         return withAgentBrowserProcessEnvironment({ AGENT_BROWSER_SESSION: undefined }, () => run(input));
-    if (input.kind === "script" || input.kind === "electron" || isPlainTextInspectionArgs(input.toolArgs))
+    if (input.kind === "electron" || isPlainTextInspectionArgs(input.toolArgs))
         return run(input);
     const env = getAgentBrowserProcessEnvironment();
     const configArg = scanUpstreamGlobalFlagOccurrences(input.toolArgs, "--config")[0];
@@ -127,8 +127,8 @@ export async function withNativeSessionDefaults(input, cwd, signal, run, root) {
         ...(configPath !== undefined ? { AGENT_BROWSER_CONFIG: resolve(cwd, configPath) } : {}),
         ...(session !== undefined ? { AGENT_BROWSER_SESSION: session } : {}),
         ...(namespace !== undefined ? { AGENT_BROWSER_NAMESPACE: namespace } : {}),
-    }, () => run({ ...input, toolArgs: args, chromeStartupArgs, persistentChromeArgs, configuredChromeLaunch }, !rootDefault ? undefined : async (browserRun) => {
-        const daemon = await inspectManagedSessionDaemon({ cwd, signal, sessionName: rootDefault,
+    }, () => run({ ...input, toolArgs: args, chromeStartupArgs, persistentChromeArgs, configuredChromeLaunch }, !rootDefault ? undefined : async (browserRun, launchSignal = signal) => {
+        const daemon = await inspectManagedSessionDaemon({ cwd, signal: launchSignal, sessionName: rootDefault,
             namespace: scanUpstreamGlobalFlagOccurrences(args, "--namespace").at(-1)?.value ?? namespace, timeoutMs: 5_000 });
         if (daemon.status === "missing-binary")
             return {

package/dist/extensions/agent-browser/lib/orchestration/output-file.js

@@ -138,7 +138,7 @@ export async function applyAgentBrowserOutputPath(options) {
         return {
             ...options.result,
             content: appendOutputFileNotice(options.result, `Output file rejected: ${message}`, true),
-            details: { ...details, failureCategory: "validation-error", outputFile, resultCategory: "failure" },
+            details: { ...details, error: message, summary: "Output file rejected.", failureCategory: "validation-error", outputFile, resultCategory: "failure" },
             isError: true,
         };
     }
@@ -163,9 +163,9 @@ export async function applyAgentBrowserOutputPath(options) {
             ? (() => {
                 const rest = { ...options.result.details };
                 delete rest.successCategory;
-                return { ...rest, failureCategory: rest.failureCategory ?? "upstream-error", outputFile, resultCategory: "failure" };
+                return { ...rest, error: message, summary: "Output file failed.", failureCategory: rest.failureCategory ?? "upstream-error", outputFile, resultCategory: "failure" };
             })()
-            : { failureCategory: "upstream-error", outputFile, resultCategory: "failure" };
+            : { error: message, summary: "Output file failed.", failureCategory: "upstream-error", outputFile, resultCategory: "failure" };
         return {
             ...options.result,
             content: appendOutputFileNotice(options.result, `Output file failed: ${requestedPath} (${message}).`, true),

package/dist/extensions/agent-browser/lib/orchestration/script-mode.js

@@ -1,13 +1,12 @@
-import { open } from "node:fs/promises";
-import { AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES, AGENT_BROWSER_SCRIPT_IPC_MESSAGE_MAX_BYTES, AGENT_BROWSER_SCRIPT_SPILL_MAX_BYTES, createAgentBrowserScriptCloseArgs, isAgentBrowserScriptSessionName, validateAgentBrowserScriptBrowserParams, } from "../input-modes/script.js";
+import { stat } from "node:fs/promises";
+import { AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES, createAgentBrowserScriptCloseArgs, isAgentBrowserScriptSessionName, } from "../input-modes/script.js";
 import { isRecord } from "../parsing.js";
-import { parseCommandInfo, redactSensitiveText } from "../runtime.js";
-import { isSessionArtifactManifest } from "../results/artifact-manifest.js";
+import { redactSensitiveText } from "../runtime.js";
+import { attachInlineImage } from "../results/presentation/artifacts.js";
+import { projectAgentBrowserObservation } from "../results/presentation/content.js";
 import { redactPresentationData } from "../results/presentation/diagnostics.js";
-import { truncateText } from "../results/text.js";
 const SCRIPT_SESSION_ENTRY_TYPE = "agent-browser-script-session";
-const SCRIPT_BROWSER_SUMMARY_MAX_CHARS = 1_024;
-const SCRIPT_BROWSER_TEXT_MAX_CHARS = 8_192;
+// Retire outstanding pre-0.7 isolated-session leases when an old transcript resumes.
 export function getScriptSessionLeasesFromBranch(branch) {
     const leases = new Map();
     for (const entry of branch) {
@@ -16,284 +15,98 @@ export function getScriptSessionLeasesFromBranch(branch) {
         const { cleanup, closeCommandArgs, launchAttempted, sessionName } = entry.data;
         if (!isAgentBrowserScriptSessionName(sessionName))
             continue;
-        const expectedCloseCommandArgs = createAgentBrowserScriptCloseArgs(sessionName);
-        if ((cleanup !== "active" && cleanup !== "closed" && cleanup !== "failed")
-            || launchAttempted !== true
-            || !Array.isArray(closeCommandArgs)
-            || closeCommandArgs.length !== expectedCloseCommandArgs.length
-            || !closeCommandArgs.every((token, index) => token === expectedCloseCommandArgs[index]))
+        const expected = createAgentBrowserScriptCloseArgs(sessionName);
+        if ((cleanup !== "active" && cleanup !== "closed" && cleanup !== "failed") || launchAttempted !== true
+            || !Array.isArray(closeCommandArgs) || closeCommandArgs.length !== expected.length
+            || !closeCommandArgs.every((token, index) => token === expected[index]))
             continue;
-        leases.set(sessionName, { cleanup, closeCommandArgs: expectedCloseCommandArgs, launchAttempted: true, sessionName });
+        leases.set(sessionName, { cleanup, closeCommandArgs: expected, launchAttempted: true, sessionName });
     }
     return leases;
 }
 export function appendScriptSessionLease(pi, sessionName, cleanup) {
-    pi.appendEntry(SCRIPT_SESSION_ENTRY_TYPE, {
-        cleanup,
-        closeCommandArgs: createAgentBrowserScriptCloseArgs(sessionName),
-        launchAttempted: true,
-        sessionName,
-    });
+    pi.appendEntry(SCRIPT_SESSION_ENTRY_TYPE, { cleanup, closeCommandArgs: createAgentBrowserScriptCloseArgs(sessionName), launchAttempted: true, sessionName });
 }
-async function readVerifiedScriptSpill(result) {
-    const details = isRecord(result.details) ? result.details : undefined;
-    const path = typeof details?.fullOutputPath === "string" ? details.fullOutputPath : undefined;
-    const manifest = isSessionArtifactManifest(details?.artifactManifest) ? details.artifactManifest : undefined;
-    if (!path || !manifest?.entries.some((entry) => entry.kind === "spill"
-        && (entry.path === path || entry.absolutePath === path)
-        && (entry.storageScope === "persistent-session" || entry.storageScope === "process-temp")
-        && (entry.retentionState === "live" || entry.retentionState === "ephemeral")))
-        return undefined;
-    let handle;
-    try {
-        handle = await open(path, "r");
-        const stats = await handle.stat();
-        if (!stats.isFile() || stats.size < 0 || stats.size > AGENT_BROWSER_SCRIPT_SPILL_MAX_BYTES)
-            return undefined;
-        const buffer = Buffer.alloc(stats.size);
-        let offset = 0;
-        while (offset < buffer.length) {
-            const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
-            if (bytesRead === 0)
-                break;
-            offset += bytesRead;
-        }
-        const text = buffer.subarray(0, offset).toString("utf8");
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-    }
-}
-function getToolResultText(result) {
-    return result.content
-        .filter((item) => item.type === "text")
-        .map((item) => item.text)
-        .join("\n\n");
-}
-function stripOwnedScriptSessionArgs(args, sessionName) {
-    if (!isAgentBrowserScriptSessionName(sessionName))
-        return args;
-    if (args[0] === "--namespace" && args[1] === "" && args[2] === "--session" && args[3] === sessionName)
-        return args.slice(4);
-    return args[0] === "--session" && args[1] === sessionName ? args.slice(2) : args;
-}
-function getScriptCompatibleNextActions(value, sessionName) {
-    if (!Array.isArray(value))
-        return undefined;
-    const actions = value.flatMap((action) => {
-        if (!isRecord(action))
-            return [];
-        if (!isRecord(action.params))
-            return typeof action.artifactPath === "string" ? [action] : [];
-        if (Object.keys(action.params).some((key) => key !== "args" && key !== "stdin"))
-            return [];
-        if (!Array.isArray(action.params.args) || action.params.args.some((token) => typeof token !== "string"))
-            return [];
-        if (action.params.stdin !== undefined && typeof action.params.stdin !== "string")
-            return [];
-        const normalizedParams = {
-            args: stripOwnedScriptSessionArgs(action.params.args, sessionName),
-            ...(typeof action.params.stdin === "string" ? { stdin: action.params.stdin } : {}),
-        };
-        if (!validateAgentBrowserScriptBrowserParams(normalizedParams).params)
-            return [];
-        return [{ ...action, params: normalizedParams }];
-    });
-    return actions.length > 0 ? actions : undefined;
-}
-function scriptBrowserEnvelopeFitsIpc(envelope) {
-    try {
-        return Buffer.byteLength(JSON.stringify({ envelope, id: Number.MAX_SAFE_INTEGER, type: "response" }), "utf8") + 1 <= AGENT_BROWSER_SCRIPT_IPC_MESSAGE_MAX_BYTES;
-    }
-    catch {
-        return false;
-    }
-}
-function buildOversizedScriptBrowserEnvelope() {
-    const text = "Browser result exceeds the script IPC response limit; narrow the inner browser call output.";
-    return {
-        data: null,
-        details: { failureCategory: "upstream-error", resultCategory: "failure" },
-        error: text,
-        failureCategory: "upstream-error",
-        ok: false,
-        resultCategory: "failure",
-        summary: text,
-        text,
-    };
-}
-export async function buildScriptBrowserEnvelope(result, args, scriptSessionName) {
-    const details = isRecord(result.details) ? result.details : undefined;
-    const fullData = await readVerifiedScriptSpill(result);
-    const commandInfo = parseCommandInfo(args);
-    const data = redactPresentationData(commandInfo, fullData ?? details?.data ?? null);
-    const resultCategory = details?.resultCategory === "failure" || result.isError === true ? "failure" : "success";
-    const text = truncateText(redactSensitiveText(getToolResultText(result)), SCRIPT_BROWSER_TEXT_MAX_CHARS);
-    const summary = truncateText(redactSensitiveText(typeof details?.summary === "string" ? details.summary : text.split("\n", 1)[0] || "Browser call completed."), SCRIPT_BROWSER_SUMMARY_MAX_CHARS);
-    const compatibleNextActions = getScriptCompatibleNextActions(details?.nextActions, scriptSessionName);
-    const redactedNextActions = getScriptCompatibleNextActions(redactPresentationData(commandInfo, compatibleNextActions), undefined);
-    const failureCategory = resultCategory === "failure" && typeof details?.failureCategory === "string"
-        ? details.failureCategory
-        : undefined;
-    const successCategory = resultCategory === "success" && typeof details?.successCategory === "string"
-        ? details.successCategory
-        : undefined;
-    const envelopeDetails = redactPresentationData(commandInfo, {
-        artifactVerification: details?.artifactVerification,
-        artifacts: details?.artifacts,
-        failureCategory,
-        pageChangeSummary: details?.pageChangeSummary,
-        resultCategory,
-        successCategory,
-    });
-    const envelope = {
-        data,
-        details: isRecord(envelopeDetails) ? envelopeDetails : { resultCategory },
-        error: resultCategory === "failure" ? summary : undefined,
-        failureCategory,
-        nextActions: Array.isArray(redactedNextActions) ? redactedNextActions : undefined,
-        ok: resultCategory === "success",
-        resultCategory,
-        successCategory,
-        summary,
-        text,
-    };
-    return scriptBrowserEnvelopeFitsIpc(envelope) ? envelope : buildOversizedScriptBrowserEnvelope();
-}
-function collectUniqueArtifacts(results) {
-    const records = results.flatMap((result) => {
-        const details = isRecord(result.details) ? result.details : undefined;
-        return Array.isArray(details?.artifacts) ? details.artifacts.filter(isRecord) : [];
-    });
-    const unique = new Map(records.map((record) => [String(record.absolutePath ?? record.path ?? JSON.stringify(record)), record]));
-    return unique.size > 0 ? [...unique.values()] : undefined;
-}
-function collectScriptArtifactVerification(results) {
-    const entries = results.flatMap((result) => {
-        const details = isRecord(result.details) ? result.details : undefined;
-        const verification = isRecord(details?.artifactVerification) ? details.artifactVerification : undefined;
-        return Array.isArray(verification?.artifacts) ? verification.artifacts.filter(isRecord) : [];
-    });
-    const unique = [...new Map(entries.map((entry) => [String(entry.absolutePath ?? entry.path ?? JSON.stringify(entry)), entry])).values()];
-    if (unique.length === 0)
-        return undefined;
-    const count = (state) => unique.filter((entry) => entry.state === state).length;
-    return {
-        artifacts: unique,
-        missingCount: count("missing"),
-        pendingCount: count("pending"),
-        unverifiedCount: count("unverified"),
-        verified: unique.every((entry) => entry.state === "verified"),
-        verifiedCount: count("verified"),
-    };
-}
-function getLatestScriptResultDetail(results, key) {
-    for (let index = results.length - 1; index >= 0; index -= 1) {
-        const rawDetails = results[index]?.details;
-        const details = isRecord(rawDetails) ? rawDetails : undefined;
-        if (details?.[key] !== undefined)
-            return details[key];
-    }
-    return undefined;
-}
-function buildScriptCloseNextAction(sessionName) {
+export function createBrowserCodeOutput() {
+    const images = new Map();
+    const selected = new Map();
+    const receipts = new Map();
+    const fileArtifacts = new Map();
+    let selectedBytes = 0;
     return {
-        id: "close-script-session-after-cleanup-failure",
-        params: { args: createAgentBrowserScriptCloseArgs(sessionName) },
-        reason: "Retry closing the isolated wrapper-owned script session after automatic cleanup failed.",
-        safety: "Use these exact args; do not add profile, state, restore, namespace, or connection flags.",
-        tool: "agent_browser",
-    };
-}
-export function buildScriptToolResult(options) {
-    let data;
-    let serializedData;
-    let outputError;
-    try {
-        data = redactPresentationData({ command: "script" }, options.run.data);
-        serializedData = data === undefined ? undefined : JSON.stringify(data);
-        if (data !== undefined && serializedData === undefined)
-            throw new TypeError("Script output is not JSON-serializable.");
-        if (serializedData !== undefined && Buffer.byteLength(serializedData, "utf8") > AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES) {
-            throw new RangeError(`Redacted script output exceeds ${AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES} bytes.`);
-        }
-    }
-    catch {
-        data = undefined;
-        serializedData = undefined;
-        outputError = "Final script output could not be safely rendered as bounded JSON.";
-    }
-    const steps = options.run.steps.map((step) => ({ ...step, summary: redactSensitiveText(step.summary) }));
-    const rejectedFailureCategory = steps.find((step) => step.failureCategory === "policy-blocked")?.failureCategory
-        ?? (options.run.rejectedCallCount > 0 ? "validation-error" : undefined);
-    const failureCategory = options.cleanupError
-        ? "cleanup-failed"
-        : outputError ? "validation-error" : options.run.failureCategory ?? rejectedFailureCategory;
-    const failed = failureCategory !== undefined || !options.run.ok;
-    const failedStepCount = steps.filter((step) => !step.ok).length;
-    const failedCallCount = Math.max(0, failedStepCount - options.run.rejectedCallCount);
-    const successfulCallCount = steps.filter((step) => step.ok).length;
-    const cleanupSuffix = options.sessionName && !options.cleanupError ? " Isolated script session closed." : "";
-    const summary = `${options.cleanupError
-        ? `Script completed, but isolated session cleanup failed: ${redactSensitiveText(options.cleanupError)}`
-        : outputError
-            ? `Script failed: ${outputError}`
-            : options.run.ok
-                ? rejectedFailureCategory
-                    ? `Script failed: ${options.run.rejectedCallCount} browser call${options.run.rejectedCallCount === 1 ? " was" : "s were"} rejected before dispatch.`
-                    : failedCallCount > 0
-                        ? `Script completed (${options.run.callCount} browser call${options.run.callCount === 1 ? "" : "s"}; ${failedCallCount} returned failure for script handling).`
-                        : `Script completed (${options.run.callCount} browser call${options.run.callCount === 1 ? "" : "s"}).`
-                : `Script failed: ${redactSensitiveText(options.run.error ?? "sandbox execution failed")}`}${cleanupSuffix}`;
-    const dataText = serializedData === undefined ? "" : `\n\n${serializedData}`;
-    const cleanupActionText = options.cleanupError && options.sessionName
-        ? `\n\nNext action: ${JSON.stringify({ args: createAgentBrowserScriptCloseArgs(options.sessionName) })}`
-        : "";
-    const artifactManifest = getLatestScriptResultDetail(options.innerResults, "artifactManifest");
-    const artifactRetentionSummary = getLatestScriptResultDetail(options.innerResults, "artifactRetentionSummary");
-    const artifacts = collectUniqueArtifacts(options.innerResults);
-    const artifactVerification = collectScriptArtifactVerification(options.innerResults);
-    const nextActions = options.cleanupError && options.sessionName ? [buildScriptCloseNextAction(options.sessionName)] : undefined;
-    return {
-        content: [{ type: "text", text: `${summary}${dataText}${cleanupActionText}` }],
-        details: {
-            artifactManifest,
-            artifactRetentionSummary,
-            artifacts,
-            artifactVerification,
-            data,
-            failureCategory,
-            nextActions,
-            resultCategory: failed ? "failure" : "success",
-            scriptRun: {
-                aborted: options.run.aborted,
-                callCount: options.run.callCount,
-                emitCount: options.run.emitCount,
-                failedCallCount,
-                preDispatchRejectedCallCount: options.run.rejectedCallCount,
-                successfulCallCount,
-                timedOut: options.run.timedOut,
-            },
-            scriptSession: options.sessionName ? {
-                cleanup: options.cleanupError ? "failed" : "closed",
-                closeCommandArgs: createAgentBrowserScriptCloseArgs(options.sessionName),
-                ...(options.cleanupError ? { error: redactSensitiveText(options.cleanupError) } : {}),
-                launchAttempted: true,
-                sessionName: options.sessionName,
-            } : undefined,
-            scriptSteps: steps,
-            successCategory: failed ? undefined : "completed",
-            summary,
+        async observe(result) {
+            const details = isRecord(result.details) ? result.details : {};
+            const observation = projectAgentBrowserObservation(details, result.isError !== true);
+            for (const entry of observation.artifactVerification?.artifacts ?? [])
+                receipts.set(entry.absolutePath ?? entry.path, entry);
+            for (const artifact of observation.artifacts ?? [])
+                fileArtifacts.set(artifact.absolutePath, artifact);
+            if (observation.imageObservations) {
+                observation.imageObservations = await Promise.all(observation.imageObservations.map(async (image) => {
+                    const file = await stat(image.path);
+                    const id = `image-${images.size + 1}`;
+                    images.set(id, { observation: image, size: file.size, mtime: file.mtimeMs });
+                    return { ...image, id };
+                }));
+            }
+            return observation;
+        },
+        async emitImage(value) {
+            const id = isRecord(value) && typeof value.id === "string" ? value.id : undefined;
+            const image = id ? images.get(id) : undefined;
+            if (!id || !image)
+                throw new Error("emitImage expects an imageObservations handle returned by browser() in this code call.");
+            if (selected.has(id))
+                return;
+            if (selected.size >= 8 || selectedBytes + image.size > 20 * 1_024 * 1_024)
+                throw new Error("Selected images exceed the code output limit (8 images / 20 MiB). Emit fewer images.");
+            const file = await stat(image.observation.path);
+            if (!file.isFile() || file.size !== image.size || file.mtimeMs !== image.mtime)
+                throw new Error("The selected image changed since capture. Capture it again before emitting it.");
+            const presentation = await attachInlineImage({ content: [], summary: "Selected browser image" }, image.observation.path);
+            if (!presentation.content.some(item => item.type === "image")) {
+                throw new Error(presentation.content.filter(item => item.type === "text").map(item => item.text).join("\n") || "The selected image could not be attached.");
+            }
+            selected.set(id, presentation.content.filter(item => item.type === "image"));
+            selectedBytes += file.size;
+        },
+        async finish(run, sessionName, namespace) {
+            let data;
+            let outputError;
+            try {
+                data = redactPresentationData({ command: "code" }, run.data);
+                if (data !== undefined && Buffer.byteLength(JSON.stringify(data), "utf8") > AGENT_BROWSER_SCRIPT_FINAL_OUTPUT_MAX_BYTES)
+                    throw new Error("oversized");
+            }
+            catch {
+                data = undefined;
+                outputError = "Code output could not be rendered as bounded JSON.";
+            }
+            const failureCategory = outputError ? "validation-error" : run.failureCategory
+                ?? (run.rejectedCallCount > 0 ? "validation-error" : undefined);
+            const success = run.ok && failureCategory === undefined;
+            const artifacts = [...receipts.values()];
+            const count = (state) => artifacts.filter(entry => entry.state === state).length;
+            const artifactVerification = artifacts.length ? {
+                artifacts, missingCount: count("missing"), pendingCount: count("pending"), unverifiedCount: count("unverified"),
+                verifiedCount: count("verified"), verified: artifacts.every(entry => entry.state === "verified"),
+            } : undefined;
+            const observation = {
+                success, resultCategory: success ? "success" : "failure", failureCategory, data,
+                error: outputError ?? (run.error ? redactSensitiveText(run.error) : undefined),
+                sessionName, namespace,
+                codeRun: { callCount: run.callCount, emitCount: run.emitCount, failedCallCount: run.steps.filter(step => !step.ok).length, rejectedCallCount: run.rejectedCallCount, aborted: run.aborted, timedOut: run.timedOut },
+                failures: run.failures?.length ? run.failures : undefined,
+                artifactVerification,
+                artifacts: fileArtifacts.size ? [...fileArtifacts.values()] : undefined,
+                imageObservations: [...selected.keys()].map(id => ({ ...images.get(id).observation, id })),
+            };
+            const summary = success ? `Browser code completed (${run.callCount} calls).` : "Browser code failed.";
+            return {
+                content: [...selected.values()].flat(),
+                details: { ...observation, codeSteps: run.steps, summary },
+                isError: !success,
+            };
         },
-        isError: failed,
     };
 }