pi-agent-browser-native 0.6.10 → 0.6.12

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

@@ -1,3 +1,4 @@
+import { stat } from "node:fs/promises";
 import { isCloseCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
 import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
@@ -194,7 +195,7 @@ async function buildBatchStepPresentation(options) {
     const redactedCommand = command ? redactInvocationArgs(command) : undefined;
     const commandText = formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index);
     const lifecycle = extractAgentBrowserLifecycle(item.result);
-    if (item.success === false) {
+    if (item.success === false && command?.[0] !== "record") {
         const redactedErrorData = redactBatchStepErrorData(command, item.error);
         const errorText = formatBatchStepError(redactedErrorData);
         const failureCategory = classifyAgentBrowserFailureCategory({
@@ -252,7 +253,9 @@ async function buildBatchStepPresentation(options) {
         commandInfo: commandInfoWithTokens,
         cwd,
         args: command,
-        envelope: { data: item.result, success: true },
+        envelope: { data: item.result, success: item.success !== false, error: item.error },
+        errorText: item.success === false ? formatBatchStepError(redactBatchStepErrorData(command, item.error)) : undefined,
+        piCleanupOwnership: options.piCleanupOwnership,
         networkRouteDiagnostics,
         namespace,
         persistentArtifactStore,
@@ -320,11 +323,18 @@ async function buildBatchStepPresentation(options) {
         presentation,
     };
 }
-function abandonedRecordingArtifact(artifact) {
+async function abandonedRecordingArtifact(artifact) {
     const { recordingState: _recordingState, willExistOnStop: _willExistOnStop, ...terminal } = artifact;
-    return { ...terminal, exists: false, status: "missing", subcommand: "close-abandoned" };
+    try {
+        const file = await stat(artifact.absolutePath);
+        return { ...terminal, exists: file.isFile(), sizeBytes: file.size, status: file.isFile() ? "unverified" : "missing", subcommand: "close-abandoned" };
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        return { ...terminal, exists: missing ? false : undefined, status: missing ? "missing" : "unverified", subcommand: "close-abandoned" };
+    }
 }
-function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
+async function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
     const artifacts = [];
     const pendingIndexesBySession = new Map();
     const removedPendingIndexes = new Set();
@@ -351,7 +361,7 @@ function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace)
         for (const pendingIndex of pendingIndexesBySession.get(session) ?? []) {
             const pending = artifacts[pendingIndex];
             if (pending && !removedPendingIndexes.has(pendingIndex))
-                artifacts[pendingIndex] = abandonedRecordingArtifact(pending);
+                artifacts[pendingIndex] = await abandonedRecordingArtifact(pending);
         }
     }
     return artifacts.filter((_, index) => !removedPendingIndexes.has(index));
@@ -372,6 +382,7 @@ export async function buildBatchPresentation(options) {
             cwd,
             index,
             item,
+            piCleanupOwnership: options.piCleanupOwnership,
             namespace,
             networkRoutes: currentNetworkRoutes,
             persistentArtifactStore: persistentArtifactStore ? { ...persistentArtifactStore, protectedPaths: protectedPersistentPaths } : undefined,
@@ -387,7 +398,7 @@ export async function buildBatchPresentation(options) {
     }
     const batchFailure = getBatchFailureDetails(steps);
     const images = steps.flatMap((step) => getPresentationImages(step.presentation));
-    const artifacts = coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace);
+    const artifacts = await coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace);
     const artifactVerification = buildArtifactVerificationSummary(artifacts);
     const fullOutputPaths = steps.flatMap((step) => getPresentationPaths({
         primaryPath: step.presentation.fullOutputPath,
@@ -399,7 +410,7 @@ export async function buildBatchPresentation(options) {
     }));
     const redactedBatchData = steps.map(({ details }) => (details.success
         ? { command: details.command, result: details.data, success: true }
-        : { command: details.command, error: details.text, success: false }));
+        : { command: details.command, error: details.text, ...(details.command?.[0] === "record" ? { result: details.data } : {}), success: false }));
     const unverifiedMutationCount = steps.filter((step) => step.details.pageChangeSummary?.changeType === "mutation" && step.details.pageChangeSummary.observed === false).length;
     const mutationEvidenceText = unverifiedMutationCount > 0
         ? `Mutation evidence: ${unverifiedMutationCount} action result${unverifiedMutationCount === 1 ? " proves" : "s prove"} dispatch only, not application state change. Use explicit later assertions or external receipts as postconditions; fixed waits are not postconditions.`

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

@@ -5,29 +5,9 @@ const UNTITLED_PAGE_SUMMARY = "(untitled page)";
 export function stringifyModelFacing(value) {
     return stringifyUnknown(redactSensitiveValue(value));
 }
-export function parseJsonPreviewString(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
-        return value;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return value;
-    }
-}
 export function redactModelFacingText(text) {
-    const parsed = parseJsonPreviewString(text);
-    if (parsed !== text) {
-        return stringifyModelFacing(parsed);
-    }
     return redactSensitiveText(text);
 }
-export function redactModelFacingTextIfSensitive(text) {
-    return /(?:@|\b(?:access[_-]?key|api[_-]?key|auth|authorization|basic|bearer|connection[_-]?string|cookie|database[_-]?url|db[_-]?url|mongo(?:db)?[_-]?uri|pass(?:word)?|private[_-]?key|redis[_-]?url|secret|session[_-]?id|token)\b)/i.test(text)
-        ? redactModelFacingText(text)
-        : text;
-}
 export function getArrayField(data, key) {
     return Array.isArray(data[key]) ? data[key] : undefined;
 }

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

@@ -1,9 +1,9 @@
 import { isRecord } from "../../parsing.js";
-import { isSensitiveFieldName, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, summarizeNetworkFailures } from "../network.js";
 import { withOptionalSessionArgs } from "../next-actions.js";
 import { stringifyUnknown, truncateText } from "../text.js";
-import { firstLine, formatCount, getArrayField, getStringField, parseJsonPreviewString, redactModelFacingText, redactModelFacingTextIfSensitive, stringifyModelFacing, } from "./common.js";
+import { firstLine, formatCount, getArrayField, getStringField, redactModelFacingText, stringifyModelFacing, } from "./common.js";
 const DIAGNOSTIC_REQUEST_PREVIEW_LIMIT = 40;
 const DIAGNOSTIC_LOG_PREVIEW_LIMIT = 80;
 const NETWORK_BODY_PREVIEW_MAX_CHARS = 280;
@@ -185,11 +185,11 @@ export function formatDiagnosticSummary(commandInfo, data) {
         }
         if (commandInfo.subcommand === "route") {
             const routed = getStringField(data, "routed") ?? getStringField(data, "url") ?? getStringField(data, "pattern");
-            return routed ? `Network route: ${redactModelFacingTextIfSensitive(routed)}` : "Network route configured";
+            return routed ? `Network route: ${redactSensitiveText(routed)}` : "Network route configured";
         }
         if (commandInfo.subcommand === "unroute") {
             const unrouted = getStringField(data, "unrouted") ?? getStringField(data, "url") ?? getStringField(data, "pattern");
-            return unrouted ? `Network unroute: ${redactModelFacingTextIfSensitive(unrouted)}` : "Network route removed";
+            return unrouted ? `Network unroute: ${redactSensitiveText(unrouted)}` : "Network route removed";
         }
         if (commandInfo.subcommand === "har") {
             const state = getStringField(data, "state") ?? getStringField(data, "status") ?? commandInfo.subcommand;
@@ -273,14 +273,33 @@ function formatSessionText(data) {
             const metadata = [
                 `active=${active ? "true" : "false"}`,
                 label ? `label=${redactModelFacingText(label)}` : undefined,
-                title ? `title=${redactModelFacingTextIfSensitive(title)}` : undefined,
-                url ? `url=${redactModelFacingTextIfSensitive(url)}` : undefined,
+                title ? `title=${redactSensitiveText(title)}` : undefined,
+                url ? `url=${redactSensitiveText(url)}` : undefined,
                 tabCount,
             ].filter(Boolean).join("; ");
             return `${index + 1}. name=${name}${active ? " *active*" : ""}; ${metadata}`;
         })
             .join("\n");
     }
+    if (typeof data.active === "boolean") {
+        const runtime = data.runtime;
+        const browser = isRecord(runtime) && isRecord(runtime.browser) ? runtime.browser : undefined;
+        const identity = [
+            `Daemon: ${data.active ? "active" : "inactive"}; PID: ${data.pid ?? "unknown"}`,
+            `Browser: ${browser?.status ?? "unknown"}; alive: ${browser?.alive ?? "unknown"}; Chrome PID: ${browser?.pid ?? "unknown"}`,
+            `Exact profile: ${browser?.userDataDir ?? "unknown"}`,
+            `Native browser ownership: ${browser?.ownership ?? "unknown"}; Pi cleanup ownership: ${data.piCleanupOwnership ?? "unknown"}`,
+        ].join("\n");
+        return `${redactModelFacingText(identity)}\n\n${stringifyModelFacing({
+            ...Object.fromEntries(["session", "namespace", "socketDir", "active", "pid", "version", "runtimeError"].map((key) => [key, data[key]])),
+            // Native runtime also includes restore check URLs, text and code; show status/identity only.
+            runtime: isRecord(runtime) ? Object.fromEntries([
+                "session", "namespace", "socketDir", "backgroundPid", "browserLaunched", "browser", "recording", "capabilities", "pageCount", "engine", "launchHash",
+                "compatibilityStatus", "restoreKey", "restoreStatus", "restoreLoadedPath", "restoreValidationPending",
+                "restoreSave", "saveStatus", "restoreSavedPath",
+            ].map((key) => [key, runtime[key]])) : runtime,
+        })}`;
+    }
     const session = getStringField(data, "session");
     return session ? `Current session: ${redactModelFacingText(session)}` : undefined;
 }
@@ -315,8 +334,7 @@ function getPreviewCandidate(item, keys) {
 function formatNetworkPreviewValue(value, maxChars) {
     if (value === undefined || value === null)
         return undefined;
-    const previewValue = typeof value === "string" ? parseJsonPreviewString(value) : value;
-    const redacted = redactSensitiveValue(previewValue);
+    const redacted = redactSensitiveValue(value);
     const raw = typeof redacted === "string" ? redacted : stringifyUnknown(redacted);
     const normalized = raw.replace(/\s+/g, " ").trim();
     if (normalized.length === 0)
@@ -797,7 +815,7 @@ function valueContainsStorageSecret(value) {
                 return true;
         }
         catch { }
-        if (redactSensitiveText(trimmed) !== trimmed || redactModelFacingTextIfSensitive(trimmed) !== trimmed)
+        if (redactSensitiveText(trimmed) !== trimmed)
             return true;
         try {
             return valueContainsStorageSecret(JSON.parse(trimmed));
@@ -830,13 +848,13 @@ function formatStorageValue(key, value) {
 }
 function redactStorageEntryValue(item) {
     if (!Object.hasOwn(item, "value"))
-        return redactStructuredPresentationValue(item);
+        return redactSensitiveValue(item);
     const key = getStringField(item, "key") ?? getStringField(item, "name");
     const value = item.value;
     if (shouldRevealStorageValue(key, value))
-        return redactStructuredPresentationValue(item);
+        return redactSensitiveValue(item);
     return {
-        ...redactStructuredPresentationValue({ ...item, value: undefined }),
+        ...redactSensitiveValue({ ...item, value: undefined }),
         value: "[REDACTED]",
         valueRedacted: true,
         valueRedactionReason: key && STORAGE_SECRET_KEY_PATTERN.test(key) ? "sensitive-key" : "sensitive-value",
@@ -846,15 +864,15 @@ function redactStorageData(value) {
     if (Array.isArray(value))
         return value.map((item) => redactStorageData(item));
     if (!isRecord(value))
-        return redactStructuredPresentationValue(value);
+        return redactSensitiveValue(value);
     const entries = Object.fromEntries(Object.entries(value).map(([key, entryValue]) => {
         if ((key === "entries" || key === "items") && Array.isArray(entryValue))
-            return [key, entryValue.map((item) => isRecord(item) ? redactStorageEntryValue(item) : redactStructuredPresentationValue(item))];
+            return [key, entryValue.map((item) => isRecord(item) ? redactStorageEntryValue(item) : redactSensitiveValue(item))];
         if (key === "value") {
             const itemKey = getStringField(value, "key") ?? getStringField(value, "name");
-            return [key, shouldRevealStorageValue(itemKey, entryValue) ? redactStructuredPresentationValue(entryValue) : "[REDACTED]"];
+            return [key, shouldRevealStorageValue(itemKey, entryValue) ? redactSensitiveValue(entryValue) : "[REDACTED]"];
         }
-        return [key, redactStructuredPresentationValue(entryValue)];
+        return [key, redactSensitiveValue(entryValue)];
     }));
     if (Object.hasOwn(value, "value")) {
         const key = getStringField(value, "key") ?? getStringField(value, "name");
@@ -899,7 +917,7 @@ function formatDialogText(data) {
         lines.push(`Type: ${redactModelFacingText(type)}`);
     const message = getStringField(data, "message");
     if (message)
-        lines.push(`Message: ${/(?:auth|authorization|bearer|cookie|pass(?:word)?|secret|session|token)/i.test(message) ? "[REDACTED]" : redactModelFacingText(message)}`);
+        lines.push(`Message: ${redactModelFacingText(message)}`);
     if (data.accepted === true)
         lines.push("Accepted.");
     if (data.dismissed === true)
@@ -910,7 +928,7 @@ function formatFrameText(data) {
     const frame = getStringField(data, "frame") ?? getStringField(data, "name") ?? getStringField(data, "selector");
     const url = getStringField(data, "url");
     const title = getStringField(data, "title");
-    const lines = [frame ? `Frame: ${redactModelFacingText(frame)}` : undefined, title ? `Title: ${redactModelFacingText(title)}` : undefined, url ? `URL: ${redactModelFacingTextIfSensitive(url)}` : undefined].filter(Boolean);
+    const lines = [frame ? `Frame: ${redactModelFacingText(frame)}` : undefined, title ? `Title: ${redactModelFacingText(title)}` : undefined, url ? `URL: ${redactSensitiveText(url)}` : undefined].filter(Boolean);
     return lines.length > 0 ? lines.join("\n") : undefined;
 }
 function formatStateText(data, subcommand) {
@@ -933,10 +951,10 @@ function formatStateText(data, subcommand) {
         return states
             .map((item, index) => {
             if (!isRecord(item))
-                return `${index + 1}. ${redactModelFacingTextIfSensitive(stringifyModelFacing(item))}`;
+                return `${index + 1}. ${stringifyModelFacing(item)}`;
             const name = getStringField(item, "name") ?? getStringField(item, "file") ?? getStringField(item, "path") ?? `(state ${index + 1})`;
             const url = getStringField(item, "url");
-            return url ? `${index + 1}. ${redactModelFacingText(name)} — ${redactModelFacingTextIfSensitive(url)}` : `${index + 1}. ${redactModelFacingText(name)}`;
+            return url ? `${index + 1}. ${redactModelFacingText(name)} — ${redactSensitiveText(url)}` : `${index + 1}. ${redactModelFacingText(name)}`;
         })
             .join("\n");
     }
@@ -946,23 +964,11 @@ function formatStateText(data, subcommand) {
         return "State cleared.";
     return undefined;
 }
-function redactStructuredPresentationValue(value) {
-    if (typeof value === "string")
-        return redactModelFacingTextIfSensitive(value);
-    if (Array.isArray(value))
-        return value.map((item) => redactStructuredPresentationValue(item));
-    if (!isRecord(value))
-        return value;
-    return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
-        key,
-        isSensitiveFieldName(key) ? "[REDACTED]" : redactStructuredPresentationValue(entryValue),
-    ]));
-}
 function redactStatefulValues(value, sensitiveKeys) {
     if (Array.isArray(value))
         return value.map((item) => redactStatefulValues(item, sensitiveKeys));
     if (!isRecord(value))
-        return redactStructuredPresentationValue(value);
+        return redactSensitiveValue(value);
     return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
         key,
         sensitiveKeys.has(key.toLowerCase()) ? "[REDACTED]" : redactStatefulValues(entryValue, sensitiveKeys),
@@ -973,13 +979,9 @@ export function redactPresentationData(commandInfo, data) {
         return redactStatefulValues(data, new Set(["value"]));
     if (commandInfo.command === "storage")
         return redactStorageData(data);
-    if (commandInfo.command === "session" && commandInfo.subcommand === "list")
-        return redactStructuredPresentationValue(data);
-    if (commandInfo.command === "state" && commandInfo.subcommand === "list")
-        return redactStructuredPresentationValue(data);
     if (commandInfo.command === "state" && commandInfo.subcommand === "show")
         return redactStatefulValues(data, new Set(["value"]));
-    return redactStructuredPresentationValue(data);
+    return redactSensitiveValue(data);
 }
 export function formatDiagnosticText(commandInfo, data) {
     if (commandInfo.command === "session")

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

@@ -203,6 +203,7 @@ export function buildErrorPresentation(options) {
             overlayBlockedClick: isOverlayBlockedClickError(presentationCommand ?? commandInfo.command, safeErrorText, args ?? commandInfo.commandTokens),
             resultCategory: "failure",
             sessionName,
+            subcommand: commandInfo.subcommand,
         }) ?? []),
     ];
     return {

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

@@ -1,7 +1,7 @@
 import { isNavigationObservableCommandName, isOpenNavigationCommand, isPageChangeSummaryCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
 import { detectConfirmationRequired } from "../confirmation.js";
-import { omitUpstreamLifecycle, redactModelFacingText, stringifyModelFacing } from "./common.js";
+import { firstLine, omitUpstreamLifecycle, redactModelFacingText, stringifyModelFacing } from "./common.js";
 const NAVIGATION_SUMMARY_FIELD = "navigationSummary";
 const GET_RESULT_FIELDS = {
     attr: "value",
@@ -25,7 +25,7 @@ function getScalarExtractionResult(commandInfo, data) {
     if (result === null || result === undefined)
         return "null";
     if (typeof result === "object")
-        return JSON.stringify(result);
+        return JSON.stringify(result, null, 2);
     return undefined;
 }
 function getExtractionOrigin(data) {
@@ -52,7 +52,7 @@ export function formatExtractionSummary(commandInfo, data) {
         return undefined;
     }
     const safeScalarResult = redactModelFacingText(scalarResult);
-    const firstResultLine = safeScalarResult.split("\n", 1)[0] ?? safeScalarResult;
+    const firstResultLine = firstLine(safeScalarResult);
     if (commandInfo.command === "get") {
         return `${formatGetSummaryLabel(commandInfo.subcommand)}: ${firstResultLine}`;
     }

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

@@ -1,10 +1,11 @@
 import { isRecord } from "../parsing.js";
+import { buildReadConfirmationNextActions, nextReadConfirmation } from "../read-confirmation.js";
 import { extractUpstreamCommandTokens, parseCommandInfo, redactInvocationArgs } from "../runtime.js";
 import { buildAgentBrowserNextActions } from "./action-recommendations.js";
 import { buildAgentBrowserResultCategoryDetails } from "./categories.js";
 import { detectConfirmationRequired } from "./confirmation.js";
 import { buildSnapshotPresentation } from "./snapshot.js";
-import { parseJsonPreviewString, redactModelFacingText, stringifyModelFacing } from "./presentation/common.js";
+import { redactModelFacingText } from "./presentation/common.js";
 import { applyArtifactManifest, attachInlineImage, buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts, classifyPresentationSuccessCategory, extractFileArtifacts, extractImagePath, formatArtifactMetadataLines, formatArtifactSummary, formatMissingArtifactFailureText, getSavedFileDetails, hasMissingFileArtifact, isManifestFileArtifact, } from "./presentation/artifacts.js";
 import { buildBatchPresentation, isAgentBrowserBatchResultArray, redactBatchStepErrorData } from "./presentation/batch.js";
 import { getPresentationPaths, isStringArray } from "./presentation/content.js";
@@ -18,8 +19,7 @@ function sanitizeModelFacingPresentation(presentation) {
     presentation.content = presentation.content.map((item) => {
         if (item.type !== "text")
             return item;
-        const parsed = parseJsonPreviewString(item.text);
-        return parsed === item.text ? item : { ...item, text: stringifyModelFacing(parsed) };
+        return { ...item, text: redactModelFacingText(item.text) };
     });
     presentation.summary = redactModelFacingText(presentation.summary);
     return presentation;
@@ -52,7 +52,10 @@ 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 (errorText) {
+    const recordingCommand = commandInfo.command === "record";
+    const recordingBatch = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(envelope?.data)
+        && envelope.data.some((row) => row.command?.[0] === "record");
+    if (errorText && !recordingCommand && !recordingBatch) {
         return buildErrorPresentation({
             args,
             commandInfo,
@@ -61,11 +64,15 @@ export async function buildToolPresentation(options) {
             sessionName,
         });
     }
-    const data = enrichStreamStatusData(commandInfoWithTokens, envelope?.data);
+    let data = enrichStreamStatusData(commandInfoWithTokens, envelope?.data);
+    if (commandInfo.command === "session" && commandInfo.subcommand === "info" && isRecord(data)) {
+        data = { ...data, piCleanupOwnership: options.piCleanupOwnership ?? "unknown" };
+    }
+    const readConfirmation = nextReadConfirmation({ commandTokens: commandInfoWithTokens.commandTokens ?? [], data, namespace, sessionName: sessionName ?? "default", succeeded: envelope?.success !== false });
     const presentationData = commandInfo.command === "batch" && isAgentBrowserBatchResultArray(data)
         ? redactBatchSpillData(data)
         : redactPresentationData(commandInfoWithTokens, data);
-    const artifacts = await extractFileArtifacts({ artifactManifest, artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs, artifactRequest, commandInfo: presentationCommandInfo, cwd, data, namespace, sessionName });
+    const artifacts = await extractFileArtifacts({ artifactManifest, artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs, artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs, artifactRequest, commandInfo: presentationCommandInfo, cwd, data, namespace, recordingOutcome: recordingCommand ? envelope?.success : undefined, recordingPending: options.recordingPending, sessionName });
     const artifactVerification = buildArtifactVerificationSummary(artifacts);
     const artifactSummary = formatArtifactSummary(artifacts);
     const summary = artifactSummary ?? formatPresentationSummary(commandInfoWithTokens, data, compiledSemanticAction);
@@ -83,6 +90,7 @@ export async function buildToolPresentation(options) {
             namespace,
             networkRoutes,
             persistentArtifactStore,
+            piCleanupOwnership: options.piCleanupOwnership,
             sessionName,
             summary,
         });
@@ -99,6 +107,12 @@ export async function buildToolPresentation(options) {
             summary,
         };
     }
+    if (errorText && (recordingCommand || recordingBatch)) {
+        const errorPresentation = buildErrorPresentation({ args, commandInfo, errorText, presentationCommand: presentationCommandInfo.command, sessionName });
+        presentation = { ...presentation, resultCategory: "failure", failureCategory: errorPresentation.failureCategory, summary: errorPresentation.summary,
+            content: [{ type: "text", text: `${errorPresentation.content[0]?.type === "text" ? errorPresentation.content[0].text : errorText}\n\n${presentation.content[0]?.type === "text" ? presentation.content[0].text : ""}` }],
+        };
+    }
     if (networkRouteDiagnostics && networkRouteDiagnostics.length > 0 && presentation.content[0]?.type === "text") {
         const diagnosticText = formatNetworkRouteDiagnosticsText(networkRouteDiagnostics);
         if (diagnosticText)
@@ -141,7 +155,7 @@ export async function buildToolPresentation(options) {
     presentationWithManifest.artifactVerification = buildArtifactVerificationSummary(artifacts, presentationWithManifest.artifactManifest, currentSpillPaths) ?? presentationWithManifest.artifactVerification;
     const confirmationRequired = detectConfirmationRequired(data);
     const missingArtifactFailureText = formatMissingArtifactFailureText(presentationWithManifest.artifacts);
-    if (missingArtifactFailureText && hasMissingFileArtifact(presentationWithManifest.artifacts)) {
+    if (!errorText && missingArtifactFailureText && hasMissingFileArtifact(presentationWithManifest.artifacts)) {
         presentationWithManifest.resultCategory = "failure";
         presentationWithManifest.failureCategory = "artifact-missing";
         presentationWithManifest.successCategory = undefined;
@@ -153,6 +167,21 @@ export async function buildToolPresentation(options) {
             presentationWithManifest.content.unshift({ type: "text", text: missingArtifactFailureText });
         }
     }
+    const failedRecording = presentationWithManifest.artifacts?.find((artifact) => artifact.recording?.success === false || artifact.recording?.output.encoderSucceeded === false);
+    if (failedRecording && !errorText) {
+        const failure = `Recording failed: ${failedRecording.recording?.error ?? "native capture/encoder failure"}`;
+        presentationWithManifest.resultCategory = "failure";
+        presentationWithManifest.failureCategory = "upstream-error";
+        presentationWithManifest.successCategory = undefined;
+        presentationWithManifest.summary = failure;
+        presentationWithManifest.content.unshift({ type: "text", text: failure });
+    }
+    if (readConfirmation?.state === "pending") {
+        presentationWithManifest.readConfirmation = readConfirmation;
+        presentationWithManifest.resultCategory = "failure";
+        presentationWithManifest.failureCategory = "confirmation-required";
+        presentationWithManifest.successCategory = undefined;
+    }
     if (!presentationWithManifest.resultCategory) {
         const categoryDetails = buildAgentBrowserResultCategoryDetails({
             artifacts: presentationWithManifest.artifacts,
@@ -160,7 +189,7 @@ export async function buildToolPresentation(options) {
             confirmationRequired: confirmationRequired !== undefined,
             errorText: envelope?.success === false ? presentationWithManifest.summary : undefined,
             savedFile: presentationWithManifest.savedFile,
-            succeeded: envelope?.success !== false,
+            succeeded: envelope?.success !== false && confirmationRequired === undefined,
         });
         presentationWithManifest.resultCategory = categoryDetails.resultCategory;
         presentationWithManifest.successCategory = categoryDetails.resultCategory === "success"
@@ -196,7 +225,7 @@ export async function buildToolPresentation(options) {
         ? buildNetworkRequestsNextActions(data, sessionName, presentationWithManifest.networkRouteDiagnostics)
         : undefined;
     const streamNextActions = presentationWithManifest.resultCategory === "success" ? buildStreamNextActions(commandInfoWithTokens, data, sessionName) : undefined;
-    presentationWithManifest.nextActions = mergeNextActions(presentationWithManifest.nextActions, genericNextActions, networkNextActions, streamNextActions);
+    presentationWithManifest.nextActions = readConfirmation ? buildReadConfirmationNextActions(readConfirmation, true) : mergeNextActions(presentationWithManifest.nextActions, genericNextActions, networkNextActions, streamNextActions);
     presentationWithManifest.pageChangeSummary = presentationWithManifest.pageChangeSummary ?? buildPageChangeSummary({
         artifacts: presentationWithManifest.artifacts,
         commandInfo: presentationCommandInfo,

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

@@ -0,0 +1,50 @@
+import { isRecord } from "../parsing.js";
+const RECORDING_QUALITY_WARNING = "Capture quality warning: repaint-driven capture, held/repeated or static frames, and late/final-state-only frames cannot establish UI smoothness. Output FPS is not captured-frame rate; inspect the recording and capture window before judging motion.";
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+export function getRecordingReceipt(value, outcome) {
+    if (!isRecord(value) || typeof value.path !== "string" || !value.path)
+        return undefined;
+    const capture = isRecord(value.capture) ? value.capture : {};
+    const output = isRecord(value.output) ? value.output : {};
+    const file = isRecord(value.file) ? value.file : {};
+    return {
+        warning: RECORDING_QUALITY_WARNING,
+        recordingId: text(value.recordingId), path: value.path,
+        success: typeof value.success === "boolean" ? value.success : value.success === null ? null : outcome ?? null,
+        error: text(value.error), frames: number(value.frames), capturedFrames: number(value.capturedFrames), fps: number(value.fps),
+        capture: {
+            startedAt: text(capture.startedAt), endedAt: text(capture.endedAt), durationMs: number(capture.durationMs),
+            firstFrameAt: text(capture.firstFrameAt), lastFrameAt: text(capture.lastFrameAt), firstFrameAfterMs: number(capture.firstFrameAfterMs), lastFrameAfterMs: number(capture.lastFrameAfterMs),
+            averageFps: number(capture.averageFps), maxFrameGapMs: number(capture.maxFrameGapMs), timestampSource: text(capture.timestampSource),
+        },
+        output: {
+            frames: number(output.frames ?? value.frames), fps: number(output.fps ?? value.fps), encodedFrames: number(output.encodedFrames),
+            durationMs: number(output.durationMs), durationSource: text(output.durationSource), heldFrames: number(output.heldFrames), droppedFrames: number(output.droppedFrames), skippedFrames: number(output.skippedFrames),
+            encoderSucceeded: typeof output.encoderSucceeded === "boolean" ? output.encoderSucceeded : null,
+        },
+        file: { exists: typeof file.exists === "boolean" ? file.exists : null, sizeBytes: number(file.sizeBytes) },
+    };
+}
+export function formatRecordingReceipt(receipt) {
+    const metric = (value, unit = "") => value === null ? "unknown" : `${value}${unit}`;
+    return [
+        `Recording ID: ${metric(receipt.recordingId)}`,
+        `Native recording outcome: ${receipt.success === true ? "succeeded" : receipt.success === false ? "failed" : "pending/unknown"}${receipt.error ? ` — ${receipt.error}` : ""}`,
+        `Capture started: ${metric(receipt.capture.startedAt)}; ended: ${metric(receipt.capture.endedAt)}`,
+        `Wall-clock capture duration: ${metric(receipt.capture.durationMs, " ms")}`,
+        `Captured frames (received, not pixel-unique): ${metric(receipt.capturedFrames)}`,
+        `Captured-frame rate: ${metric(receipt.capture.averageFps, " fps")}`,
+        `First frame: ${metric(receipt.capture.firstFrameAt)}; after start: ${metric(receipt.capture.firstFrameAfterMs, " ms")}`,
+        `Last frame: ${metric(receipt.capture.lastFrameAt)}; after start: ${metric(receipt.capture.lastFrameAfterMs, " ms")}`,
+        `Maximum frame gap: ${metric(receipt.capture.maxFrameGapMs, " ms")}; timestamp source: ${metric(receipt.capture.timestampSource)}`,
+        `Written frames: ${metric(receipt.output.frames)}; Encoded frames: ${metric(receipt.output.encodedFrames)}`,
+        `Held frames: ${metric(receipt.output.heldFrames)}; dropped frames: ${metric(receipt.output.droppedFrames)}; skipped frames: ${metric(receipt.output.skippedFrames)}`,
+        `Nominal/output FPS: ${metric(receipt.output.fps)}; output duration (encoded frames/fps): ${metric(receipt.output.durationMs, " ms")}`,
+        receipt.warning,
+    ].join("\n");
+}