pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/managed-session-storage.js

@@ -1,65 +1,25 @@
-import { createHash, randomUUID } from "node:crypto";
-import { linkSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, parse, resolve, win32 } from "node:path";
+import { isAbsolute, join, win32 } from "node:path";
 import { canonicalizeAgentBrowserNamespace } from "./argv-grammar.js";
-const MANAGED_SESSION_RESTORE_KEY_PATTERN = /^piab-r2-[a-f\d]{32}$/i;
-const MANAGED_SESSION_NAME_PREFIX = "piab-r2-";
-export function isManagedSessionRestoreKey(value) {
-    return typeof value === "string" && MANAGED_SESSION_RESTORE_KEY_PATTERN.test(value);
-}
-const MANAGED_SESSION_FRESH_SUFFIX_PATTERN = /-fresh-[a-f\d]{10}$/i;
-const MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH = 32;
-const PROJECT_GENERATION_MARKER_NAME = "pi-agent-browser-project-generation-v1.json";
-const PROJECT_GENERATION_MARKER_MAX_BYTES = 1_024;
-const projectGenerationCache = new Map();
-function isAbsoluteHome(path, platform) {
-    return platform === "win32" ? win32.isAbsolute(path) : isAbsolute(path);
-}
-function currentUid() {
-    return typeof process.getuid === "function" ? process.getuid() : undefined;
-}
-function isTrustedPosixDirectory(path, requireCurrentOwner, platform = process.platform) {
-    const uid = currentUid();
-    if (uid === undefined)
-        return false;
-    const root = parse(path).root;
-    let cursor = root;
-    for (const component of path.slice(root.length).split("/").filter(Boolean)) {
-        cursor = join(cursor, component);
-        let entry;
-        try {
-            entry = lstatSync(cursor);
-        }
-        catch {
-            return false;
-        }
-        if (entry.isSymbolicLink() || !entry.isDirectory())
-            return false;
-        const androidSystemAncestor = platform === "android" && (cursor === "/data" || cursor === "/data/data") && entry.uid === 1000 && (entry.mode & 0o002) === 0;
-        const androidAppDirectory = platform === "android" && entry.uid === uid && entry.gid === uid && (entry.mode & 0o002) === 0;
-        if (!androidSystemAncestor && entry.uid !== 0 && entry.uid !== uid)
-            return false;
-        const writableByOthers = (entry.mode & 0o022) !== 0;
-        const rootOwnedStickyDirectory = entry.uid === 0 && (entry.mode & 0o1000) !== 0;
-        if (writableByOthers && !rootOwnedStickyDirectory && !androidSystemAncestor && !androidAppDirectory)
-            return false;
-    }
-    try {
-        const leaf = lstatSync(path);
-        return !requireCurrentOwner || leaf.uid === uid;
-    }
-    catch {
-        return false;
-    }
+import { isTrustedPosixDirectory } from "./managed-session-posix-storage.js";
+import { getCurrentProcessUid } from "./process-identity.js";
+import { getErrorCode } from "./process-errors.js";
+export { isManagedSessionRestoreKey, createManagedSessionRestoreKey, getManagedSessionRestoreScope, hasManagedSessionRestoreProjectIdentity, resolveManagedSessionRestoreCheckoutRoot, } from "./managed-session-project-identity.js";
+function validHomeCandidate(candidate, platform) {
+    return (candidate.length > 0 &&
+        candidate.trim() === candidate &&
+        (platform === "win32" ? win32.isAbsolute(candidate) : isAbsolute(candidate)));
 }
 export function resolveManagedSessionRestoreHome(parentEnv, platform = process.platform) {
     const configuredHome = platform === "win32" ? parentEnv.USERPROFILE : parentEnv.HOME;
     const candidate = configuredHome ?? homedir();
-    if (!candidate || candidate.trim() !== candidate || !isAbsoluteHome(candidate, platform))
+    if (!validHomeCandidate(candidate, platform)) {
         return undefined;
-    if (platform === "win32")
+    }
+    if (platform === "win32") {
         return candidate;
+    }
     try {
         const canonical = realpathSync(candidate);
         return isTrustedPosixDirectory(canonical, true, platform) ? canonical : undefined;
@@ -74,15 +34,18 @@ export function ensureOwnerOnlyDirectory(path, platform = process.platform) {
             mkdirSync(path, { mode: 0o700 });
         }
         catch (error) {
-            if (error.code !== "EEXIST")
+            if (getErrorCode(error) !== "EEXIST") {
                 return false;
+            }
         }
         const entry = lstatSync(path);
-        if (entry.isSymbolicLink() || !entry.isDirectory())
+        if (entry.isSymbolicLink() || !entry.isDirectory()) {
             return false;
-        if (platform === "win32")
+        }
+        if (platform === "win32") {
             return true;
-        const uid = currentUid();
+        }
+        const uid = getCurrentProcessUid();
         return uid !== undefined && entry.uid === uid && (entry.mode & 0o077) === 0;
     }
     catch {
@@ -97,225 +60,65 @@ export function directoryContainsSymlink(path) {
         return true;
     }
 }
-function resolveGitCheckout(cwd, platform) {
-    let directory = cwd;
-    while (true) {
-        const dotGit = join(directory, ".git");
-        try {
-            const entry = lstatSync(dotGit);
-            if (entry.isDirectory() && !entry.isSymbolicLink())
-                return { gitDirectory: realpathSync(dotGit), worktreeDirectory: realpathSync(directory) };
-            if (!entry.isFile() || entry.isSymbolicLink() || entry.size > PROJECT_GENERATION_MARKER_MAX_BYTES)
-                return undefined;
-            if (platform !== "win32") {
-                const uid = currentUid();
-                if (uid === undefined || entry.uid !== uid || (entry.mode & 0o022) !== 0)
-                    return undefined;
-            }
-            const match = /^gitdir:\s*(.+)\s*$/i.exec(readFileSync(dotGit, "utf8"));
-            if (!match?.[1])
-                return undefined;
-            return { gitDirectory: realpathSync(resolve(directory, match[1])), worktreeDirectory: realpathSync(directory) };
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                return undefined;
-        }
-        const parent = dirname(directory);
-        if (parent === directory)
-            return undefined;
-        directory = parent;
-    }
-}
-function readProjectGenerationMarker(path, platform) {
-    try {
-        const entry = lstatSync(path);
-        if (entry.isSymbolicLink() || !entry.isFile() || entry.size > PROJECT_GENERATION_MARKER_MAX_BYTES)
-            return undefined;
-        if (platform !== "win32") {
-            const uid = currentUid();
-            if (uid === undefined || entry.uid !== uid || (entry.mode & 0o177) !== 0)
-                return undefined;
-        }
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return parsed.version === 1 && typeof parsed.id === "string" && /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i.test(parsed.id) ? parsed.id : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function getDirectoryFilesystemIdentity(path, platform) {
-    try {
-        const entry = statSync(path, { bigint: true });
-        if (!entry.isDirectory() || entry.dev <= 0n || entry.ino <= 0n)
-            return undefined;
-        // ponytail: Android reports mutable ctime as birthtime; use statx birthtime/inode generation when Node exposes either reliably.
-        return platform === "android"
-            ? `${entry.dev}:${entry.ino}`
-            : entry.birthtimeNs > 0n ? `${entry.dev}:${entry.ino}:${entry.birthtimeNs}` : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function resolveManagedSessionRestoreProjectCheckout(cwd, platform) {
-    let canonicalCwd;
-    try {
-        canonicalCwd = realpathSync(cwd);
-    }
-    catch {
-        return undefined;
-    }
-    if (platform !== "win32" && !isTrustedPosixDirectory(canonicalCwd, false, platform))
-        return undefined;
-    const checkout = resolveGitCheckout(canonicalCwd, platform);
-    if (!checkout)
-        return undefined;
-    if (platform !== "win32" && (!isTrustedPosixDirectory(checkout.worktreeDirectory, true, platform)
-        || !isTrustedPosixDirectory(checkout.gitDirectory, true, platform)))
-        return undefined;
-    return { canonicalCwd, ...checkout };
-}
-export function resolveManagedSessionRestoreCheckoutRoot(cwd, platform = process.platform) {
-    return resolveManagedSessionRestoreProjectCheckout(cwd, platform)?.worktreeDirectory;
-}
-function resolveProjectGenerationIdentity(cwd, platform = process.platform) {
-    const checkout = resolveManagedSessionRestoreProjectCheckout(cwd, platform);
-    if (!checkout)
-        return undefined;
-    const { canonicalCwd } = checkout;
-    const gitFilesystemIdentity = getDirectoryFilesystemIdentity(checkout.gitDirectory, platform);
-    const worktreeFilesystemIdentity = getDirectoryFilesystemIdentity(checkout.worktreeDirectory, platform);
-    if (!gitFilesystemIdentity || !worktreeFilesystemIdentity)
-        return undefined;
-    const markerPath = join(checkout.gitDirectory, PROJECT_GENERATION_MARKER_NAME);
-    let marker = readProjectGenerationMarker(markerPath, platform);
-    const cached = projectGenerationCache.get(canonicalCwd);
-    if (cached
-        && cached.gitDirectory === checkout.gitDirectory
-        && cached.worktreeDirectory === checkout.worktreeDirectory
-        && cached.gitFilesystemIdentity === gitFilesystemIdentity
-        && cached.worktreeFilesystemIdentity === worktreeFilesystemIdentity
-        && cached.marker === marker)
-        return cached.identity;
-    projectGenerationCache.delete(canonicalCwd);
-    try {
-        if (!marker) {
-            const content = JSON.stringify({ id: randomUUID(), version: 1 });
-            if (platform === "android") {
-                // ponytail: Android denies hard links in app storage; use renameat2(RENAME_NOREPLACE) if Node exposes it.
-                try {
-                    writeFileSync(markerPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
-                }
-                catch (error) {
-                    if (error.code !== "EEXIST")
-                        return undefined;
-                }
-            }
-            else {
-                const candidatePath = `${markerPath}.candidate-${process.pid}-${randomUUID()}`;
-                try {
-                    writeFileSync(candidatePath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
-                    try {
-                        linkSync(candidatePath, markerPath);
-                    }
-                    catch (error) {
-                        if (error.code !== "EEXIST")
-                            return undefined;
-                    }
-                }
-                finally {
-                    try {
-                        unlinkSync(candidatePath);
-                    }
-                    catch { }
-                }
-            }
-            marker = readProjectGenerationMarker(markerPath, platform);
-        }
-        if (!marker)
-            return undefined;
-        const identity = `${platform}:${worktreeFilesystemIdentity}:${gitFilesystemIdentity}:${marker}`;
-        projectGenerationCache.set(canonicalCwd, {
-            gitDirectory: checkout.gitDirectory,
-            gitFilesystemIdentity,
-            identity,
-            marker,
-            worktreeDirectory: checkout.worktreeDirectory,
-            worktreeFilesystemIdentity,
-        });
-        return identity;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function hasManagedSessionRestoreProjectIdentity(cwd) {
-    return resolveProjectGenerationIdentity(cwd) !== undefined;
-}
-/** Keep fresh rotations from one Pi transcript in one private upstream restore pool. */
-export function getManagedSessionRestoreScope(sessionName) {
-    return sessionName.replace(MANAGED_SESSION_FRESH_SUFFIX_PATTERN, "");
-}
-/** Stable for one Pi transcript and checkout generation; isolated from other concurrent transcripts. */
-export function createManagedSessionRestoreKey(cwd, restoreScope = "", platform = process.platform) {
-    let canonicalCwd = resolve(cwd);
-    try {
-        canonicalCwd = realpathSync(canonicalCwd);
-    }
-    catch { }
-    const identity = resolveProjectGenerationIdentity(canonicalCwd, platform);
-    const material = identity ?? `unavailable:${canonicalCwd}`;
-    const digest = createHash("sha256")
-        .update(`restore-v3:${material}:scope:${restoreScope}`)
-        .digest("hex")
-        .slice(0, MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH);
-    return `${MANAGED_SESSION_NAME_PREFIX}${digest}`;
-}
 function hasValidEncryptionKey(parentEnv) {
     const value = parentEnv.AGENT_BROWSER_ENCRYPTION_KEY;
     return typeof value === "string" && /^[a-f\d]{64}$/i.test(value);
 }
 export function getManagedRestoreSessionsDirectory(home, namespace) {
     const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
-    return canonicalNamespace
+    return canonicalNamespace !== undefined && canonicalNamespace.length > 0
         ? join(home, ".agent-browser", "namespaces", canonicalNamespace, "state", "sessions")
         : join(home, ".agent-browser", "sessions");
 }
-/** Require the upstream 256-bit key format and secure every directory that can receive restore snapshots. */
+function ensureRestoreStateDirectory(root, namespace, platform) {
+    const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
+    const components = canonicalNamespace !== undefined && canonicalNamespace.length > 0
+        ? ["namespaces", canonicalNamespace, "state", "sessions"]
+        : ["sessions"];
+    let path = root;
+    for (const component of components) {
+        path = join(path, component);
+        if (!ensureOwnerOnlyDirectory(path, platform)) {
+            return undefined;
+        }
+    }
+    return path;
+}
+/** Require the native 256-bit key format and secure each automatic restore storage directory. */
 export function ensureManagedSessionRestoreStorageIsSecure(parentEnv = process.env, platform = process.platform, namespace) {
-    const encryptionKey = parentEnv.AGENT_BROWSER_ENCRYPTION_KEY;
-    if (encryptionKey !== undefined && !hasValidEncryptionKey(parentEnv))
+    if (parentEnv.AGENT_BROWSER_ENCRYPTION_KEY !== undefined && !hasValidEncryptionKey(parentEnv)) {
         return false;
-    if (platform === "win32")
+    }
+    if (platform === "win32") {
         return hasValidEncryptionKey(parentEnv);
+    }
     const home = resolveManagedSessionRestoreHome(parentEnv, platform);
-    if (!home)
+    if (home === undefined) {
         return false;
+    }
     const root = join(home, ".agent-browser");
-    if (!ensureOwnerOnlyDirectory(root, platform))
+    if (!ensureOwnerOnlyDirectory(root, platform)) {
         return false;
-    const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
-    const stateComponents = canonicalNamespace
-        ? ["namespaces", canonicalNamespace, "state", "sessions"]
-        : ["sessions"];
-    let path = root;
-    for (const component of stateComponents) {
-        path = join(path, component);
-        if (!ensureOwnerOnlyDirectory(path, platform))
-            return false;
     }
-    if (directoryContainsSymlink(path))
+    const path = ensureRestoreStateDirectory(root, namespace, platform);
+    if (path === undefined || directoryContainsSymlink(path)) {
         return false;
+    }
+    return secureRestoreTemporaryDirectory(path, platform);
+}
+function secureRestoreTemporaryDirectory(path, platform) {
     const temporaryDirectory = join(path, ".tmp");
-    return ensureOwnerOnlyDirectory(temporaryDirectory, platform) && !directoryContainsSymlink(temporaryDirectory);
+    return (ensureOwnerOnlyDirectory(temporaryDirectory, platform) &&
+        !directoryContainsSymlink(temporaryDirectory));
 }
 export function getManagedSessionRestoreProtectedStorageEnv(restoreEnabled, parentEnv, platform = process.platform) {
-    if (!restoreEnabled)
+    if (!restoreEnabled) {
         return {};
+    }
     const home = resolveManagedSessionRestoreHome(parentEnv, platform);
-    if (!home)
+    if (home === undefined) {
         return {};
+    }
     return {
         AGENT_BROWSER_ENCRYPTION_KEY: parentEnv.AGENT_BROWSER_ENCRYPTION_KEY,
         ...(platform === "win32" ? { USERPROFILE: home } : { HOME: home }),

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

@@ -0,0 +1,140 @@
+import { getExplicitNavigationTarget } from "./page-target-navigation.js";
+import { isRecord } from "./parsing.js";
+function isNonemptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function confirmationIdentity(value) {
+    if (!isNonemptyString(value.id) ||
+        !isNonemptyString(value.sessionName) ||
+        (value.namespace !== undefined && typeof value.namespace !== "string")) {
+        return undefined;
+    }
+    return { id: value.id, sessionName: value.sessionName, namespace: value.namespace };
+}
+function guardedProvenance(value) {
+    if (!isNonemptyString(value.command) || !isNonemptyString(value.action)) {
+        return undefined;
+    }
+    const fresh = value.state === "cleared" &&
+        value.command === "snapshot" &&
+        value.action === "snapshot" &&
+        value.refSnapshotFresh === true;
+    return {
+        command: value.command,
+        action: value.action,
+        ...(fresh ? { refSnapshotFresh: true } : {}),
+    };
+}
+function explicitReadCapabilities(value) {
+    return isRecord(value) && value.readRequiresConfirmation === true
+        ? { readRequiresConfirmation: true }
+        : undefined;
+}
+export function parseReadConfirmation(value) {
+    if (!isRecord(value) ||
+        (value.source !== "native-explicit-url-read" && value.source !== "native-guarded-action") ||
+        (value.state !== "pending" && value.state !== "cleared")) {
+        return undefined;
+    }
+    const identity = confirmationIdentity(value);
+    if (identity === undefined) {
+        return undefined;
+    }
+    if (value.source === "native-explicit-url-read") {
+        const capabilities = explicitReadCapabilities(value.capabilities);
+        return {
+            ...identity,
+            source: value.source,
+            state: value.state,
+            ...(capabilities !== undefined ? { capabilities } : {}),
+        };
+    }
+    const provenance = guardedProvenance(value);
+    return provenance === undefined
+        ? undefined
+        : { ...identity, ...provenance, source: value.source, state: value.state };
+}
+function parsePendingControl(value) {
+    if (!isRecord(value) ||
+        value.confirmation_required !== true ||
+        !isNonemptyString(value.confirmation_id) ||
+        !isNonemptyString(value.action)) {
+        return undefined;
+    }
+    return {
+        id: value.confirmation_id,
+        action: value.action,
+        capabilities: explicitReadCapabilities(value.capabilities),
+    };
+}
+const TAB_TRANSPORT_KEYS = new Set([
+    "confirmation_required",
+    "confirmation_id",
+    "action",
+    "capabilities",
+    "after_confirmation",
+    "guidance",
+]);
+function matchesTabContinuation(after, commandTokens) {
+    return (Array.isArray(after) &&
+        after.length === 2 &&
+        after[0] === "open" &&
+        isNonemptyString(after[1]) &&
+        after[1] === getExplicitNavigationTarget(commandTokens));
+}
+export function getNativeTabContinuationGuidance(commandTokens, data) {
+    if (commandTokens[0] !== "tab" || commandTokens[1] !== "new" || !isRecord(data)) {
+        return undefined;
+    }
+    const pending = parsePendingControl(data);
+    if (pending?.action !== "tab_new" ||
+        !Object.keys(data).every((key) => TAB_TRANSPORT_KEYS.has(key))) {
+        return undefined;
+    }
+    if (!matchesTabContinuation(data.after_confirmation, commandTokens)) {
+        return undefined;
+    }
+    // Transport prose only: approval creates the tab; the continuation is never stored or executed.
+    return typeof data.guidance === "string" && data.guidance.trim().length > 0
+        ? data.guidance
+        : undefined;
+}
+export function getNativePendingControl(commandTokens, data) {
+    if (!isRecord(data)) {
+        return undefined;
+    }
+    // Only native control fields and validated tab transport. Page output is never provenance.
+    const controlKeys = new Set([
+        "confirmation_required",
+        "confirmation_id",
+        "action",
+        "capabilities",
+    ]);
+    if (!Object.keys(data).every((key) => controlKeys.has(key)) &&
+        getNativeTabContinuationGuidance(commandTokens, data) === undefined) {
+        return undefined;
+    }
+    return parsePendingControl(data);
+}
+export function getConfirmedNativeResult(data, current) {
+    const action = current.source === "native-explicit-url-read" ? "read" : current.action;
+    return isRecord(data) &&
+        data.confirmed === true &&
+        data.action === action &&
+        isRecord(data.result)
+        ? data.result
+        : undefined;
+}
+export function isSuccessfulNativeConfirmedClose(commandTokens, data) {
+    if (commandTokens[0] !== "confirm" ||
+        commandTokens.length !== 2 ||
+        !isRecord(data) ||
+        data.confirmed !== true ||
+        data.action !== "close") {
+        return false;
+    }
+    return (isRecord(data.result) &&
+        data.result.success === true &&
+        isRecord(data.result.data) &&
+        data.result.data.closed === true);
+}

package/dist/extensions/agent-browser/lib/native-output.js

@@ -1,8 +1,10 @@
 import { JsonSchema } from "./json-schema.js";
 import { isRecord } from "./parsing.js";
+import { isBooleanFlagEnabled } from "./argv-grammar.js";
 import { finalizeAgentBrowserFailure } from "./pi-tool-rendering.js";
 import { isPlainTextInspectionArgs } from "./runtime.js";
-import { projectAgentBrowserObservation, OBSERVATION_INLINE_MAX_CHARS } from "./results/presentation/content.js";
+import { projectAgentBrowserObservation, OBSERVATION_INLINE_MAX_CHARS, isStringArray, } from "./results/presentation/content.js";
+import { renderAgentBrowserObservation } from "./results/presentation/large-output.js";
 export const AGENT_BROWSER_NAMESPACE = {
     name: "browser",
     description: "Browser commands, bounded browser code, advanced UI checks, Electron, and optional web search.",
@@ -10,37 +12,70 @@ export const AGENT_BROWSER_NAMESPACE = {
 };
 export const AGENT_BROWSER_OUTPUT_SCHEMA = JsonSchema.Object({
     success: JsonSchema.Boolean(),
-    resultCategory: JsonSchema.Union([JsonSchema.Literal("success"), JsonSchema.Literal("failure")]),
+    resultCategory: JsonSchema.Union([
+        JsonSchema.Literal("success"),
+        JsonSchema.Literal("failure"),
+    ]),
     data: JsonSchema.Optional(JsonSchema.Unsafe({})),
     error: JsonSchema.Optional(JsonSchema.Unsafe({})),
     summary: JsonSchema.Optional(JsonSchema.String()),
     nextActions: JsonSchema.Optional(JsonSchema.Array(JsonSchema.Object({}))),
 }, { additionalProperties: true });
+function inputArgs(input) {
+    return isRecord(input) && isStringArray(input.args) ? input.args : undefined;
+}
+function isJsonRequest(input) {
+    return (isRecord(input) && ("code" in input || isBooleanFlagEnabled(inputArgs(input) ?? [], "--json")));
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function serializedObservation(value) {
+    // Serialization keeps native JSON omission/coercion semantics; validate the decoded unknown boundary.
+    const decoded = JSON.parse(JSON.stringify(value));
+    if (!isJsonValue(decoded)) {
+        throw new Error("Browser observation did not serialize to a JSON value.");
+    }
+    return decoded;
+}
 /** Final public boundary, after execution, persistence, and any requested output export. */
 export async function finalizeAgentBrowserNativeResult(result, input) {
     const finalized = finalizeAgentBrowserFailure(result, input);
     // Native help/version stays plain text; the entrypoint intentionally skips observation rendering for it.
-    if (isRecord(input) && Array.isArray(input.args) && isPlainTextInspectionArgs(input.args))
+    if (isPlainTextInspectionArgs(inputArgs(input) ?? [])) {
         return finalized;
+    }
     const succeeded = finalized.isError !== true;
     // The normal entrypoint supplies the exact bounded projection, including its complete spill.
-    if (isRecord(result.structuredContent) && result.structuredContent.success === succeeded)
+    if (isRecord(result.structuredContent) && result.structuredContent.success === succeeded) {
         return finalized;
+    }
     const details = isRecord(result.details) ? result.details : {};
     const observation = projectAgentBrowserObservation(details, succeeded);
     if (JSON.stringify(observation).length > OBSERVATION_INLINE_MAX_CHARS) {
-        const { renderAgentBrowserObservation } = await import("./results/presentation/large-output.js");
         const rendered = await renderAgentBrowserObservation({
-            content: finalized.content, details, succeeded,
-            json: isRecord(input) && ("code" in input || Array.isArray(input.args) && input.args.includes("--json")),
+            content: finalized.content,
+            details,
+            succeeded,
+            json: isJsonRequest(input),
             // The caller's exact visible output stays inline (for example formatted search results); only the structured field is bounded.
             preserveContent: true,
         });
         const { artifactManifest, ...renderedResult } = rendered;
         return finalizeAgentBrowserFailure({
-            ...finalized, ...renderedResult,
+            ...finalized,
+            ...renderedResult,
             details: artifactManifest ? { ...details, artifactManifest } : details,
         }, input);
     }
-    return { ...finalized, structuredContent: JSON.parse(JSON.stringify(observation)) };
+    return { ...finalized, structuredContent: serializedObservation(observation) };
 }