pi-agent-browser-native 0.9.1 → 0.9.3

package/dist/extensions/agent-browser/lib/read-confirmation.js

@@ -2,21 +2,40 @@ import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
 import { extractExplicitSessionName, getAgentBrowserSessionIdentityKey, resolveAgentBrowserNamespace, scanUpstreamGlobalFlagOccurrences } from "./argv-grammar.js";
 import { getExplicitReadUrl } from "./command-policy.js";
 import { isCloseCommand } from "./command-taxonomy.js";
+import { getExplicitNavigationTarget } from "./page-target-validation.js";
 import { isRecord } from "./parsing.js";
+import { getUpstreamEffectiveBatchSteps } from "./orchestration/batch-stdin.js";
 export function parseReadConfirmation(value) {
-    if (!isRecord(value) || value.source !== "native-explicit-url-read" || (value.state !== "pending" && value.state !== "cleared"))
+    if (!isRecord(value) || (value.source !== "native-explicit-url-read" && value.source !== "native-guarded-action") || (value.state !== "pending" && value.state !== "cleared"))
         return undefined;
     if (typeof value.id !== "string" || !value.id || typeof value.sessionName !== "string" || !value.sessionName || (value.namespace !== undefined && typeof value.namespace !== "string"))
         return undefined;
-    return { ...(isRecord(value.capabilities) && value.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: value.id, sessionName: value.sessionName, namespace: value.namespace, source: "native-explicit-url-read", state: value.state };
+    if (value.source === "native-guarded-action" && (typeof value.command !== "string" || !value.command || typeof value.action !== "string" || !value.action))
+        return undefined;
+    return { ...(value.source === "native-explicit-url-read" && isRecord(value.capabilities) && value.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: value.id, sessionName: value.sessionName, namespace: value.namespace, source: value.source, state: value.state,
+        ...(value.source === "native-guarded-action" ? { command: typeof value.command === "string" ? value.command : undefined, action: typeof value.action === "string" ? value.action : undefined } : {}),
+        ...(value.source === "native-guarded-action" && value.state === "cleared" && value.command === "snapshot" && value.action === "snapshot" && value.refSnapshotFresh === true ? { refSnapshotFresh: true } : {}) };
+}
+export function isBrowserIndependentConfirmation(value) {
+    return value?.source === "native-explicit-url-read" && value.capabilities?.readRequiresConfirmation === true;
+}
+export function suppressConfirmationPageHelpers(value) {
+    return value?.state === "pending" && (value.source === "native-guarded-action" || isBrowserIndependentConfirmation(value));
 }
-export function findReadConfirmation(args, confirmations, namespace) {
-    const tokens = extractUpstreamCommandTokens(args);
+export function isSuccessfulNativeConfirmedClose(commandTokens, data) {
+    return commandTokens[0] === "confirm" && commandTokens.length === 2 && isRecord(data) && data.confirmed === true
+        && data.action === "close" && isRecord(data.result) && data.result.success === true
+        && isRecord(data.result.data) && data.result.data.closed === true;
+}
+export function findReadConfirmation(args, confirmations, namespace, stdin) {
+    const command = extractUpstreamCommandTokens(args);
+    const tokens = command[0] === "batch" ? getUpstreamEffectiveBatchSteps(command, stdin)[0] ?? [] : command;
     if (tokens.length !== 2 || !["confirm", "deny"].includes(tokens[0]))
         return undefined;
     const sessionName = extractExplicitSessionName(args);
     const effectiveNamespace = resolveAgentBrowserNamespace(args, namespace);
     const matches = [...confirmations].filter(value => value.state === "pending" && value.id === tokens[1]
+        && (command[0] !== "batch" || value.source === "native-guarded-action")
         && (sessionName === undefined || getAgentBrowserSessionIdentityKey(sessionName, value.namespace) === getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace))
         && (effectiveNamespace === undefined || getAgentBrowserSessionIdentityKey(value.sessionName, effectiveNamespace) === getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace)));
     return matches.length === 1 ? matches[0] : undefined;
@@ -28,32 +47,53 @@ export function scopeReadConfirmationArgs(args, confirmation) {
         ...args,
     ];
 }
+export function getNativeTabContinuationGuidance(commandTokens, data) {
+    if (commandTokens[0] !== "tab" || commandTokens[1] !== "new" || !isRecord(data)
+        || data.confirmation_required !== true || typeof data.confirmation_id !== "string" || !data.confirmation_id || data.action !== "tab_new"
+        || !Object.keys(data).every(key => ["confirmation_required", "confirmation_id", "action", "capabilities", "after_confirmation", "guidance"].includes(key))
+        || !Array.isArray(data.after_confirmation) || data.after_confirmation.length !== 2 || data.after_confirmation[0] !== "open"
+        || typeof data.after_confirmation[1] !== "string" || !data.after_confirmation[1]
+        || data.after_confirmation[1] !== getExplicitNavigationTarget(commandTokens)
+        || typeof data.guidance !== "string" || !data.guidance.trim())
+        return undefined;
+    // Transport prose only: approval creates the tab; the continuation is never stored or executed.
+    return data.guidance;
+}
 export function nextReadConfirmation(options) {
     const { commandTokens: tokens, current } = options;
-    const settlesRead = current?.state === "pending" && tokens.length === 2 && ["confirm", "deny"].includes(tokens[0]) && tokens[1] === current.id;
-    const confirmedResult = settlesRead && tokens[0] === "confirm" && isRecord(options.data) && options.data.confirmed === true && options.data.action === "read" && isRecord(options.data.result)
-        ? options.data.result.data : options.data;
-    // Native control fields only. Never parse response content, snapshot text or nested page JSON as provenance.
-    if (isRecord(confirmedResult) && confirmedResult.confirmation_required === true && typeof confirmedResult.confirmation_id === "string" && confirmedResult.confirmation_id && !("content" in confirmedResult)) {
-        if (confirmedResult.action === "read" && (typeof getExplicitReadUrl(tokens) === "string" || settlesRead)) {
-            return { ...(isRecord(confirmedResult.capabilities) && confirmedResult.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: confirmedResult.confirmation_id, namespace: options.namespace, sessionName: options.sessionName, source: "native-explicit-url-read", state: "pending" };
+    const settles = current?.state === "pending" && tokens.length === 2 && ["confirm", "deny"].includes(tokens[0]) && tokens[1] === current.id;
+    const confirmed = settles && tokens[0] === "confirm" && isRecord(options.data) && options.data.confirmed === true
+        && options.data.action === (current.source === "native-explicit-url-read" ? "read" : current.action) && isRecord(options.data.result);
+    const control = confirmed && isRecord(options.data) && isRecord(options.data.result) ? options.data.result.data : options.data;
+    // Only native control fields and a validated tab transport continuation. Page output is never provenance.
+    if (options.succeeded && isRecord(control) && !Array.isArray(control) && control.confirmation_required === true
+        && typeof control.confirmation_id === "string" && control.confirmation_id && typeof control.action === "string" && control.action
+        && (Object.keys(control).every(key => ["confirmation_required", "confirmation_id", "action", "capabilities"].includes(key))
+            || getNativeTabContinuationGuidance(tokens, control) !== undefined)) {
+        const explicitRead = control.action === "read" && (typeof getExplicitReadUrl(tokens) === "string" || confirmed && current.source === "native-explicit-url-read");
+        if (explicitRead)
+            return { ...(isRecord(control.capabilities) && control.capabilities.readRequiresConfirmation === true ? { capabilities: { readRequiresConfirmation: true } } : {}), id: control.confirmation_id, namespace: options.namespace, sessionName: options.sessionName, source: "native-explicit-url-read", state: "pending" };
+        if (tokens[0] && !["confirm", "deny"].includes(tokens[0]) || confirmed && current.source === "native-guarded-action") {
+            return { id: control.confirmation_id, namespace: options.namespace, sessionName: options.sessionName, source: "native-guarded-action", command: confirmed ? current.command : tokens[0], action: control.action, state: "pending" };
         }
         if (current?.state === "pending")
             return { ...current, state: "cleared" };
     }
-    return options.succeeded && current?.state === "pending" && (settlesRead || isCloseCommand(tokens[0])) ? { ...current, state: "cleared" } : undefined;
+    return options.succeeded && current?.state === "pending" && (settles || isCloseCommand(tokens[0])) ? { ...current, state: "cleared" } : undefined;
 }
 export function buildReadConfirmationNextActions(confirmation, pendingResponse) {
     if (confirmation.state === "cleared")
         return [];
     const prefix = ["--namespace", confirmation.namespace ?? "", "--session", confirmation.sessionName];
     if (!pendingResponse)
-        return [{ id: "inspect-read-confirmation-session", tool: "agent_browser", params: { args: [...prefix, "session", "info"] }, reason: "Inspect the exact native session after the read confirmation failed; rerun the original URL read if its ID expired.", safety: "Read-only status, without browser launch or tab changes. Do not substitute a different pending confirmation ID." }];
+        return [{ id: "inspect-read-confirmation-session", tool: "agent_browser", params: { args: [...prefix, "session", "info"] }, reason: "Inspect the exact native session after the confirmation failed; rerun the original command if its ID expired.", safety: "Read-only status, without browser launch or tab changes. Do not substitute a different pending confirmation ID." }];
     return ["confirm", "deny"].map(command => ({
         id: command === "confirm" ? "approve-confirmation" : "deny-confirmation", tool: "agent_browser", params: { args: [...prefix, command, confirmation.id] },
-        reason: `${command === "confirm" ? "Approve" : "Deny"} the native confirmation for this explicit URL read.`,
-        safety: confirmation.capabilities?.readRequiresConfirmation === true
+        reason: `${command === "confirm" ? "Approve" : "Deny"} the native confirmation for ${confirmation.source === "native-explicit-url-read" ? "this explicit URL read" : `${confirmation.command} (${confirmation.action})`}.`,
+        safety: isBrowserIndependentConfirmation(confirmation)
             ? "Review the requested read first. The native capability proves ID matching; no DOM confirmation is implied."
-            : "Native ID matching/browser independence is unproven. The exact native session is preserved, but this confirmation retains normal page checks.",
+            : confirmation.source === "native-guarded-action"
+                ? "Review the original guarded action. Exact wrapper observation preserves its session and avoids overwriting helpers; native ID validation is not implied."
+                : "Native ID matching/browser independence is unproven. The exact native session is preserved, but this confirmation retains normal page checks.",
     }));
 }

package/dist/extensions/agent-browser/lib/results/confirmation.js

@@ -34,6 +34,9 @@ function getNestedConfirmationRecord(data) {
     return undefined;
 }
 export function detectConfirmationRequired(data) {
+    // Native confirm can acknowledge one action while its original compound command remains pending.
+    if (isRecord(data) && data.confirmed === true && isRecord(data.result) && data.result.success === true)
+        data = data.result.data;
     if (!isRecord(data)) {
         return undefined;
     }

package/dist/extensions/agent-browser/lib/results/envelope.js

@@ -47,6 +47,10 @@ export async function parseAgentBrowserEnvelope(options) {
     catch (error) {
         return { parseError: error instanceof Error ? error.message : String(error) };
     }
+    // ponytail: native text has no machine receipts; use JSON mode for structured evidence.
+    // JSON-looking page text must never become an envelope, confirmation, or batch row.
+    if (typeof options !== "string" && options.textOutput)
+        return { envelope: { success: true, data: stdout } };
     const trimmed = stdout.trim();
     const plainText = typeof options !== "string" && options.plainText === true;
     if (trimmed.length === 0 && !plainText) {
@@ -150,7 +154,7 @@ export function getAgentBrowserErrorText(options) {
     if (spawnError)
         return spawnError.message;
     if (parseError)
-        return parseError;
+        return exitCode !== 0 && stderr.trim() ? stderr.trim() : parseError;
     if (envelope?.success === false) {
         const explicitErrorText = extractEnvelopeErrorText(envelope.error);
         if ((hasStructuredBatchStepFailure(envelope.data) || detectConfirmationRequired(envelope.data)) && explicitErrorText === undefined) {

package/dist/extensions/agent-browser/lib/results/presentation/artifacts.js

@@ -6,6 +6,7 @@ import { getExplicitArtifactDestination } from "../../orchestration/browser-run/
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
 import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
+import { LIGHTPANDA_IMAGE_REASON } from "./common.js";
 import { formatRecordingReceipt, getRecordingReceipt } from "../recording.js";
 const PNG_HEADER = Buffer.from("89504e470d0a1a0a0000000d49484452", "hex");
 const INLINE_IMAGE_MAX_BYTES_ENV = "PI_AGENT_BROWSER_INLINE_IMAGE_MAX_BYTES";
@@ -220,6 +221,9 @@ async function buildPreviousRestartRecordingArtifact(options) {
         const recording = getRecordingReceipt(options.data.previousRecording);
         return recording ? buildFileArtifactMetadata({ ...options, commandInfo: { command: "record", subcommand: "restart-previous" }, path: recording.path, recording }) : undefined;
     }
+    // A rejected or pending restart has not acknowledged replacement of the active take.
+    if (!isRecord(options.data) || options.data.restarted !== true)
+        return undefined;
     const sessionKey = options.sessionName ? getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace) : undefined;
     const previousRecording = options.artifactManifest?.entries.find((entry) => (entry.command === "record" &&
         (entry.subcommand === "start" || entry.subcommand === "restart") &&
@@ -587,11 +591,16 @@ export async function attachInlineImage(presentation, imagePath, modelVisible =
             return presentation;
         const dimensions = getImageDimensions(header.toString("base64"), mimeType);
         presentation.imagePath = imagePath;
+        const lifecycle = isRecord(presentation.data) && isRecord(presentation.data.lifecycle) ? presentation.data.lifecycle : undefined;
+        const textRendered = isRecord(lifecycle?.effectiveLaunch) && lifecycle.effectiveLaunch.engine === "lightpanda";
         presentation.imageObservations = [{ path: imagePath, mimeType,
+                ...(textRendered ? { rendering: "text" } : {}),
                 pixels: dimensions ? { width: dimensions.widthPx, height: dimensions.heightPx } : undefined,
-                capture: "unknown", geometry: { status: "unknown", reason: dimensions ? "Capture geometry was not observed." : "Image dimensions could not be read from the bounded header." } }];
+                capture: "unknown", geometry: { status: "unknown", reason: textRendered ? LIGHTPANDA_IMAGE_REASON : dimensions ? "Capture geometry was not observed." : "Image dimensions could not be read from the bounded header." } }];
         if (!modelVisible)
             return presentation;
+        if (textRendered)
+            appendPresentationNotice(presentation, LIGHTPANDA_IMAGE_REASON);
         const inlineImageMaxBytes = getInlineImageMaxBytes();
         if (fileStats.size > inlineImageMaxBytes) {
             appendPresentationNotice(presentation, `Image attachment skipped: ${formatByteCount(fileStats.size)} exceeds the inline limit of ${formatByteCount(inlineImageMaxBytes)}.`);

package/dist/extensions/agent-browser/lib/results/presentation/common.js

@@ -2,6 +2,7 @@ import { isRecord } from "../../parsing.js";
 import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { stringifyUnknown, truncateText } from "../text.js";
 const UNTITLED_PAGE_SUMMARY = "(untitled page)";
+export const LIGHTPANDA_IMAGE_REASON = "Lightpanda screenshot is a text-rendered page representation, not a graphical capture; CSS/mouse coordinate mapping is unknown.";
 export function stringifyModelFacing(value) {
     return stringifyUnknown(redactSensitiveValue(value));
 }

package/dist/extensions/agent-browser/lib/results/presentation/diagnostics.js

@@ -1,4 +1,5 @@
 import { isRecord } from "../../parsing.js";
+import { getUpstreamEffectiveBatchSteps } from "../../orchestration/batch-stdin.js";
 import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, summarizeNetworkFailures } from "../network.js";
 import { withOptionalSessionArgs } from "../next-actions.js";
@@ -866,6 +867,8 @@ function redactStorageData(value) {
     if (!isRecord(value))
         return redactSensitiveValue(value);
     const entries = Object.fromEntries(Object.entries(value).map(([key, entryValue]) => {
+        if (key === "data" && isRecord(entryValue))
+            return [key, Object.fromEntries(Object.entries(entryValue).map(([storageKey, storageValue]) => [storageKey, shouldRevealStorageValue(storageKey, storageValue) ? redactSensitiveValue(storageValue) : "[REDACTED]"]))];
         if ((key === "entries" || key === "items") && Array.isArray(entryValue))
             return [key, entryValue.map((item) => isRecord(item) ? redactStorageEntryValue(item) : redactSensitiveValue(item))];
         if (key === "value") {
@@ -885,6 +888,9 @@ function redactStorageData(value) {
 }
 function formatStorageText(data) {
     const type = getStringField(data, "type") ?? getStringField(data, "storage") ?? "storage";
+    if (isRecord(data.data)) {
+        return Object.entries(data.data).map(([key, value]) => `${redactModelFacingText(key)}: ${formatStorageValue(key, value)}`).join("\n") || `${type}: no entries.`;
+    }
     const entries = getArrayField(data, "entries") ?? getArrayField(data, "items");
     if (entries) {
         if (entries.length === 0)
@@ -974,7 +980,34 @@ function redactStatefulValues(value, sensitiveKeys) {
         sensitiveKeys.has(key.toLowerCase()) ? "[REDACTED]" : redactStatefulValues(entryValue, sensitiveKeys),
     ]));
 }
-export function redactPresentationData(commandInfo, data) {
+function redactNativeContextText(commandInfo, text, stdin) {
+    if (commandInfo.command === "batch") {
+        const steps = getUpstreamEffectiveBatchSteps(commandInfo.commandTokens ?? ["batch"], stdin);
+        if (steps.some(step => step[0] === "cookies"))
+            text = redactNativeContextText({ command: "cookies" }, text);
+        if (steps.some(step => step[0] === "storage"))
+            text = redactNativeContextText({ command: "storage" }, text);
+        return text;
+    }
+    if (commandInfo.command === "cookies")
+        return text.replace(/^([^=\r\n]*)=([^\r\n]*)/gm, "$1=[REDACTED]");
+    if (commandInfo.command !== "storage")
+        return text;
+    const tokens = commandInfo.commandTokens;
+    const operation = tokens?.[2];
+    const key = operation === "get" ? tokens?.[3] : operation === "set" || operation === "clear" ? undefined : operation;
+    if (key !== undefined && text.startsWith(`${key}: `)) {
+        const suffix = text.endsWith("\n") ? "\n" : "";
+        const value = text.slice(key.length + 2, suffix ? -1 : undefined);
+        return `${key}: ${formatStorageValue(key, value)}${suffix}`;
+    }
+    // ponytail: native all-entry/raw-batch text does not escape multiline values.
+    // Format heuristics cannot separate lookalike entries; use structured JSON for sensitive storage.
+    return text.replace(/^([^\r\n]*?): ([^\r\n]*)/gm, (_line, key, value) => `${key}: ${formatStorageValue(key, value)}`);
+}
+export function redactPresentationData(commandInfo, data, stdin) {
+    if (typeof data === "string")
+        return redactSensitiveText(redactNativeContextText(commandInfo, data, stdin));
     if (commandInfo.command === "cookies")
         return redactStatefulValues(data, new Set(["value"]));
     if (commandInfo.command === "storage")

package/dist/extensions/agent-browser/lib/results/presentation/registry.js

@@ -1,4 +1,5 @@
 import { isRecord } from "../../parsing.js";
+import { getNativeTabContinuationGuidance } from "../../read-confirmation.js";
 import { detectConfirmationRequired } from "../confirmation.js";
 import { formatRawSnapshotText, formatSnapshotSummary } from "../snapshot.js";
 import { getPageSummary, omitUpstreamLifecycle, redactModelFacingText, stringifyModelFacing } from "./common.js";
@@ -225,7 +226,10 @@ export function formatPresentationSummary(commandInfo, data, compiledSemanticAct
 export function formatPresentationContentText(commandInfo, data, compiledSemanticAction) {
     const confirmationRequired = detectConfirmationRequired(data);
     if (confirmationRequired)
-        return formatConfirmationRequiredText(confirmationRequired);
+        return [
+            formatConfirmationRequiredText(confirmationRequired),
+            getNativeTabContinuationGuidance(commandInfo.commandTokens ?? [], data),
+        ].filter(Boolean).join("\n\n");
     const presenterText = commandInfo.command ? COMMAND_PRESENTERS[commandInfo.command]?.text?.(commandInfo, data) : undefined;
     if (presenterText)
         return presenterText;

package/dist/extensions/agent-browser/lib/results/presentation.js

@@ -53,6 +53,19 @@ export async function buildToolPresentation(options) {
     const { args, artifactManifest, artifactRequest, commandInfo, compiledSemanticAction, cwd, envelope, errorText, namespace, networkRouteDiagnostics, networkRoutes, persistentArtifactStore, sessionName, } = options;
     const commandInfoWithTokens = commandInfo.commandTokens || !args ? commandInfo : { ...commandInfo, commandTokens: extractUpstreamCommandTokens(args) };
     const presentationCommandInfo = resolvePresentationCommandInfo(commandInfoWithTokens, compiledSemanticAction);
+    if (options.textOutput) {
+        const text = String(redactPresentationData(commandInfoWithTokens, typeof envelope?.data === "string" ? envelope.data : "", options.stdin));
+        const failure = errorText ? buildErrorPresentation({ args, commandInfo, errorText, sessionName }) : undefined;
+        const presentation = {
+            ...failure,
+            content: options.modelVisible === false ? [] : [{ type: "text", text: [errorText, text].filter(Boolean).join("\n\n") }],
+            data: text,
+            summary: failure?.summary ?? (text.split("\n", 1)[0] || "Native text command completed."),
+        };
+        return sanitizeModelFacingPresentation(options.modelVisible === false ? presentation : await compactLargePresentationOutput({
+            artifactManifest, commandInfo, data: presentation.data, persistentArtifactStore, presentation,
+        }));
+    }
     const recordingCommand = commandInfo.command === "record";
     const recordingBatch = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(envelope?.data)
         && envelope.data.some((row) => row.command?.[0] === "record");
@@ -66,6 +79,7 @@ export async function buildToolPresentation(options) {
         data = { ...data, piCleanupOwnership: options.piCleanupOwnership ?? "unknown" };
     }
     const readConfirmation = nextReadConfirmation({ commandTokens: commandInfoWithTokens.commandTokens ?? [], data, namespace, sessionName: sessionName ?? "default", succeeded: envelope?.success !== false });
+    const confirmationRequired = detectConfirmationRequired(data);
     const presentationData = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)
         ? redactBatchSpillData(data)
         : redactPresentationData(commandInfoWithTokens, data);
@@ -93,7 +107,7 @@ export async function buildToolPresentation(options) {
             summary,
         });
     }
-    else if (options.modelVisible !== false && commandInfo.command === "snapshot" && isRecord(data)) {
+    else if (options.modelVisible !== false && commandInfo.command === "snapshot" && isRecord(data) && !confirmationRequired) {
         presentation = await buildSnapshotPresentation(data, persistentArtifactStore, artifactManifest);
     }
     else {
@@ -160,7 +174,6 @@ export async function buildToolPresentation(options) {
         secondaryPaths: presentationWithManifest.fullOutputPaths,
     }));
     presentationWithManifest.artifactVerification = buildArtifactVerificationSummary(artifacts, presentationWithManifest.artifactManifest, currentSpillPaths) ?? presentationWithManifest.artifactVerification;
-    const confirmationRequired = detectConfirmationRequired(data);
     const missingArtifactFailureText = formatMissingArtifactFailureText(presentationWithManifest.artifacts);
     if (!errorText && missingArtifactFailureText && hasMissingFileArtifact(presentationWithManifest.artifacts)) {
         presentationWithManifest.resultCategory = "failure";

package/dist/extensions/agent-browser/lib/results/selector-recovery.js

@@ -74,8 +74,8 @@ function getFindVisibleRefFallbackTarget(args, options = {}) {
 export function getVisibleRefFallbackTarget(options) {
     return getFindVisibleRefFallbackTarget(options.commandTokens, { allowLeadingDashFillText: true }) ?? (options.compiledSemanticAction ? getFindVisibleRefFallbackTarget(options.compiledSemanticAction.args, { allowLeadingDashFillText: true }) : undefined);
 }
-function getVisibleRefFallbackCandidates(target, snapshotData) {
-    const refs = getSnapshotRefRecord(snapshotData);
+function getVisibleRefFallbackCandidates(target, snapshotData, refSnapshot) {
+    const refs = refSnapshot?.refs ?? getSnapshotRefRecord(snapshotData);
     if (!refs)
         return [];
     const snapshotLineByRef = getSnapshotLineTextByRef(snapshotData);
@@ -85,7 +85,7 @@ function getVisibleRefFallbackCandidates(target, snapshotData) {
         if (!/^e\d+$/.test(ref) || !isRecord(entry))
             return [];
         const snapshotLine = snapshotLineByRef.get(ref);
-        const editableEvidence = getEditableRefEvidence({ ref: entry, text: snapshotLine });
+        const editableEvidence = refSnapshot ? refSnapshot.refs?.[ref]?.isEditable : getEditableRefEvidence({ ref: entry, text: snapshotLine });
         const role = getSnapshotRefRole(entry, editableEvidence);
         const name = typeof entry.name === "string" ? entry.name : undefined;
         if (!role || !name || !roleOrder.includes(role.toLowerCase()) || normalizeSemanticActionAccessibleName(name) !== targetName)
@@ -132,7 +132,7 @@ export function resolveVisibleRefActionFromSnapshot(options) {
     const target = getFindVisibleRefFallbackTarget(options.compiledAction.args, { allowLeadingDashFillText: true });
     if (!target)
         return undefined;
-    const snapshot = extractRefSnapshotFromData(options.snapshotData);
+    const snapshot = options.refSnapshot ?? extractRefSnapshotFromData(options.snapshotData);
     if (!snapshot)
         return undefined;
     const selectOptionValues = options.compiledAction.values && options.compiledAction.values.length > 0
@@ -141,7 +141,7 @@ export function resolveVisibleRefActionFromSnapshot(options) {
     const effectiveTarget = target.action === "select" && selectOptionValues
         ? { ...target, optionValues: selectOptionValues }
         : target;
-    const candidates = getVisibleRefFallbackCandidates(effectiveTarget, options.snapshotData);
+    const candidates = getVisibleRefFallbackCandidates(effectiveTarget, options.snapshotData, options.refSnapshot);
     if (effectiveTarget.action === "fill") {
         if (!options.allowFill || candidates.length !== 1 || effectiveTarget.text === undefined)
             return undefined;

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

@@ -157,6 +157,10 @@ function createBalancedJsonEndFinder(text) {
     };
 }
 function redactSerializedJson(text) {
+    if (text === "[REDACTED]")
+        return undefined;
+    if (!/^\s*[\[{"\d\-tfn]/.test(text))
+        return undefined;
     // Validate grammar only; rebuilding parsed values loses duplicates and numeric spelling.
     try {
         JSON.parse(text);
@@ -878,7 +882,7 @@ export function buildExecutionPlan(args, options) {
     const argvDescriptor = parseArgvDescriptor(args);
     const commandInfo = argvDescriptor.commandInfo;
     const commandNeedsManagedSession = !plainTextInspection && !options.browserIndependentReadConfirmation && needsManagedSession(argvDescriptor, options.stdin);
-    const effectiveArgs = plainTextInspection ? [...args] : args.includes("--json") ? [] : ["--json"];
+    const effectiveArgs = plainTextInspection ? [...args] : getBooleanFlagValue(args, "--json") !== undefined ? [] : ["--json"];
     let namespace = explicitNamespacePresent ? explicitNamespace ?? "" : undefined;
     if (plainTextInspection) {
         return {

package/dist/extensions/agent-browser/lib/session-page-state.js

@@ -4,7 +4,8 @@ import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNa
 import { getBrowserRecord, snapshotFromDefinition } from "./browser-transcript.js";
 import { isCloseCommand, isOpenNavigationCommand, isReadOnlyDiagnosticSessionTargetCommand, isRecordPageTransitionCommand, isUnverifiedPageTransitionCommand, isWebMcpPageMutationCommand, isWindowOrDiffPageTransitionCommand } from "./command-taxonomy.js";
 import { isRecord } from "./parsing.js";
-import { findReadConfirmation as findPendingReadConfirmation, parseReadConfirmation } from "./read-confirmation.js";
+import { detectConfirmationRequired } from "./results/confirmation.js";
+import { findReadConfirmation as findPendingReadConfirmation, isSuccessfulNativeConfirmedClose, parseReadConfirmation } from "./read-confirmation.js";
 import { getEditableRefEvidence } from "./results/editable-ref-evidence.js";
 import { enrichSnapshotRefEntries, getFullSnapshotData, getSnapshotRefEntries } from "./results/snapshot-refs.js";
 import { parseSnapshotLines } from "./results/snapshot-segments.js";
@@ -81,6 +82,10 @@ function extractBatchResultCommand(item) {
 }
 export function extractSessionTabTargetFromCommandData(commandTokens, data) {
     const [command, subcommand] = commandTokens;
+    if (command === "confirm" && isRecord(data) && data.confirmed === true && ["navigate", "url"].includes(String(data.action))
+        && isRecord(data.result) && data.result.success === true && !detectConfirmationRequired(data)) {
+        return extractSessionTabTargetFromData(data.result.data);
+    }
     if (command === "get" && subcommand === "url") {
         return normalizeSessionTabTarget({ url: extractStringResultField(data, "url") ?? extractStringResultField(data, "result") });
     }
@@ -93,7 +98,7 @@ export function extractSessionTabTargetFromBatchResults(data) {
     let currentTarget;
     let pendingTitle;
     for (const item of data) {
-        if (!isRecord(item))
+        if (!isRecord(item) || detectConfirmationRequired(item.result))
             continue;
         // Only this row's native identity can describe the active tab after it ran.
         if (currentTarget?.targetId)
@@ -108,7 +113,7 @@ export function extractSessionTabTargetFromBatchResults(data) {
         if (item.success === false)
             continue;
         const result = item.result;
-        if (isCloseCommand(name)) {
+        if (isCloseCommand(name) || isSuccessfulNativeConfirmedClose(commandTokens, result)) {
             currentTarget = undefined;
             pendingTitle = undefined;
             continue;
@@ -138,9 +143,7 @@ export function deriveSessionTabTarget(options) {
     if (isCloseCommand(options.command)) {
         return undefined;
     }
-    const commandDataTarget = isReadOnlyDiagnosticSessionTargetCommand(options.command, options.subcommand)
-        ? undefined
-        : extractSessionTabTargetFromData(options.data);
+    const commandDataTarget = extractSessionTabTargetFromCommandData([options.command, options.subcommand].filter((token) => token !== undefined), options.data);
     const observedTarget = normalizeSessionTabTarget(options.navigationSummary)
         ?? extractSessionTabTargetFromBatchResults(options.data)
         ?? commandDataTarget;
@@ -163,6 +166,8 @@ function extractRefSnapshotRefs(data) {
     return Object.keys(refs).length > 0 ? refs : undefined;
 }
 export function extractRefSnapshotFromData(value) {
+    if (detectConfirmationRequired(value))
+        return undefined;
     const data = getFullSnapshotData(value);
     if (!data)
         return undefined;
@@ -214,7 +219,7 @@ export function extractLatestRefSnapshotStateFromBatchResults(data) {
             continue;
         const commandTokens = extractUpstreamCommandTokens(extractBatchResultCommand(item));
         const [name] = commandTokens;
-        if (item.success !== false && isCloseCommand(name)) {
+        if (item.success !== false && !detectConfirmationRequired(item.result) && (isCloseCommand(name) || isSuccessfulNativeConfirmedClose(commandTokens, item.result))) {
             latestState = undefined;
             continue;
         }
@@ -258,6 +263,7 @@ export function getSessionPageStateKey(sessionName, namespace) {
     return sessionName ? getAgentBrowserSessionIdentityKey(sessionName, namespace) : undefined;
 }
 export class SessionPageState {
+    confirmActions = new Map();
     readConfirmations = new Map();
     refSnapshotInvalidations = new Map();
     refSnapshots = new Map();
@@ -281,6 +287,7 @@ export class SessionPageState {
     /** A command operates on its admitted state while the committed view is unavailable. */
     fork() {
         const state = new SessionPageState();
+        state.confirmActions = new Map(this.confirmActions);
         state.readConfirmations = new Map(this.readConfirmations);
         state.refSnapshotInvalidations = new Map(this.refSnapshotInvalidations);
         state.refSnapshots = new Map(this.refSnapshots);
@@ -293,7 +300,7 @@ export class SessionPageState {
         return state;
     }
     views() {
-        return new Map([...new Set([...this.tabTargets.keys(), ...this.tabTargetUnknownOrders.keys(), ...this.refSnapshots.keys(), ...this.refSnapshotInvalidations.keys()])].map(key => [key, this.get(key)]));
+        return new Map([...new Set([...this.confirmActions.keys(), ...this.tabTargets.keys(), ...this.tabTargetUnknownOrders.keys(), ...this.refSnapshots.keys(), ...this.refSnapshotInvalidations.keys()])].map(key => [key, this.get(key)]));
     }
     /** The same reducer commits live observations and replays selected journal envelopes. */
     applyBrowserRecord({ event, snapshot }) {
@@ -301,12 +308,6 @@ export class SessionPageState {
         const confirmation = parseReadConfirmation(event.state.readConfirmation);
         for (const page of event.pages ?? []) {
             const key = page.key;
-            if (event.phase === "begin") {
-                this.pending.set(key, { operationId: event.operationId, snapshot: this.refSnapshots.get(key) ?? this.pending.get(key)?.snapshot });
-                this.markTabTargetUnknown({ sessionName: key, update });
-                this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: buildPageTransitionRefSnapshotInvalidation("This browser operation has no persisted finish. Inspect the current URL and take a fresh snapshot before using refs; changes may already have happened.") });
-                continue;
-            }
             if (page.clear) {
                 this.clearSession(key);
                 continue;
@@ -314,6 +315,14 @@ export class SessionPageState {
             const pending = this.pending.get(key);
             if (event.phase === "finish" && pending && pending.operationId !== event.operationId)
                 continue;
+            if (page.confirmActions !== undefined)
+                this.setConfirmActions(key, page.confirmActions ?? undefined);
+            if (event.phase === "begin") {
+                this.pending.set(key, { operationId: event.operationId, snapshot: this.refSnapshots.get(key) ?? this.pending.get(key)?.snapshot });
+                this.markTabTargetUnknown({ sessionName: key, update });
+                this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: buildPageTransitionRefSnapshotInvalidation("This browser operation has no persisted finish. Inspect the current URL and take a fresh snapshot before using refs; changes may already have happened.") });
+                continue;
+            }
             if (page.unknown || page.refs.kind === "unknown") {
                 this.markTabTargetUnknown({ sessionName: key, update });
                 this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: page.refs.kind === "unknown" && page.refs.invalidation
@@ -361,6 +370,7 @@ export class SessionPageState {
         return this.updateOrder;
     }
     reset() {
+        this.confirmActions.clear();
         this.readConfirmations.clear();
         this.pending.clear();
         this.nativeGenerations.clear();
@@ -375,6 +385,7 @@ export class SessionPageState {
         if (!sessionName)
             return {};
         return {
+            ...(this.confirmActions.has(sessionName) ? { confirmActions: this.confirmActions.get(sessionName) } : {}),
             pinningReason: this.tabPinningReasons.get(sessionName),
             ...(this.tabTargets.get(sessionName)?.reopenPending !== undefined ? { tabReopenPending: this.tabTargets.get(sessionName)?.reopenPending } : {}),
             refSnapshot: stripRefSnapshotOrder(this.refSnapshots.get(sessionName)),
@@ -383,8 +394,14 @@ export class SessionPageState {
             tabTarget: this.tabTargets.get(sessionName)?.target,
         };
     }
-    findReadConfirmation(args, namespace) {
-        return findPendingReadConfirmation(args, [...this.readConfirmations.values()].map(entry => entry.value), namespace);
+    findReadConfirmation(args, namespace, stdin) {
+        return findPendingReadConfirmation(args, [...this.readConfirmations.values()].map(entry => entry.value), namespace, stdin);
+    }
+    setConfirmActions(sessionName, value) {
+        if (value !== undefined)
+            this.confirmActions.set(sessionName, value);
+        else
+            this.confirmActions.delete(sessionName);
     }
     getReadConfirmation(sessionKey) {
         return this.readConfirmations.get(sessionKey)?.value;
@@ -455,6 +472,7 @@ export class SessionPageState {
         return { ...this.get(options.sessionName), applied: true };
     }
     clearSession(sessionName) {
+        this.confirmActions.delete(sessionName);
         this.pending.delete(sessionName);
         this.nativeGenerations.delete(sessionName);
         this.readConfirmations.delete(sessionName);
@@ -466,6 +484,7 @@ export class SessionPageState {
     }
     clearNamespace(namespace) {
         const sessionKeys = new Set([
+            ...this.confirmActions.keys(),
             ...this.readConfirmations.keys(),
             ...this.refSnapshotInvalidations.keys(),
             ...this.refSnapshots.keys(),