pi-agent-browser-native 0.3.0 → 0.5.0

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

@@ -1,3 +1,4 @@
+const BATCH_STDIN_EXAMPLE = ' Example: { "args": ["batch"], "stdin": "[[\\"get\\",\\"title\\"],[\\"get\\",\\"url\\"]]" }';
 // Mirror upstream commands::shell_words_split so policy inspection sees the same argv.
 export function parseBatchCommandArgument(command) {
     const tokens = [];
@@ -36,20 +37,20 @@ export function parseBatchCommandArgument(command) {
 function validateUserBatchStep(step, index) {
     if (!Array.isArray(step)) {
         return {
-            error: `agent_browser batch stdin step ${index} must be a non-empty array of string command tokens.`,
+            error: `agent_browser batch stdin step ${index} must be a non-empty array of string command tokens.${BATCH_STDIN_EXAMPLE}`,
             ok: false,
         };
     }
     if (step.length === 0) {
         return {
-            error: `agent_browser batch stdin step ${index} must not be empty.`,
+            error: `agent_browser batch stdin step ${index} must not be empty.${BATCH_STDIN_EXAMPLE}`,
             ok: false,
         };
     }
     const invalidTokenIndex = step.findIndex((token) => typeof token !== "string");
     if (invalidTokenIndex !== -1) {
         return {
-            error: `agent_browser batch stdin step ${index} token ${invalidTokenIndex} must be a string.`,
+            error: `agent_browser batch stdin step ${index} token ${invalidTokenIndex} must be a string.${BATCH_STDIN_EXAMPLE}`,
             ok: false,
         };
     }
@@ -62,13 +63,13 @@ export function parseBatchStdinJsonArray(stdin) {
     try {
         const parsed = JSON.parse(stdin);
         if (!Array.isArray(parsed)) {
-            return { error: "agent_browser batch stdin must be a JSON array of command steps." };
+            return { error: `agent_browser batch stdin must be a JSON array of command steps.${BATCH_STDIN_EXAMPLE}` };
         }
         return { steps: parsed };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return { error: `agent_browser batch stdin could not be parsed as JSON: ${message}` };
+        return { error: `agent_browser batch stdin could not be parsed as JSON: ${message}.${BATCH_STDIN_EXAMPLE}` };
     }
 }
 export function parseUserBatchStdin(stdin) {
@@ -86,6 +87,26 @@ export function parseUserBatchStdin(stdin) {
     }
     return { steps };
 }
+/**
+ * The batch steps upstream will actually execute: run_batch uses raw batch
+ * arguments exclusively when any exist and reads stdin only otherwise.
+ * Upstream filters only the exact `--bail` token, so an equals form such as
+ * `--bail=true` stays a raw command (an unknown-command row) and keeps stdin
+ * ignored.
+ */
+export function getUpstreamEffectiveBatchSteps(commandTokens, stdin) {
+    if (commandTokens[0] !== "batch")
+        return [];
+    const argumentSteps = commandTokens.slice(1).flatMap((command) => {
+        if (command === "--bail")
+            return [];
+        const step = parseBatchCommandArgument(command).step;
+        return step ? [step] : [];
+    });
+    if (argumentSteps.length > 0)
+        return argumentSteps;
+    return parseUserBatchStdin(stdin).steps ?? [];
+}
 export function parseValidBatchStepEntries(stdin) {
     const parsed = parseBatchStdinJsonArray(stdin);
     if (parsed.error || parsed.steps === undefined)

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

@@ -1,46 +1,126 @@
-import { extname, isAbsolute } from "node:path";
-import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "../../argv-grammar.js";
+import { lstatSync, readlinkSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { foldAgentBrowserFilesystemIdentity } from "../../argv-grammar.js";
+import { parseWaitCommandTokens } from "../../argv-descriptor.js";
 const SCREENSHOT_BOOLEAN_FLAGS = new Set(["--annotate", "--full", "-f"]);
 const SCREENSHOT_VALUE_FLAGS = new Set(["--screenshot-dir", "--screenshot-format", "--screenshot-quality"]);
-const SCREENSHOT_IMAGE_EXTENSIONS = new Set([".jpeg", ".jpg", ".png", ".webp"]);
-function isImagePathToken(token) {
-    const extension = extname(token).toLowerCase();
-    return SCREENSHOT_IMAGE_EXTENSIONS.has(extension);
+const SCREENSHOT_IMAGE_EXTENSIONS = [".jpeg", ".jpg", ".png", ".webp"];
+function isSingleScreenshotPathToken(token) {
+    const explicitlyRelative = token.startsWith("./") || token.startsWith("../");
+    if (token.startsWith("#") || token.startsWith("@") || (token.startsWith(".") && !explicitlyRelative && !token.includes("/")))
+        return false;
+    return explicitlyRelative || token.includes("/") || SCREENSHOT_IMAGE_EXTENSIONS.some((extension) => token.endsWith(extension));
+}
+function getScreenshotPositionalIndices(commandTokens) {
+    if (commandTokens[0] !== "screenshot")
+        return [];
+    const positionalIndices = [];
+    for (let index = 1; index < commandTokens.length; index += 1) {
+        const token = commandTokens[index];
+        if (SCREENSHOT_VALUE_FLAGS.has(token)) {
+            index += 1;
+            continue;
+        }
+        if (SCREENSHOT_BOOLEAN_FLAGS.has(token))
+            continue;
+        positionalIndices.push(index);
+    }
+    return positionalIndices;
 }
 export function getScreenshotPathTokenIndex(commandTokens) {
-    if (commandTokens[0] !== "screenshot") {
+    const positionalIndices = getScreenshotPositionalIndices(commandTokens);
+    if (positionalIndices.length === 0)
         return undefined;
+    const candidateIndex = positionalIndices.length >= 2 ? positionalIndices[1] : positionalIndices[0];
+    const candidate = commandTokens[candidateIndex];
+    if (positionalIndices.length >= 2 || isSingleScreenshotPathToken(candidate)) {
+        return candidateIndex;
     }
-    const positionalIndices = [];
-    for (let index = 1; index < commandTokens.length; index += 1) {
+    return undefined;
+}
+const DIFF_SCREENSHOT_VALUE_FLAGS = new Set(["-b", "--baseline", "-o", "--output", "-s", "--selector", "-t", "--threshold"]);
+function getDiffScreenshotOutputPath(commandTokens) {
+    let outputPath;
+    for (let index = 2; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
-        if (token === "--") {
-            for (let positionalIndex = index + 1; positionalIndex < commandTokens.length; positionalIndex += 1) {
-                positionalIndices.push(positionalIndex);
+        if (!DIFF_SCREENSHOT_VALUE_FLAGS.has(token))
+            continue;
+        const value = commandTokens[index + 1];
+        if (value === undefined)
+            return undefined;
+        if (token === "-o" || token === "--output")
+            outputPath = value;
+        index += 1;
+    }
+    return outputPath;
+}
+function foldArtifactPath(path, platform) {
+    return foldAgentBrowserFilesystemIdentity(path, platform);
+}
+function canonicalizeArtifactPath(absolutePath, platform, seenSymlinks) {
+    let cursor = absolutePath;
+    const suffix = [];
+    while (true) {
+        try {
+            const canonicalPath = join(realpathSync.native(cursor), ...suffix);
+            try {
+                const stats = statSync(canonicalPath, { bigint: true });
+                if (stats.ino > 0n)
+                    return `inode:${stats.dev}:${stats.ino}`;
+            }
+            catch {
+                // The destination does not exist yet; canonical ancestry still catches aliases.
             }
-            break;
+            return foldArtifactPath(canonicalPath, platform);
         }
-        if (token.startsWith("-")) {
-            const normalizedToken = token.split("=", 1)[0] ?? token;
-            if ((SCREENSHOT_VALUE_FLAGS.has(normalizedToken) || VALUE_FLAGS.has(normalizedToken)) && !token.includes("=")) {
-                index += 1;
-                continue;
+        catch {
+            let symlinkTarget;
+            try {
+                if (lstatSync(cursor).isSymbolicLink())
+                    symlinkTarget = resolve(dirname(cursor), readlinkSync(cursor));
             }
-            if (SCREENSHOT_BOOLEAN_FLAGS.has(normalizedToken) || GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(normalizedToken)) {
-                if (["true", "false"].includes(commandTokens[index + 1] ?? ""))
-                    index += 1;
-                continue;
+            catch { }
+            if (symlinkTarget) {
+                if (seenSymlinks.has(cursor))
+                    throw new Error(`Artifact destination contains a symlink loop: ${absolutePath}`);
+                if (seenSymlinks.size >= 32)
+                    throw new Error(`Artifact destination has too many symlink hops: ${absolutePath}`);
+                seenSymlinks.add(cursor);
+                return canonicalizeArtifactPath(join(symlinkTarget, ...suffix), platform, seenSymlinks);
             }
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                return foldArtifactPath(absolutePath, platform);
+            suffix.unshift(basename(cursor));
+            cursor = parent;
         }
-        positionalIndices.push(index);
     }
-    if (positionalIndices.length === 0) {
-        return undefined;
-    }
-    const candidateIndex = positionalIndices[positionalIndices.length - 1];
-    const candidate = commandTokens[candidateIndex];
-    if (positionalIndices.length >= 2 || isImagePathToken(candidate) || isAbsolute(candidate) || candidate.startsWith("./") || candidate.startsWith("../")) {
-        return candidateIndex;
+}
+export function canonicalizeExplicitArtifactDestination(cwd, destination, platform = process.platform) {
+    return canonicalizeArtifactPath(resolve(cwd, destination), platform, new Set());
+}
+export function getExplicitArtifactDestination(commandTokens) {
+    const command = commandTokens[0];
+    const subcommand = commandTokens[1];
+    if (command === "screenshot") {
+        const index = getScreenshotPathTokenIndex(commandTokens);
+        return index === undefined ? undefined : commandTokens[index];
     }
+    if (command === "download")
+        return commandTokens[2];
+    if (command === "pdf")
+        return commandTokens[1];
+    if (command === "wait")
+        return parseWaitCommandTokens(commandTokens).downloadPath;
+    if (command === "state" && subcommand === "save")
+        return commandTokens[2];
+    if (command === "diff" && subcommand === "screenshot")
+        return getDiffScreenshotOutputPath(commandTokens);
+    if (command === "network" && subcommand === "har" && commandTokens[2] === "stop")
+        return commandTokens[3];
+    if ((command === "trace" || command === "profiler") && subcommand === "stop")
+        return commandTokens[2];
+    if (command === "record" && (subcommand === "start" || subcommand === "restart"))
+        return commandTokens[2];
     return undefined;
 }

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

@@ -245,6 +245,7 @@ export async function collectClickDispatchDiagnostic(options) {
     const result = getEvalResultRecord(data);
     if (!result)
         return undefined;
+    options.probe.cleaned = true;
     const status = typeof result.status === "string" ? result.status : undefined;
     if (status !== "no-native-event-observed")
         return undefined;
@@ -264,7 +265,7 @@ export async function collectClickDispatchDiagnostic(options) {
     };
 }
 export async function cleanupClickDispatchProbe(options) {
-    if (!options.probe || !options.sessionName)
+    if (!options.probe || options.probe.cleaned || !options.sessionName)
         return;
     await runSessionCommandData({
         args: ["eval", "--stdin"],

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

@@ -7,8 +7,8 @@ import { isHttpOrHttpsUrl } from "../../input-modes/job.js";
 import { formatSessionArtifactRetentionSummary } from "../../results/artifact-manifest.js";
 import { buildNextToolAction, withOptionalSessionArgs } from "../../results/next-actions.js";
 import { buildVisibleRefFallbackDiagnosticFromSnapshot, getVisibleRefFallbackTarget } from "../../results/selector-recovery.js";
-import { extractRefSnapshotFromData, normalizeComparableUrl } from "../../session-page-state.js";
-import { redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
+import { extractRefSnapshotFromData, isAboutBlankUrl, normalizeComparableUrl } from "../../session-page-state.js";
+import { extractUpstreamCommandTokens, parseWaitCommandTokens, redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
 import { isRecord } from "../../parsing.js";
 import { getManagedSessionStateAccessValidationError, isFileUrl } from "../../managed-session-state-policy.js";
 import { extractBatchResultCommand, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, runSessionCommandData, } from "./session-state.js";
@@ -22,8 +22,14 @@ export async function collectNavigationSummary(options) {
     const url = extractStringResultField(await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal }), "url");
     if (!url || !/^[a-z][a-z0-9+.-]*:/i.test(url))
         return undefined;
-    if (isFileUrl(url))
+    if (isFileUrl(url) || isAboutBlankUrl(url))
         return { url };
+    // Reuse the title already observed for this exact URL instead of spending a second probe. Titles can
+    // change without a URL change on SPAs, but this summary is only a "last observed" page label; the URL
+    // stays live-probed on every call.
+    if (options.priorTarget?.title && normalizeComparableUrl(options.priorTarget.url) === normalizeComparableUrl(url)) {
+        return { title: options.priorTarget.title, url };
+    }
     const title = extractStringResultField(await runSessionCommandData({ args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal }), "title");
     return { title, url };
 }
@@ -390,14 +396,14 @@ function isBroadGetTextSelector(selector) {
     return normalized === "body" || normalized === "html" || normalized === ":root" || normalized === "*" || normalized === "main" || normalized === "div" || normalized === "section" || normalized === "article" || /^\[role=(?:"application"|'application'|application)\]$/i.test(normalized);
 }
 function getElectronTextScopeContext(options) {
-    const record = findElectronLaunchRecordForSession(options.sessionName, options.electronLaunchRecords);
+    const record = findElectronLaunchRecordForSession(options.sessionName, options.electronLaunchRecords, options.namespace);
     if (!record)
         return undefined;
     const url = options.currentTarget?.url ?? options.priorTarget?.url;
     return { launchId: record.launchId, sessionName: record.sessionName ?? options.sessionName, url };
 }
 export function getSourceLookupElectronContext(options) {
-    const record = findElectronLaunchRecordForSession(options.sessionName, options.electronLaunchRecords);
+    const record = findElectronLaunchRecordForSession(options.sessionName, options.electronLaunchRecords, options.namespace);
     if (!record)
         return undefined;
     const url = options.currentTarget?.url ?? options.priorTarget?.url;
@@ -469,9 +475,11 @@ export function formatEvalResultWarningText(warning) {
     return warning ? `Eval result warning: ${warning.reason} ${warning.suggestion}` : undefined;
 }
 export async function getArtifactCleanupGuidance(options) {
-    if (!options.succeeded || !isCloseCommand(options.command) || !options.manifest || options.manifest.entries.length === 0)
+    if (!options.succeeded || !isCloseCommand(options.command) || !options.manifest)
         return undefined;
     const explicitEntries = options.manifest.entries.filter((entry) => entry.storageScope === "explicit-path");
+    if (explicitEntries.length === 0)
+        return undefined;
     const explicitArtifactPaths = [];
     const seenPaths = new Set();
     for (const entry of explicitEntries) {
@@ -490,16 +498,15 @@ export async function getArtifactCleanupGuidance(options) {
         seenPaths.add(displayPath);
         explicitArtifactPaths.push(displayPath);
     }
+    if (explicitArtifactPaths.length === 0)
+        return undefined;
     return { explicitArtifactPaths, note: "Closing the browser session does not delete explicit screenshots, downloads, PDFs, traces, HAR files, or recordings; clean existing paths with host file tools when no longer needed.", owner: "host-file-tools", summary: formatSessionArtifactRetentionSummary(options.manifest) };
 }
 export function formatArtifactCleanupGuidanceText(guidance) {
-    if (!guidance)
+    if (!guidance || guidance.explicitArtifactPaths.length === 0)
         return undefined;
     const explicitCount = guidance.explicitArtifactPaths.length;
-    const explicitSummary = explicitCount === 0
-        ? "No existing explicit artifact paths were found in the recent manifest."
-        : `${explicitCount} explicit artifact${explicitCount === 1 ? "" : "s"} remain${explicitCount === 1 ? "s" : ""}; expand or inspect details.artifactCleanup.explicitArtifactPaths for paths.`;
-    return `Artifact lifecycle: ${explicitSummary} Browser close does not delete explicit screenshots, downloads, PDFs, traces, HAR files, or recordings; use host file tools for cleanup.`;
+    return `Artifact lifecycle: ${explicitCount} explicit artifact${explicitCount === 1 ? "" : "s"} remain${explicitCount === 1 ? "s" : ""}; expand or inspect details.artifactCleanup.explicitArtifactPaths for paths. Browser close does not delete explicit screenshots, downloads, PDFs, traces, HAR files, or recordings; use host file tools for cleanup.`;
 }
 async function collectManagedSessionCommandData(options) {
     try {
@@ -718,24 +725,18 @@ function getLastPositionalToken(args, startIndex = 1) {
     return undefined;
 }
 function getTimeoutStepArtifactPath(args) {
-    const [command] = args;
+    const commandArgs = extractUpstreamCommandTokens(args);
+    const [command] = commandArgs;
     if (command === "screenshot") {
-        const index = getScreenshotPathTokenIndex(args);
-        return index === undefined ? undefined : args[index];
+        const index = getScreenshotPathTokenIndex(commandArgs);
+        return index === undefined ? undefined : commandArgs[index];
     }
     if (command === "pdf")
-        return getLastPositionalToken(args);
+        return getLastPositionalToken(commandArgs);
     if (command === "download")
-        return getLastPositionalToken(args, 2);
-    if (command === "wait") {
-        const inlineDownload = args.find((token) => token.startsWith("--download="));
-        if (inlineDownload)
-            return inlineDownload.slice("--download=".length) || undefined;
-        const downloadIndex = args.indexOf("--download");
-        const downloadPath = downloadIndex >= 0 ? args[downloadIndex + 1] : undefined;
-        if (downloadPath && !downloadPath.startsWith("-"))
-            return downloadPath;
-    }
+        return getLastPositionalToken(commandArgs, 2);
+    if (command === "wait")
+        return parseWaitCommandTokens(commandArgs).downloadPath;
     return undefined;
 }
 async function statTimeoutArtifactPath(absolutePath) {

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

@@ -195,7 +195,7 @@ export async function prepareFinalResultRecoveryState(options) {
         }
     }
     const richInputRecoveryDiagnostic = buildRichInputRecoveryDiagnostic(visibleRefFallbackDiagnostic);
-    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation !== undefined);
+    const noActivePageSnapshotFailure = categoryDetails.resultCategory === "failure" && (isNoActivePageSnapshotFailure(options.executionPlan.commandInfo.command, options.errorText ?? options.presentation.summary) || options.batchRefSnapshotState?.invalidation?.reason === "no-active-page");
     const executionSessionKey = getSessionContextKey(options.executionPlan.sessionName, options.executionPlan.namespace);
     if (noActivePageSnapshotFailure && executionSessionKey) {
         const refUpdate = options.sessionPageState.applyRefSnapshotInvalidation({ invalidation: buildNoActivePageRefSnapshotInvalidation(), sessionName: executionSessionKey, update: options.sessionPageStateUpdate });
@@ -329,6 +329,18 @@ function buildResultNextActions(options) {
         append(buildAgentBrowserNextActions({ electron: { launchId: options.electronLaunchRecord.launchId, sessionName: options.electronLaunchRecord.sessionName, status: options.electronLaunchRecord.cleanupState }, failureCategory: options.categoryDetails.failureCategory, resultCategory: options.categoryDetails.resultCategory, successCategory: options.categoryDetails.successCategory }));
     return nextActions.length > 0 ? nextActions : undefined;
 }
+function formatFailureNextActionsText(options, nextActions) {
+    if (options.categoryDetails.resultCategory !== "failure" || !nextActions || nextActions.length === 0)
+        return undefined;
+    const lines = nextActions.slice(0, 6).map((action) => {
+        const params = action.params
+            ? { ...action.params, ...(action.params.stdin === undefined ? {} : { stdin: "[omitted; use details.nextActions]" }) }
+            : undefined;
+        const payload = action.artifactPath ? { artifactPath: action.artifactPath } : params;
+        return `- ${action.id}${payload ? ` ${JSON.stringify(payload)}` : ""}: ${action.reason}`;
+    });
+    return ["Next actions:", ...lines, "Use the exact redacted payloads in details.nextActions when available."].join("\n");
+}
 function buildAgentBrowserResultDetails(options, nextActions) {
     const publicVisibleRefFallbackDiagnostic = options.visibleRefFallbackDiagnostic ? sanitizeVisibleRefFallbackDiagnostic(options.visibleRefFallbackDiagnostic) : undefined;
     const rawPageChangeSummary = (options.scrollNoopDiagnostic || options.comboboxFocusDiagnostic) && options.presentation.pageChangeSummary ? { ...options.presentation.pageChangeSummary, nextActionIds: nextActions?.map((action) => action.id) } : options.presentation.pageChangeSummary;
@@ -357,6 +369,7 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         navigationSummary: options.navigationSummary,
         electron: options.electronLaunchRecord ? { action: "launch", cleanup: options.electronFailedConnectCleanup, handoff: options.electronHandoff, identifiers: buildElectronIdentifiers(options.electronLaunchRecord), launch: options.electronLaunchRecord, profileIsolation: options.electronProfileIsolationDetails, status: options.succeeded ? "succeeded" : "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined,
         ...options.categoryDetails,
+        agentBrowserStarted: options.processResult.agentBrowserStarted,
         aboutBlankSessionMismatch: options.aboutBlankSessionMismatch,
         electronPostCommandHealth: options.electronPostCommandHealth,
         electronRefFreshness: options.electronRefFreshnessDiagnostic,
@@ -434,7 +447,8 @@ export function buildFinalAgentBrowserToolResult(options) {
     const artifactCleanupText = formatArtifactCleanupGuidanceText(options.artifactCleanup);
     const timeoutPartialProgressText = options.timeoutPartialProgress ? formatTimeoutPartialProgressText(options.timeoutPartialProgress) : undefined;
     const managedSessionOutcomeText = formatManagedSessionOutcomeText(options.managedSessionOutcome);
-    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText].filter((item) => item !== undefined).join("\n\n");
+    const failureNextActionsText = formatFailureNextActionsText(options, nextActions);
+    const rawAppendedDiagnosticText = [visibleRefFallbackText, richInputRecoveryText, semanticActionCandidateText, clickDispatchText, overlayBlockerText, fillVerificationText, electronRefFreshnessText, selectorTextVisibilityText, electronBroadGetTextScopeText, scrollNoopDiagnosticText, comboboxFocusDiagnosticText, recordingDependencyWarningText, evalStdinHintText, evalResultWarningText, artifactCleanupText, timeoutPartialProgressText, managedSessionOutcomeText, failureNextActionsText].filter((item) => item !== undefined).join("\n\n");
     const appendedDiagnosticText = redactSensitiveText(redactExactSensitiveText(rawAppendedDiagnosticText, options.exactSensitiveValues));
     const shouldAppendDiagnosticText = appendedDiagnosticText.length > 0 && (!options.userRequestedJson || options.plainTextInspection);
     let content = shouldAppendDiagnosticText && options.redactedContent[0]?.type === "text" ? [{ ...options.redactedContent[0], text: `${options.redactedContent[0].text}\n\n${appendedDiagnosticText}` }, ...options.redactedContent.slice(1)] : options.redactedContent;
@@ -462,5 +476,5 @@ export async function buildMissingBinaryFailureResult(options) {
         missingBinaryElectronRecord = missingBinaryElectronCleanup.record;
     }
     const textParts = [errorText, managedSessionOutcomeText, missingBinaryElectronCleanup ? `Electron cleanup after failed attach: ${missingBinaryElectronCleanup.summary}` : undefined].filter((part) => part !== undefined && part.length > 0);
-    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
+    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { agentBrowserStarted: options.processResult.agentBrowserStarted, args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
 }

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

@@ -20,6 +20,7 @@ async function runAgentBrowserToolInContext(options) {
     const ownedManagedSession = prepared.ownedManagedSessionContext;
     return await withOwnedManagedSessionContext(ownedManagedSession, async () => {
         try {
+            const artifactRunStartedAtMs = Date.now();
             const processResult = await runAgentBrowserProcess({
                 args: prepared.processArgs,
                 cwd: options.cwd,
@@ -51,7 +52,7 @@ async function runAgentBrowserToolInContext(options) {
             });
             if (missingBinaryResult)
                 return missingBinaryResult;
-            const output = await processBrowserOutput({ ...options, prepared, processResult });
+            const output = await processBrowserOutput({ ...options, artifactRunStartedAtMs, prepared, processResult });
             applyBrowserRunStatePatch(options.state, output.statePatch);
             return output.result;
         }

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-policy.js

@@ -3,13 +3,14 @@ import { acquireManagedSessionPolicyLock } from "../../managed-session-policy-lo
 import { pruneOwnedManagedSessionRestoreSnapshots, resolveExplicitAutosaveInterval, } from "../../managed-session-restore.js";
 import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
 import { isRecord } from "../../parsing.js";
+import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
 import { runAgentBrowserProcess } from "../../process.js";
 import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
 import { redactInvocationArgs } from "../../runtime.js";
 const MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS = 35_000;
 const RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR = "AGENT_BROWSER_AUTOSAVE_INTERVAL_MS cannot change a running wrapper-owned headed session's launch-time periodic autosave interval. Close that session first, then retry with sessionMode: \"fresh\" so the new daemon starts with the requested interval.";
 export function getRunningHeadedAutosavePolicyChangeError(recordedInterval, closeCommand = false) {
-    const explicitInterval = resolveExplicitAutosaveInterval(process.env.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
+    const explicitInterval = resolveExplicitAutosaveInterval(getAgentBrowserProcessEnvironment().AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
     return recordedInterval !== undefined && !closeCommand && explicitInterval !== undefined && explicitInterval !== recordedInterval
         ? RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR
         : undefined;
@@ -79,7 +80,7 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
         if (options.mode === "close") {
             if (daemon.status === "active")
                 context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
-            return { lock };
+            return { daemonStatus: daemon.status, lock };
         }
         const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
         const hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
@@ -101,13 +102,14 @@ export async function acquireOwnedManagedSessionDaemonPolicy(options) {
             context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
         return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
             ? {
+                daemonStatus: daemon.status,
                 error: [
                     "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",
                     "Close that session first, retry with sessionMode: \"fresh\", or use a distinct explicit --session.",
                 ].join(" "),
                 lock,
             }
-            : { lock };
+            : { daemonStatus: daemon.status, lock };
     }
     catch (error) {
         await lock.release();
@@ -118,7 +120,7 @@ export async function closeManagedSession(options) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), options.timeoutMs);
     let stdoutSpillPath;
-    const closeArgs = [...(options.namespace ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
+    const closeArgs = [...(options.namespace !== undefined ? ["--namespace", options.namespace] : []), "--session", options.sessionName, "close"];
     const policyLock = options.policyLock ?? await acquireManagedSessionPolicyLock({
         namespace: options.namespace,
         sessionName: options.sessionName,