pi-agent-browser-native 0.9.2 → 0.9.4

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

@@ -5,33 +5,43 @@ function resolveArtifactPath(cwd, path) {
     return isAbsolute(path) ? path : resolve(cwd, path);
 }
 function manifestContainsArtifact(manifest, cwd, artifact) {
-    if (!manifest)
+    if (!manifest) {
         return false;
+    }
     const requestedAbsolutePath = resolveArtifactPath(cwd, artifact.path);
     const expectedKind = artifact.kind === "screenshot" ? "image" : "video";
     return manifest.entries.some((entry) => {
         const entryAbsolutePath = entry.absolutePath ?? resolveArtifactPath(cwd, entry.path);
-        return entry.storageScope === "explicit-path" && entry.kind === expectedKind && entryAbsolutePath === requestedAbsolutePath && entry.retentionState === "live" && entry.exists === true;
+        return (entry.storageScope === "explicit-path" &&
+            entry.kind === expectedKind &&
+            entryAbsolutePath === requestedAbsolutePath &&
+            entry.retentionState === "live" &&
+            entry.exists === true);
     });
 }
 async function isArtifactRequired(artifact) {
-    if (artifact.required)
+    if (artifact.required) {
         return true;
-    return artifact.kind === "recording" && await executableExistsOnPath("ffmpeg");
+    }
+    return artifact.kind === "recording" && (await executableExistsOnPath("ffmpeg"));
 }
 export async function findRequestedArtifactCloseViolation(options) {
-    if (!isCloseCommand(options.command))
+    if (!isCloseCommand(options.command)) {
         return undefined;
-    const missingArtifacts = [];
-    for (const artifact of options.promptPolicy.requestedArtifacts) {
-        if (!await isArtifactRequired(artifact))
-            continue;
-        if (!manifestContainsArtifact(options.artifactManifest, options.cwd, artifact))
-            missingArtifacts.push(artifact);
     }
-    if (missingArtifacts.length === 0)
+    const requirements = await Promise.all(options.promptPolicy.requestedArtifacts.map(async (artifact) => ({
+        artifact,
+        required: await isArtifactRequired(artifact),
+    })));
+    const missingArtifacts = requirements
+        .filter(({ artifact, required }) => required && !manifestContainsArtifact(options.artifactManifest, options.cwd, artifact))
+        .map(({ artifact }) => artifact);
+    if (missingArtifacts.length === 0) {
         return undefined;
-    const missingList = missingArtifacts.map((artifact) => `${artifact.kind}: ${artifact.path}`).join(", ");
+    }
+    const missingList = missingArtifacts
+        .map((artifact) => `${artifact.kind}: ${artifact.path}`)
+        .join(", ");
     return {
         message: `Blocked browser close because requested artifact path${missingArtifacts.length === 1 ? " is" : "s are"} missing or unverified: ${missingList}. Save the requested artifact path first, or report why an optional artifact is unavailable before closing.`,
         missingArtifacts,

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-receipt-reconciliation.js

@@ -0,0 +1,198 @@
+import { resolve } from "node:path";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
+import { getRecordCommandOperands } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { extractEnvelopeErrorText } from "../../results/envelope.js";
+import { getRecordingReceipt } from "../../results/recording.js";
+import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
+import { diagnosticErrorText } from "./diagnostic-values.js";
+import { runSessionCommandData } from "./session-state.js";
+export function isRecordingStop(tokens) {
+    return tokens[0] === "record" && tokens[1] === "stop";
+}
+function rowError(row) {
+    return isRecord(row) ? row.error : undefined;
+}
+function rowResult(row) {
+    return isRecord(row) && isRecord(row.result) ? row.result : undefined;
+}
+function stopNeedsRecovery(options, row) {
+    return (options.processResult.timedOut ||
+        /no recording in progress/i.test(extractEnvelopeErrorText(rowError(row) ?? options.envelope?.error) ?? ""));
+}
+function reservationForStart(options, step, row) {
+    if (step[0] !== "record" || !["start", "restart"].includes(step[1] ?? "")) {
+        return undefined;
+    }
+    if (isRecord(row) && row.success === false) {
+        return undefined;
+    }
+    return buildStartReservation(options, step, rowResult(row));
+}
+function buildStartReservation(options, step, started) {
+    const path = typeof started?.path === "string" ? started.path : getRecordCommandOperands(step).path;
+    if (path === undefined ||
+        path === "" ||
+        options.sessionName === undefined ||
+        options.sessionName === "") {
+        return undefined;
+    }
+    return {
+        absolutePath: resolve(options.cwd, path),
+        cwd: options.cwd,
+        path,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        recordingId: typeof started?.recordingId === "string" ? started.recordingId : undefined,
+        startedAtMs: options.artifactRunStartedAtMs,
+    };
+}
+function recoverySource(options) {
+    const batch = options.commandTokens[0] === "batch";
+    return {
+        batch,
+        steps: batch
+            ? getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin)
+            : [options.commandTokens],
+        rows: batch && Array.isArray(options.envelope?.data) ? options.envelope.data : undefined,
+    };
+}
+function originalAttempt(options, stopRow) {
+    const error = options.processResult.timedOut
+        ? `Record stop timed out after ${options.processResult.timeoutMs ?? "undefined"} ms.`
+        : (extractEnvelopeErrorText(rowError(stopRow) ?? options.envelope?.error) ??
+            "Record stop did not return a receipt.");
+    return {
+        success: false,
+        exitCode: options.processResult.exitCode,
+        timedOut: options.processResult.timedOut,
+        error,
+        parseError: options.parseError,
+    };
+}
+function recordingAttemptWasInterrupted(options) {
+    return (options.processResult.aborted ||
+        (options.signal?.aborted ?? false) ||
+        !options.processResult.agentBrowserStarted);
+}
+export function planRecordingRecovery(options) {
+    if (recordingAttemptWasInterrupted(options)) {
+        return undefined;
+    }
+    const { batch, steps, rows } = recoverySource(options);
+    const stopIndex = steps.reduce((last, step, index) => isRecordingStop(step) && stopNeedsRecovery(options, rows?.at(index)) ? index : last, -1);
+    if (stopIndex < 0) {
+        return undefined;
+    }
+    let expected = options.reservation;
+    for (const [index, step] of steps.slice(0, stopIndex).entries()) {
+        expected = reservationForStart(options, step, rows?.at(index)) ?? expected;
+    }
+    return {
+        batch,
+        rows,
+        stopIndex,
+        expected,
+        attempt: originalAttempt(options, rows?.at(stopIndex)),
+    };
+}
+function receiptMatches(receipt, expected, nowMs) {
+    if (resolve(expected.cwd, receipt.path) !== expected.absolutePath) {
+        return false;
+    }
+    if (expected.recordingId !== undefined && expected.recordingId !== "") {
+        return receipt.recordingId === expected.recordingId;
+    }
+    const startedAtMs = Date.parse(receipt.capture.startedAt ?? "");
+    return (expected.startedAtMs !== undefined &&
+        startedAtMs >= expected.startedAtMs &&
+        startedAtMs <= nowMs);
+}
+function sameNativeSession(info, options) {
+    if (!isRecord(info) || typeof info.session !== "string" || options.sessionName === undefined) {
+        return false;
+    }
+    return (getAgentBrowserSessionIdentityKey(info.session, typeof info.namespace === "string" ? info.namespace : undefined) === getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace));
+}
+function reconcileNativeReceipts(info, options, expected) {
+    const recordings = nativeRecordingState(info);
+    const current = getRecordingReceipt(recordings?.current);
+    const unavailable = {
+        current,
+        status: "unavailable",
+        reason: "Native session info did not provide a matching recording receipt. File presence alone cannot prove successful recording finalization.",
+    };
+    if (!recordings) {
+        return unavailable;
+    }
+    if (!sameNativeSession(info, options)) {
+        return {
+            current,
+            status: "mismatch",
+            reason: "Native session info reported a different namespace/session; its recording receipt was not used.",
+        };
+    }
+    if (!expected) {
+        return unavailable;
+    }
+    for (const candidate of [recordings.current, recordings.last]) {
+        const receipt = getRecordingReceipt(candidate);
+        if (receipt && receiptMatches(receipt, expected, Date.now())) {
+            return { ...unavailable, receipt, data: candidate };
+        }
+    }
+    return {
+        current,
+        status: "mismatch",
+        reason: "Native recording IDs, paths or capture windows did not match this attempt; unrelated receipt measurements were not used.",
+    };
+}
+function nativeRecordingState(info) {
+    const runtime = isRecord(info) && isRecord(info.runtime) ? info.runtime : undefined;
+    return isRecord(runtime?.recording) ? runtime.recording : undefined;
+}
+export async function collectRecordingReceiptEvidence(options, expected) {
+    try {
+        const info = await runSessionCommandData({
+            args: ["session", "info"],
+            cwd: options.cwd,
+            namespace: options.namespace,
+            pinNamespace: true,
+            sessionName: options.sessionName,
+            signal: options.signal,
+            timeoutMs: 2_000,
+        });
+        return reconcileNativeReceipts(info, options, expected);
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            reason: `Native session info was unavailable: ${diagnosticErrorText(error)}. File presence alone cannot prove successful recording finalization.`,
+        };
+    }
+}
+export function anotherTakeUsesPath(evidence, expected) {
+    const { current, receipt } = evidence;
+    return (current !== undefined &&
+        receipt !== undefined &&
+        expected !== undefined &&
+        current.recordingId !== receipt.recordingId &&
+        resolve(expected.cwd, current.path) === expected.absolutePath);
+}
+function encodedOutputIsComplete(receipt) {
+    return (receipt.success === true &&
+        receipt.output.encoderSucceeded === true &&
+        receipt.output.encodedFrames !== null &&
+        receipt.output.encodedFrames > 0 &&
+        receipt.file.exists === true &&
+        receipt.file.sizeBytes !== null &&
+        receipt.file.sizeBytes > 0);
+}
+export function recordingHasTerminalMeasurements(evidence, expected) {
+    const receipt = evidence.receipt;
+    return (receipt !== undefined &&
+        encodedOutputIsComplete(receipt) &&
+        Number.isFinite(Date.parse(receipt.capture.startedAt ?? "")) &&
+        Number.isFinite(Date.parse(receipt.capture.endedAt ?? "")) &&
+        !anotherTakeUsesPath(evidence, expected));
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-recovery-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/extensions/agent-browser/lib/orchestration/browser-run/recording-recovery-presentation.js

@@ -0,0 +1,154 @@
+import { buildToolPresentation } from "../../results/presentation.js";
+import { isRecord } from "../../parsing.js";
+import { anotherTakeUsesPath, } from "./recording-receipt-reconciliation.js";
+export function recordingRecoveryData(plan, evidence) {
+    return (evidence.data ??
+        (plan.expected
+            ? { path: plan.expected.absolutePath, recordingId: plan.expected.recordingId, success: null }
+            : undefined));
+}
+export async function presentRecordingReceipt(options, plan, evidence, terminalMeasurements) {
+    const expected = plan.expected;
+    const data = recordingRecoveryData(plan, evidence);
+    return buildToolPresentation({
+        modelVisible: options.modelVisible,
+        artifactManifest: options.artifactManifest,
+        artifactMinUpdatedAtMs: expected?.startedAtMs ?? options.artifactRunStartedAtMs,
+        artifactMaxUpdatedAtMs: Date.now(),
+        artifactRequest: expected
+            ? {
+                path: expected.path,
+                absolutePath: expected.absolutePath,
+                status: terminalMeasurements ? undefined : "unverified",
+            }
+            : undefined,
+        commandInfo: { command: "record", subcommand: "stop" },
+        cwd: expected?.cwd ?? options.cwd,
+        envelope: { success: evidence.receipt?.success === true, data },
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        recordingPending: evidence.receipt
+            ? evidence.receipt.success === null
+            : options.processResult.timedOut,
+    });
+}
+export function classifyRecordingRecovery(evidence, plan, verified) {
+    const receipt = evidence.receipt;
+    if (!receipt) {
+        return { status: evidence.status, reason: evidence.reason };
+    }
+    if (verified) {
+        return {
+            status: "recovered",
+            reason: "Native terminal success and encoder measurements match the expected recording and the verified file.",
+        };
+    }
+    if (receipt.success === null) {
+        return {
+            status: "pending",
+            reason: "The matching native take is still pending; no terminal success was reported.",
+        };
+    }
+    if (!receipt.success) {
+        return {
+            status: "failed",
+            reason: `The matching native receipt reports failure: ${receipt.error ?? "unknown encoder/capture failure"}.`,
+        };
+    }
+    return {
+        status: "unverified",
+        reason: anotherTakeUsesPath(evidence, plan.expected)
+            ? "Another active recording uses this path. The previous receipt cannot verify the new take's file."
+            : "A matching receipt was found, but successful encoding and a matching fresh file could not both be verified.",
+    };
+}
+export function repairRecordingEnvelope(options, plan, data, verified) {
+    if (plan.rows) {
+        const rows = plan.rows.map((row, index) => index === plan.stopIndex && isRecord(row)
+            ? { ...row, result: data, success: verified, error: verified ? undefined : row.error }
+            : row);
+        const healed = verified &&
+            !options.processResult.timedOut &&
+            rows.every((row) => isRecord(row) && row.success === true);
+        return {
+            healed,
+            envelope: {
+                success: healed,
+                data: rows,
+                error: healed ? undefined : options.envelope?.error,
+            },
+        };
+    }
+    if (!plan.batch) {
+        return {
+            healed: verified,
+            envelope: { success: verified, data, error: verified ? undefined : plan.attempt.error },
+        };
+    }
+    return { healed: false, envelope: options.envelope };
+}
+function recordingSessionArgs(options, command) {
+    return [
+        "--namespace",
+        options.namespace ?? "",
+        "--session",
+        options.sessionName ?? "",
+        ...command,
+    ];
+}
+function pendingTakeIsCurrent(evidence, recovery) {
+    return (evidence.current !== undefined &&
+        evidence.receipt !== undefined &&
+        evidence.current.recordingId === evidence.receipt.recordingId &&
+        recovery.status === "pending");
+}
+function buildRecordingFollowups(options, evidence, recovery) {
+    if (options.sessionName === undefined || options.sessionName === "") {
+        return [];
+    }
+    const actions = recovery.healed
+        ? []
+        : [
+            {
+                id: "inspect-recording-receipt",
+                tool: "agent_browser",
+                params: { args: recordingSessionArgs(options, ["session", "info"]) },
+                reason: "Inspect the native current/last recording receipts for this exact session.",
+                safety: "Read-only status; does not launch or retarget the browser. Do not infer encoding success from an existing file.",
+            },
+        ];
+    if (pendingTakeIsCurrent(evidence, recovery)) {
+        actions.push({
+            id: "stop-pending-recording",
+            tool: "agent_browser",
+            params: { args: recordingSessionArgs(options, ["record", "stop"]) },
+            reason: `Finalize the still-current native recording ${evidence.receipt?.recordingId ?? "null"}; it has not reported a terminal outcome.`,
+            safety: "Run only while this same recording remains current. No repeated stop was dispatched during recovery.",
+        });
+    }
+    return actions;
+}
+export function finishRecordingPresentation(options, presentation, evidence, recovery) {
+    const content = [...presentation.content];
+    if (options.modelVisible !== false) {
+        content.unshift({
+            type: "text",
+            text: `Recording receipt recovery (${recovery.status}): ${recovery.reason}\nOriginal attempt: ${recovery.attempt.error}`,
+        });
+    }
+    const failure = recovery.healed
+        ? {}
+        : {
+            resultCategory: "failure",
+            failureCategory: options.processResult.timedOut ? "timeout" : "upstream-error",
+            successCategory: undefined,
+            summary: `${recovery.attempt.error} ${recovery.reason}`,
+        };
+    return {
+        ...presentation,
+        ...failure,
+        content,
+        nextActions: buildRecordingFollowups(options, evidence, recovery),
+        recordingRecovery: recovery,
+    };
+}

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

@@ -1,163 +1,80 @@
-import { resolve } from "node:path";
-import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
-import { getRecordCommandOperands } from "../../command-taxonomy.js";
-import { isRecord } from "../../parsing.js";
-import { isPendingRecordingArtifact, mergeSessionArtifactManifest } from "../../results/artifact-manifest.js";
-import { extractEnvelopeErrorText } from "../../results/envelope.js";
+import { isPendingRecordingArtifact, mergeSessionArtifactManifest, } from "../../results/artifact-manifest.js";
 import { appendUniqueAgentBrowserNextActions } from "../../results/next-actions.js";
-import { buildToolPresentation } from "../../results/presentation.js";
-import { buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts } from "../../results/presentation/artifacts.js";
-import { getRecordingReceipt } from "../../results/recording.js";
-import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
-import { runSessionCommandData } from "./session-state.js";
-function isStop(tokens) {
-    return tokens[0] === "record" && tokens[1] === "stop";
-}
-function receiptMatches(receipt, expected, nowMs) {
-    if (resolve(expected.cwd, receipt.path) !== expected.absolutePath)
-        return false;
-    if (expected.recordingId)
-        return receipt.recordingId === expected.recordingId;
-    const startedAtMs = Date.parse(receipt.capture.startedAt ?? "");
-    return expected.startedAtMs !== undefined && startedAtMs >= expected.startedAtMs && startedAtMs <= nowMs;
-}
+import { buildArtifactVerificationSummary, buildManifestEntriesForFileArtifacts, } from "../../results/presentation/artifacts.js";
+import { collectRecordingReceiptEvidence, isRecordingStop, planRecordingRecovery, recordingHasTerminalMeasurements, } from "./recording-receipt-reconciliation.js";
+import { classifyRecordingRecovery, finishRecordingPresentation, presentRecordingReceipt, repairRecordingEnvelope, recordingRecoveryData, } from "./recording-recovery-presentation.js";
 export async function recoverRecordingStop(options) {
-    const batch = options.commandTokens[0] === "batch";
-    const steps = batch ? getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin) : [options.commandTokens];
-    const rows = batch && Array.isArray(options.envelope?.data) ? options.envelope.data : undefined;
-    const stopIndex = steps.reduce((last, step, index) => isStop(step) && (options.processResult.timedOut
-        || /no recording in progress/i.test(extractEnvelopeErrorText(rows?.[index]?.error ?? options.envelope?.error) ?? "")) ? index : last, -1);
-    if (stopIndex < 0 || options.processResult.aborted || options.signal?.aborted || !options.processResult.agentBrowserStarted)
+    const plan = planRecordingRecovery(options);
+    if (!plan) {
         return undefined;
-    let expected = options.reservation;
-    for (let index = 0; index < stopIndex; index += 1) {
-        const step = steps[index];
-        if (step[0] !== "record" || !["start", "restart"].includes(step[1]))
-            continue;
-        const row = rows?.[index];
-        if (isRecord(row) && row.success === false)
-            continue;
-        const started = isRecord(row) && isRecord(row.result) ? row.result : undefined;
-        const path = typeof started?.path === "string" ? started.path : getRecordCommandOperands(step).path;
-        if (path && options.sessionName)
-            expected = {
-                absolutePath: resolve(options.cwd, path), cwd: options.cwd, path, namespace: options.namespace, sessionName: options.sessionName,
-                recordingId: typeof started?.recordingId === "string" ? started.recordingId : undefined, startedAtMs: options.artifactRunStartedAtMs,
-            };
     }
-    const attemptError = options.processResult.timedOut
-        ? `Record stop timed out after ${options.processResult.timeoutMs} ms.`
-        : extractEnvelopeErrorText(rows?.[stopIndex]?.error ?? options.envelope?.error) ?? "Record stop did not return a receipt.";
+    const evidence = await collectRecordingReceiptEvidence(options, plan.expected);
+    const terminalMeasurements = recordingHasTerminalMeasurements(evidence, plan.expected);
+    const presentation = await presentRecordingReceipt(options, plan, evidence, terminalMeasurements);
+    const verified = terminalMeasurements &&
+        presentation.artifactVerification?.verified === true &&
+        presentation.artifacts?.at(0)?.sizeBytes === evidence.receipt?.file.sizeBytes;
+    const data = recordingRecoveryData(plan, evidence);
+    const repaired = repairRecordingEnvelope(options, plan, data, verified);
     const recovery = {
-        attempt: { success: false, exitCode: options.processResult.exitCode, timedOut: options.processResult.timedOut, error: attemptError, parseError: options.parseError },
-        expected, healed: false, namespace: options.namespace, sessionName: options.sessionName, source: "session-info", status: "unavailable",
-        reason: "Native session info did not provide a matching recording receipt. File presence alone cannot prove successful recording finalization.",
+        attempt: plan.attempt,
+        expected: plan.expected,
+        healed: repaired.healed,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        source: "session-info",
+        receipt: evidence.receipt,
+        ...classifyRecordingRecovery(evidence, plan, verified),
+    };
+    return {
+        batch: plan.batch,
+        envelope: repaired.envelope,
+        partialBatch: plan.batch && plan.rows === undefined,
+        stopIndex: plan.stopIndex,
+        presentation: finishRecordingPresentation(options, presentation, evidence, recovery),
+        recovery,
     };
-    let info;
-    try {
-        info = await runSessionCommandData({ args: ["session", "info"], cwd: options.cwd, namespace: options.namespace, pinNamespace: true, sessionName: options.sessionName, signal: options.signal, timeoutMs: 2_000 });
-    }
-    catch (error) {
-        recovery.reason = `Native session info was unavailable: ${error instanceof Error ? error.message : String(error)}. File presence alone cannot prove successful recording finalization.`;
-    }
-    const runtime = isRecord(info) && isRecord(info.runtime) ? info.runtime : undefined;
-    const recordings = isRecord(runtime?.recording) ? runtime.recording : undefined;
-    const sameSession = isRecord(info) && typeof info.session === "string" && options.sessionName !== undefined
-        && getAgentBrowserSessionIdentityKey(info.session, typeof info.namespace === "string" ? info.namespace : undefined)
-            === getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace);
-    const current = getRecordingReceipt(recordings?.current);
-    let matchedData;
-    if (recordings && sameSession && expected) {
-        for (const candidate of [recordings.current, recordings.last]) {
-            const receipt = getRecordingReceipt(candidate);
-            if (!receipt || !receiptMatches(receipt, expected, Date.now()))
-                continue;
-            recovery.receipt = receipt;
-            matchedData = candidate;
-            break;
-        }
-        if (!recovery.receipt) {
-            recovery.status = "mismatch";
-            recovery.reason = "Native recording IDs, paths or capture windows did not match this attempt; unrelated receipt measurements were not used.";
-        }
-    }
-    else if (recordings && !sameSession) {
-        recovery.status = "mismatch";
-        recovery.reason = "Native session info reported a different namespace/session; its recording receipt was not used.";
-    }
-    const receipt = recovery.receipt;
-    const currentUsesSamePath = current && receipt && current.recordingId !== receipt.recordingId && expected
-        && resolve(expected.cwd, current.path) === expected.absolutePath;
-    const terminalMeasurements = receipt?.success === true && receipt.output.encoderSucceeded === true
-        && receipt.output.encodedFrames !== null && receipt.output.encodedFrames > 0
-        && receipt.file.exists === true && receipt.file.sizeBytes !== null && receipt.file.sizeBytes > 0
-        && Number.isFinite(Date.parse(receipt.capture.startedAt ?? "")) && Number.isFinite(Date.parse(receipt.capture.endedAt ?? ""))
-        && !currentUsesSamePath;
-    const data = matchedData ?? (expected ? { path: expected.absolutePath, recordingId: expected.recordingId, success: null } : undefined);
-    const presentation = await buildToolPresentation({
-        modelVisible: options.modelVisible,
-        artifactManifest: options.artifactManifest, artifactMinUpdatedAtMs: expected?.startedAtMs ?? options.artifactRunStartedAtMs, artifactMaxUpdatedAtMs: Date.now(),
-        artifactRequest: expected ? { path: expected.path, absolutePath: expected.absolutePath, status: terminalMeasurements ? undefined : "unverified" } : undefined,
-        commandInfo: { command: "record", subcommand: "stop" }, cwd: expected?.cwd ?? options.cwd,
-        envelope: { success: receipt?.success === true, data }, namespace: options.namespace, sessionName: options.sessionName,
-        recordingPending: receipt ? receipt.success === null : options.processResult.timedOut,
-    });
-    const file = presentation.artifacts?.[0];
-    const stopVerified = terminalMeasurements && presentation.artifactVerification?.verified === true && file?.sizeBytes === receipt?.file.sizeBytes;
-    if (receipt) {
-        recovery.status = stopVerified ? "recovered" : receipt.success === null ? "pending" : receipt.success === false ? "failed" : "unverified";
-        recovery.reason = stopVerified ? "Native terminal success and encoder measurements match the expected recording and the verified file."
-            : receipt.success === null ? "The matching native take is still pending; no terminal success was reported."
-                : receipt.success === false ? `The matching native receipt reports failure: ${receipt.error ?? "unknown encoder/capture failure"}.`
-                    : currentUsesSamePath ? "Another active recording uses this path. The previous receipt cannot verify the new take's file."
-                        : "A matching receipt was found, but successful encoding and a matching fresh file could not both be verified.";
-    }
-    let envelope = options.envelope;
-    if (rows) {
-        const updatedRows = rows.map((row, index) => index === stopIndex && isRecord(row) ? { ...row, result: data, success: stopVerified === true, error: stopVerified ? undefined : row.error } : row);
-        recovery.healed = stopVerified === true && !options.processResult.timedOut && updatedRows.every(row => isRecord(row) && row.success === true);
-        envelope = { success: recovery.healed, data: updatedRows, error: recovery.healed ? undefined : options.envelope?.error };
-    }
-    else if (!batch) {
-        recovery.healed = stopVerified === true;
-        envelope = { success: recovery.healed, data, error: recovery.healed ? undefined : attemptError };
-    }
-    if (!recovery.healed) {
-        presentation.resultCategory = "failure";
-        presentation.failureCategory = options.processResult.timedOut ? "timeout" : "upstream-error";
-        presentation.successCategory = undefined;
-        presentation.summary = `${attemptError} ${recovery.reason}`;
-    }
-    const followups = options.sessionName && !recovery.healed ? [{
-            id: "inspect-recording-receipt", tool: "agent_browser", params: { args: ["--namespace", options.namespace ?? "", "--session", options.sessionName, "session", "info"] },
-            reason: "Inspect the native current/last recording receipts for this exact session.", safety: "Read-only status; does not launch or retarget the browser. Do not infer encoding success from an existing file.",
-        }] : [];
-    if (current && receipt && current.recordingId === receipt.recordingId && recovery.status === "pending" && options.sessionName)
-        followups.push({
-            id: "stop-pending-recording", tool: "agent_browser", params: { args: ["--namespace", options.namespace ?? "", "--session", options.sessionName, "record", "stop"] },
-            reason: `Finalize the still-current native recording ${receipt.recordingId}; it has not reported a terminal outcome.`, safety: "Run only while this same recording remains current. No repeated stop was dispatched during recovery.",
-        });
-    presentation.nextActions = followups;
-    presentation.recordingRecovery = recovery;
-    const text = `Recording receipt recovery (${recovery.status}): ${recovery.reason}\nOriginal attempt: ${attemptError}`;
-    if (options.modelVisible !== false)
-        presentation.content.unshift({ type: "text", text });
-    return { batch, envelope, partialBatch: batch && !rows, stopIndex, presentation, recovery };
 }
-export function mergeRecordingRecoveryPresentation(base, result) {
-    if (!result.batch)
-        return result.presentation;
-    const artifacts = result.partialBatch ? [...(base.artifacts ?? []), ...(result.presentation.artifacts ?? [])] : base.artifacts;
-    const laterRecording = base.batchSteps?.slice(result.stopIndex + 1).some(step => step.artifacts?.some(isPendingRecordingArtifact));
-    const unrelatedFailure = base.batchFailure && !isStop(base.batchFailure.failedStep.command ?? []);
-    const nextActions = (base.nextActions ?? []).filter(action => action.id === "stop-pending-recording" ? laterRecording : unrelatedFailure);
+function mergeRecoveryNextActions(base, result) {
+    const laterRecording = base.batchSteps
+        ?.slice(result.stopIndex + 1)
+        .some((step) => step.artifacts?.some(isPendingRecordingArtifact) === true) === true;
+    const unrelatedFailure = base.batchFailure !== undefined && !isRecordingStop(base.batchFailure.failedStep.command ?? []);
+    const nextActions = (base.nextActions ?? []).filter((action) => action.id === "stop-pending-recording" ? laterRecording : unrelatedFailure);
     appendUniqueAgentBrowserNextActions(nextActions, result.presentation.nextActions);
+    return nextActions;
+}
+export function mergeRecordingRecoveryPresentation(base, result) {
+    if (!result.batch) {
+        return { ...result.presentation, content: [...result.presentation.content] };
+    }
+    const artifacts = result.partialBatch
+        ? [...(base.artifacts ?? []), ...(result.presentation.artifacts ?? [])]
+        : base.artifacts;
     return {
-        ...base, artifacts, artifactVerification: buildArtifactVerificationSummary(artifacts ?? []),
-        batchSteps: base.batchSteps?.map((step) => step.index === result.stopIndex ? { ...step, artifacts: result.presentation.artifacts, artifactVerification: result.presentation.artifactVerification } : step),
-        artifactManifest: result.partialBatch ? mergeSessionArtifactManifest({ base: base.artifactManifest, entries: buildManifestEntriesForFileArtifacts(result.presentation.artifacts ?? []) }) : base.artifactManifest,
-        content: [...base.content, ...(result.partialBatch ? result.presentation.content : result.presentation.content.slice(0, 1))],
-        nextActions,
+        ...base,
+        artifacts,
+        artifactVerification: buildArtifactVerificationSummary(artifacts ?? []),
+        batchSteps: base.batchSteps?.map((step) => step.index === result.stopIndex
+            ? {
+                ...step,
+                artifacts: result.presentation.artifacts,
+                artifactVerification: result.presentation.artifactVerification,
+            }
+            : step),
+        artifactManifest: result.partialBatch
+            ? mergeSessionArtifactManifest({
+                base: base.artifactManifest,
+                entries: buildManifestEntriesForFileArtifacts(result.presentation.artifacts ?? []),
+            })
+            : base.artifactManifest,
+        content: [
+            ...base.content,
+            ...(result.partialBatch
+                ? result.presentation.content
+                : result.presentation.content.slice(0, 1)),
+        ],
+        nextActions: mergeRecoveryNextActions(base, result),
         recordingRecovery: result.recovery,
     };
 }

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

@@ -0,0 +1,14 @@
+import { getScreenshotPathTokenIndex, getScreenshotPositionalIndices } from "./artifact-paths.js";
+export function getScreenshotCapture(command) {
+    if (command[0] !== "screenshot") {
+        return { kind: "unknown" };
+    }
+    if (command.includes("--full") || command.includes("-f")) {
+        return { kind: "full-page" };
+    }
+    const positional = getScreenshotPositionalIndices(command);
+    const selectorIndex = positional.find((index) => index !== getScreenshotPathTokenIndex(command));
+    return selectorIndex === undefined
+        ? { kind: "viewport" }
+        : { kind: "element", selector: command[selectorIndex] };
+}