pi-agent-browser-native 0.2.77 → 0.3.0

package/dist/extensions/agent-browser/lib/prompt-policy.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Derive operator prompt constraints for browser-run preflight guards and legacy bash policy.
- * Responsibilities: Parse the latest user message into requested artifact paths and legacy bash allowance.
- * Scope: Pure prompt-text policy; enforcement lives in orchestration prompt-guards and the extension entrypoint.
- */
 const BROWSER_PROMPT_PATTERNS = [
     /\b(?:agent[_ -]?browser|browser automation|eval\s+--stdin|screenshot|snapshot|tab\s+list)\b/i,
     /\b(?:react\s+(?:tree|inspect|renders|suspense)|web\s+vitals|core\s+web\s+vitals|pushstate)\b/i,
@@ -17,41 +12,190 @@ const LEGACY_BASH_ALLOW_PATTERNS = [
     /\bagent-browser\s+--(?:help|version)\b/i,
     /\bdebug(?:ging)?\b.*\b(?:agent[_ -]?browser|agent_browser|browser integration)\b/i,
 ];
-const PROMPT_ARTIFACT_PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`),;:\\/]+(?:[\\/][^\s"'`),;]+)+|[^\s"'`),;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?:[\s"'`),;.]|$)/gi;
-function inferPromptArtifactKind(line, path) {
+const PROMPT_ARTIFACT_PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`()[\],;:\\/]+(?:[\\/][^\s"'`()[\],;\\/]+)+|[^\s"'`()[\],;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?=[\s"'`),;.!?]|$)/gi;
+const PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s*:\s*$/i;
+const PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the|this)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s+(?:directly\s+)?(?:\b(?:at|as|to)\b\s*[:=-]?|\bhere\b(?:\s+(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available)?\s*[:=-]?)\s*$|\b(?:export|output|save|write)\s+(?:it\s+)?(?:at|as|to)\s*[:=-]?\s*$/i;
+const PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN = /n['’]t\b|\b(?:cannot|disallowed|forbidden|maybe|needed|never|no|not|optional(?:ly)?|perhaps|prohibited|rather|refrain|unable|without)\b|\b(?:he|i|it|she|they|we|you)\s+(?:can|could|may|might)\b/i;
+const PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN = /^(?:(?:and(?:\s+then)?|then)(?:\s+please)?|please|you|(?:be|make)\s+sure\s+to|(?:can|could|will|would)\s+you(?:\s+please)?|(?:i|we)\s+(?:need|want)\s+you\s+to|you\s+(?:must|should))$/i;
+const PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN = /^(?:please\s+)?(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\b.*(?:[,\-:–—]|\b(?:and|then))\s*$/i;
+const PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN = /^[\s"'`()\[\]{},;:.*!?\/&+>-]*(?:(?:and|or)[\s"'`()\[\]{},;:.*!?\/&+>-]*)?$/i;
+const PROMPT_ARTIFACT_LIST_PREFIX_PATTERN = /^\s*(?:(?:[-*+]|\d+[.)])\s*)/;
+const PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN = /\b(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available\b/i;
+const PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN = /^\s*(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available[.:;]?\s*$/i;
+const PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN = /\b(?:optionally|if\s+(?:convenient|desired|needed|possible|you\s+can|you\s+want\s+to)|when\s+(?:convenient|desired|needed|possible)|only\s+if\s+you\s+(?:can|want\s+to))\b/i;
+const PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN = /\btake\s+the\s+(?:image|recording|screenshot|video)\s+(?:at|from)\b/i;
+const PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN = /(?:[;.!?](?:\s|$)|\b(?:but|instead)\b)/i;
+function getPromptArtifactKind(path) {
     const lowerPath = path.toLowerCase();
     if (/\.(?:webm|mp4)$/.test(lowerPath))
         return "recording";
     if (/\.(?:png|jpe?g|webp|gif)$/.test(lowerPath))
         return "screenshot";
-    const lowerLine = line.toLowerCase();
-    if (lowerLine.includes("screenshot"))
-        return "screenshot";
-    if (/\b(?:screen\s+recording|recording|webm|video)\b/.test(lowerLine))
-        return "recording";
     return undefined;
 }
+function getPromptArtifactIntentClause(context) {
+    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context;
+}
+function getPromptArtifactTrailingClause(context) {
+    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN)[0] ?? context;
+}
+function hasPromptArtifactOutputIntent(context) {
+    const clause = getPromptArtifactIntentClause(context)
+        .replace(/\[[^\]\r\n]*\]\(\s*$/, "")
+        .replace(/[([{\"'`]+\s*$/, "");
+    const intentMatch = clause.match(PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN) ?? clause.match(PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN);
+    if (!intentMatch)
+        return false;
+    const prefix = clause.slice(0, intentMatch.index ?? 0);
+    const governingPrefix = prefix.split(/\b(?:before|unless|until)\b/i).at(-1) ?? prefix;
+    if (PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN.test(governingPrefix))
+        return false;
+    const normalizedPrefix = governingPrefix.trim();
+    return normalizedPrefix.length === 0
+        || PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN.test(normalizedPrefix)
+        || PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN.test(governingPrefix);
+}
+function stripPromptArtifactListPrefix(context) {
+    return context.replace(PROMPT_ARTIFACT_LIST_PREFIX_PATTERN, "");
+}
+function normalizePromptArtifactPath(path) {
+    return path.replace(/^[([{]+/, "");
+}
+function isLikelyInboundPromptArtifact(path) {
+    return /(?:^|[\\/])pi-(?:attachment|clipboard|paste|upload)-/i.test(path);
+}
 function extractPromptRequestedArtifacts(prompt) {
     const artifacts = [];
-    const seen = new Set();
-    for (const line of prompt.split(/\r?\n/)) {
+    const seen = new Map();
+    const lines = prompt.split(/\r?\n/);
+    let inCodeFence = false;
+    let listArtifactIndexes = [];
+    let listContinuation;
+    let pendingRecordingAvailability = false;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex] ?? "";
+        if (/^\s*(?:`{3,}|~{3,})/.test(line)) {
+            inCodeFence = !inCodeFence;
+            listArtifactIndexes = [];
+            listContinuation = undefined;
+            pendingRecordingAvailability = false;
+            continue;
+        }
+        if (inCodeFence)
+            continue;
         PROMPT_ARTIFACT_PATH_PATTERN.lastIndex = 0;
+        const pathMatches = [];
         for (const match of line.matchAll(PROMPT_ARTIFACT_PATH_PATTERN)) {
-            const path = match[1]?.trim();
-            if (!path)
-                continue;
-            const kind = inferPromptArtifactKind(line, path);
-            if (!kind)
+            const rawPath = match[1]?.trim();
+            const path = rawPath ? normalizePromptArtifactPath(rawPath) : undefined;
+            if (!path || !rawPath)
                 continue;
-            const key = `${kind}:${path}`;
-            if (seen.has(key))
+            const start = (match.index ?? 0) + match[0].indexOf(rawPath) + rawPath.indexOf(path);
+            pathMatches.push({ end: start + path.length, path, start });
+        }
+        if (pathMatches.length === 0 && PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN.test(line)) {
+            if (listContinuation?.kind === "recording") {
+                for (const artifactIndex of listArtifactIndexes) {
+                    if (artifacts[artifactIndex]?.kind === "recording")
+                        artifacts[artifactIndex].required = false;
+                }
+                listContinuation = { ...listContinuation, required: false };
+            }
+            else {
+                pendingRecordingAvailability = true;
+            }
+            continue;
+        }
+        if (pathMatches.length === 0 && pendingRecordingAvailability && /\brecordings?\b/i.test(line) && hasPromptArtifactOutputIntent(line))
+            continue;
+        const pendingRecordingAvailabilityForLine = pathMatches.length > 0 && pendingRecordingAvailability;
+        pendingRecordingAvailability = false;
+        const pathlessLine = stripPromptArtifactListPrefix(line.replace(PROMPT_ARTIFACT_PATH_PATTERN, ""));
+        const remainder = pathlessLine.replace(/[\s"'`()\[\],;:.*!?>-]+/g, "").toLowerCase();
+        const listSyntax = pathlessLine
+            .replace(PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN, "")
+            .replace(PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN, "");
+        const isPathList = pathMatches.length > 0 && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(listSyntax);
+        const groupOptional = new Map();
+        const candidates = [];
+        let nextGroup = 0;
+        let previousGroup;
+        let previousKind;
+        let previousPathEnd = 0;
+        for (let matchIndex = 0; matchIndex < pathMatches.length; matchIndex += 1) {
+            const { end, path, start } = pathMatches[matchIndex];
+            const localContext = stripPromptArtifactListPrefix(line.slice(previousPathEnd, start));
+            const intentContext = matchIndex === 0 && (isPathList || !remainder || ["file", "output", "path"].includes(remainder))
+                ? `${lines[lineIndex - 1] ?? ""}\n${localContext}`
+                : localContext;
+            const kind = getPromptArtifactKind(path);
+            const directIntent = hasPromptArtifactOutputIntent(intentContext);
+            const sameLineContinuation = kind === previousKind && previousGroup !== undefined && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
+            const priorLineContinuation = matchIndex === 0 && isPathList && kind === listContinuation?.kind && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
+            let group;
+            if (directIntent) {
+                group = nextGroup++;
+                groupOptional.set(group, pendingRecordingAvailabilityForLine || PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactIntentClause(intentContext)));
+            }
+            else if (sameLineContinuation) {
+                group = previousGroup;
+            }
+            else if (priorLineContinuation) {
+                group = nextGroup++;
+                groupOptional.set(group, listContinuation?.required === false);
+            }
+            const referenceReading = directIntent && PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN.test(getPromptArtifactIntentClause(intentContext));
+            const trailingContext = getPromptArtifactTrailingClause(line.slice(end, pathMatches[matchIndex + 1]?.start ?? line.length));
+            const explicitlyOptional = directIntent && (PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(getPromptArtifactIntentClause(intentContext))
+                || PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(trailingContext));
+            if (!kind || group === undefined || referenceReading || explicitlyOptional || isLikelyInboundPromptArtifact(path)) {
+                previousGroup = undefined;
+                previousKind = undefined;
+                previousPathEnd = end;
                 continue;
-            seen.add(key);
-            artifacts.push({
-                kind,
-                path,
-                required: kind === "screenshot" || !/\b(?:if|when)\s+(?:recording\s+)?(?:is\s+)?available\b/i.test(line),
-            });
+            }
+            candidates.push({ continuedFromPriorLine: priorLineContinuation && !directIntent, group, kind, matchIndex, path });
+            previousGroup = group;
+            previousKind = kind;
+            previousPathEnd = end;
+        }
+        for (const candidate of candidates) {
+            const match = pathMatches[candidate.matchIndex];
+            const nextStart = pathMatches[candidate.matchIndex + 1]?.start ?? line.length;
+            if (PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactTrailingClause(line.slice(match.end, nextStart)))) {
+                groupOptional.set(candidate.group, true);
+            }
+        }
+        const lineArtifactIndexes = [];
+        for (const candidate of candidates) {
+            const required = candidate.kind === "screenshot" || groupOptional.get(candidate.group) !== true;
+            const key = `${candidate.kind}:${candidate.path}`;
+            let artifactIndex = seen.get(key);
+            if (artifactIndex === undefined) {
+                artifactIndex = artifacts.length;
+                seen.set(key, artifactIndex);
+                artifacts.push({ kind: candidate.kind, path: candidate.path, required });
+            }
+            else if (required) {
+                artifacts[artifactIndex].required = true;
+            }
+            lineArtifactIndexes.push(artifactIndex);
+        }
+        const lastCandidate = candidates.at(-1);
+        if (isPathList && lastCandidate?.matchIndex === pathMatches.length - 1) {
+            const lastArtifact = artifacts[lineArtifactIndexes.at(-1)];
+            listContinuation = { kind: lastArtifact.kind, required: lastArtifact.required };
+            if (candidates[0]?.continuedFromPriorLine) {
+                for (const artifactIndex of lineArtifactIndexes)
+                    listArtifactIndexes.push(artifactIndex);
+            }
+            else {
+                listArtifactIndexes = lineArtifactIndexes;
+            }
+        }
+        else {
+            listArtifactIndexes = [];
+            listContinuation = undefined;
         }
     }
     return artifacts;

package/dist/extensions/agent-browser/lib/results/action-recommendations.js

@@ -1,12 +1,5 @@
-/**
- * Purpose: Build generic nextAction recommendations from result categories, artifacts, Electron lifecycle state, and recovery context.
- * Responsibilities: Preserve stable action ids/order while keeping recommendation policy out of generic shared helpers.
- * Scope: Generic result-level recommendations only; feature-specific diagnostics append their own actions in the extension entrypoint.
- * Usage: Called by presentation and extension result assembly.
- * Invariants/Assumptions: Action ids are public machine-readable contracts; preserve first-observed order.
- */
 import { isOpenNavigationCommand, isPageMutationCommand } from "../command-taxonomy.js";
-import { isPendingRecordingArtifact } from "./artifact-state.js";
+import { isPendingRecordingArtifact } from "./artifact-manifest.js";
 import { buildNextToolAction } from "./next-actions.js";
 import { AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS, buildRecoveryNextActions, } from "./recovery-actions.js";
 function buildArtifactAction(path) {

package/dist/extensions/agent-browser/lib/results/artifact-manifest.js

@@ -1,11 +1,10 @@
-/**
- * Purpose: Own persistent session artifact manifest merge, retention, and validation logic.
- * Responsibilities: Parse manifest bounds, recognize manifest entries, merge new artifact rows, and format retention summaries.
- * Scope: Manifest accounting only; artifact detection and presentation live in presentation modules.
- * Usage: Imported by presentation and snapshot artifact persistence paths.
- * Invariants/Assumptions: Explicit-path artifacts are host-owned while persistent-session spill files are bounded by the manifest cap.
- */
 import { isRecord } from "../parsing.js";
+export function isPendingRecordingCommand(command, subcommand, kind) {
+    return command === "record" && (subcommand === "start" || subcommand === "restart") && kind === "video";
+}
+export function isPendingRecordingArtifact(artifact) {
+    return isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind);
+}
 export const SESSION_ARTIFACT_MANIFEST_VERSION = 1;
 export const SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES_ENV = "PI_AGENT_BROWSER_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES";
 export const DEFAULT_SESSION_ARTIFACT_MANIFEST_MAX_ENTRIES = 100;

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

@@ -1,11 +1,4 @@
-/**
- * Purpose: Classify successful and failed agent-browser outcomes into stable result categories.
- * Responsibilities: Map artifacts, inspection calls, errors, refs, selectors, downloads, drift, and timeouts to small enums.
- * Scope: Category policy only; next-action recommendations and presentation formatting live elsewhere.
- * Usage: Called by presentation and extension result assembly before details are exposed to Pi.
- * Invariants/Assumptions: Category strings are public machine-readable contracts covered by tests and docs.
- */
-import { isPendingRecordingArtifact } from "./artifact-state.js";
+import { isPendingRecordingArtifact } from "./artifact-manifest.js";
 function hasUnverifiedFileArtifact(artifacts) {
     return (artifacts ?? []).some((artifact) => !isPendingRecordingArtifact(artifact) && artifact.exists !== true);
 }

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Detect upstream guarded-action confirmation-needed result shapes without creating wrapper-owned confirmation state.
- * Responsibilities: Recognize confirmation-required markers, extract the pending upstream confirmation id, and optionally surface a short upstream action label.
- * Scope: Pure result-shape detection shared by presentation and error derivation; command execution, approval state, and redaction stay in their existing modules.
- * Usage: Imported by result presentation to render recovery commands and by envelope error handling to avoid hiding actionable confirmation payloads behind generic failure text.
- * Invariants/Assumptions: Detection must be conservative: a confirmation marker and a non-empty upstream id are both required before a result is treated as actionable.
- */
 import { isRecord } from "../parsing.js";
 const CONFIRMATION_REQUIRED_FIELD_NAMES = [
     "confirmation_required",

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

@@ -1,8 +1 @@
-/**
- * Purpose: Define stable result-rendering data contracts shared across focused result modules.
- * Responsibilities: Keep upstream envelope, presentation, artifact, category, and network shapes in one type-only surface.
- * Scope: Types only; runtime classifiers, manifests, network rules, and text helpers live in neighboring modules.
- * Usage: Imported with `import type` by result modules and re-exported by the public results facade.
- * Invariants/Assumptions: This file has no runtime policy so adding fields cannot hide behavior in a catch-all module.
- */
 export {};

package/dist/extensions/agent-browser/lib/results/editable-ref-evidence.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Detect whether upstream ref metadata or snapshot text proves an element is editable.
- * Responsibilities: Parse structured ref flags and snapshot-line contenteditable/editable markers into a conservative boolean/unknown signal.
- * Scope: Editable evidence only; callers decide how to rank controls or build recovery actions from the signal.
- * Usage: Imported by snapshot compaction and selector/fill recovery diagnostics.
- * Invariants/Assumptions: Explicit false evidence wins over positive hints; unknown remains undefined.
- */
 const EDITABLE_REF_EVIDENCE_KEYS = ["editable", "contentEditable", "contenteditable", "isContentEditable"];
 const EDITABLE_FALSE_TEXT_PATTERN = /\b(?:contenteditable|editable)\s*=\s*["']?(?:false|0)["']?/i;
 const EDITABLE_ASSIGNMENT_TEXT_PATTERN = /\b(contenteditable|editable)\s*=\s*("[^"]*"|'[^']*'|[^\s,\]]+)/gi;

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Parse upstream agent-browser output and turn failure envelopes into actionable error text.
- * Responsibilities: Read inline or spilled stdout, parse observed JSON envelope shapes, normalize batch arrays, and extract the most useful error text from nested upstream failures.
- * Scope: Envelope parsing and error derivation only; content rendering and snapshot compaction live in separate modules.
- * Usage: Imported by the public `lib/results.ts` facade and by tests through that facade.
- * Invariants/Assumptions: Upstream `agent-browser --json` responses follow the observed `{ success, data, error }` envelope shape or the array shape returned by `batch --json`.
- */
 import { readFile } from "node:fs/promises";
 import { isRecord } from "../parsing.js";
 import { detectConfirmationRequired } from "./confirmation.js";

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Classify failed network requests into actionable vs benign diagnostics.
- * Responsibilities: Recognize failed request rows, de-prioritize browser icon misses, and summarize failure counts.
- * Scope: Network diagnostic classification only.
- * Usage: QA preset analysis and presentation network summaries.
- * Invariants/Assumptions: Browser favicon/apple-touch icon misses are warnings; API/document/script failures are actionable.
- */
 import { isRecord } from "../parsing.js";
 export function getStringRecordField(value, key) {
     const field = value[key];

package/dist/extensions/agent-browser/lib/results/next-actions.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Own machine-readable agent_browser next-action contracts and merge policy.
- * Responsibilities: Define the stable nextAction shape, build basic argv follow-ups, and provide deterministic action-list collection helpers.
- * Scope: Result follow-up action mechanics only; command-specific recovery and artifact policies live in neighboring modules.
- * Usage: Imported by result presentation helpers and the extension entrypoint when attaching details.nextActions.
- * Invariants/Assumptions: Action ids are stable machine-readable contracts; dedupe preserves first occurrence order.
- */
 export function withOptionalNamespaceArgs(namespace, args) {
     return namespace && args[0] !== "--namespace" ? ["--namespace", namespace, ...args] : args;
 }
@@ -65,26 +58,3 @@ export function alignPageChangeSummaryNextActionIds(summary, nextActions) {
     const alignedIds = summary.nextActionIds.filter((id) => nextActionIds.has(id));
     return alignedIds.length > 0 ? { ...summary, nextActionIds: alignedIds } : { ...summary, nextActionIds: undefined };
 }
-export class AgentBrowserNextActionCollector {
-    actions;
-    constructor(initialActions = undefined) {
-        this.actions = initialActions ? [...initialActions] : [];
-    }
-    append(actions) {
-        if (!actions || actions.length === 0)
-            return;
-        this.actions.push(...actions);
-    }
-    appendUnique(actions) {
-        appendUniqueAgentBrowserNextActions(this.actions, actions);
-    }
-    replace(actions) {
-        this.actions = actions ? [...actions] : [];
-    }
-    removeWhere(predicate) {
-        this.actions = this.actions.filter((action) => !predicate(action));
-    }
-    toArray() {
-        return this.actions.length > 0 ? [...this.actions] : undefined;
-    }
-}

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

@@ -1,13 +1,7 @@
-/**
- * Purpose: Own file artifact detection, verification, manifest merging, and inline image attachment for tool presentation.
- * Responsibilities: Build artifact metadata, verification summaries, saved-file details, artifact retention notices, and safe image content.
- * Scope: Artifact and image presentation only.
- */
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import { isRecord, parsePositiveInteger } from "../../parsing.js";
-import { formatSessionArtifactRetentionSummary, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
-import { isPendingRecordingArtifact, isPendingRecordingCommand } from "../artifact-state.js";
+import { formatSessionArtifactRetentionSummary, isPendingRecordingArtifact, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
 import { classifyAgentBrowserSuccessCategory } from "../categories.js";
 const IMAGE_EXTENSION_TO_MIME_TYPE = {
     ".gif": "image/gif",

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Build browser profile/config recovery hints for launch/setup failures.
- * Responsibilities: Recognize local Chrome/profile setup errors, avoid self-loop diagnostics, and emit canonical next actions.
- * Scope: Error presentation only; upstream profile discovery and doctor execution remain normal agent_browser commands.
- */
 import { isOpenNavigationCommand } from "../../command-taxonomy.js";
 import { getStartupScopedFlags } from "../../runtime.js";
 import { buildNextToolAction } from "../next-actions.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Share small presentation formatting and redaction helpers across result presentation modules.
- * Responsibilities: Normalize scalar fields, stringify model-facing values, and apply sensitive-text redaction.
- * Scope: Leaf helpers only; command-family formatting lives in sibling modules.
- */
 import { containsManagedSessionRestoreKey } from "../../managed-session-capabilities.js";
 import { redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { stringifyUnknown, truncateText } from "../text.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Share small ToolPresentation content helpers used by batch and compaction code.
- * Responsibilities: Extract text/image/path fields and format batch step command labels.
- * Scope: Pure ToolPresentation content helpers only.
- */
 export function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "string");
 }

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Render diagnostic command families and safe redacted diagnostic data.
- * Responsibilities: Format sessions, profiles, auth/cookies/storage, network diagnostics, console/errors, stream/dashboard/chat, and build network follow-up actions.
- * Scope: Diagnostic/result-state command presentation only; core orchestration stays in presentation.ts.
- */
 import { isRecord } from "../../parsing.js";
 import { isSensitiveFieldName, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { classifyNetworkRequestFailure, isApiLikeNetworkRequest, isNetworkArtifactNoiseRequest, summarizeNetworkFailures } from "../network.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compact oversized model-facing tool output into bounded previews and spill artifacts.
- * Responsibilities: Write full output to persistent/session temp storage, update artifact manifests, and preserve safe previews.
- * Scope: Large-output compaction only.
- */
 import { writePersistentSessionArtifactFile, writeSecureTempFile, } from "../../temp.js";
 import { buildEvictedSessionArtifactEntries } from "../artifact-manifest.js";
 import { countLines, truncateText } from "../text.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Remove wrapper-owned managed session and state capabilities from caller-visible list results.
- * Responsibilities: Recognize managed list rows recursively and preserve the surrounding upstream result shape.
- * Scope: Presentation filtering only; command authorization lives in managed-session-state-policy.ts.
- */
 import { containsManagedSessionRestoreKey, isWrapperManagedSessionName } from "../../managed-session-capabilities.js";
 import { isRecord } from "../../parsing.js";
 function isWrapperManagedSessionListItem(item) {

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Format scalar extraction results, navigation summaries, and page-change summaries.
- * Responsibilities: Keep navigation/extraction presentation separate from core tool result orchestration.
- * Scope: Navigation and get/eval extraction formatting only.
- */
 import { isNavigationObservableCommandName, isPageChangeSummaryCommand } from "../../command-taxonomy.js";
 import { isRecord } from "../../parsing.js";
 import { detectConfirmationRequired } from "../confirmation.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Map successful semanticAction results to the same presentation signals as direct ref commands.
- * Responsibilities: Resolve presentation command names, compact action prose, and navigation-summary probe gates.
- * Scope: semanticAction success presentation only.
- */
 import { getCompiledSemanticActionCommandIndex, isCompiledSemanticActionFindCommand, } from "../../input-modes/semantic-action.js";
 import { isRecord } from "../../parsing.js";
 import { formatNavigationSummary, getNavigationSummary, isNavigationObservableCommand, } from "./navigation.js";

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Render upstream agent-browser skills output as native pi tool guidance.
- * Responsibilities: Format skills list/path/get results and translate agent-browser shell snippets to agent_browser tool calls.
- * Scope: Skills command presentation only.
- */
 import { isRecord } from "../../parsing.js";
 import { getStringField, redactModelFacingText, stringifyModelFacing } from "./common.js";
 function formatSkillsListText(skills) {

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

@@ -1,8 +1,3 @@
-/*
- * Purpose: Render parsed agent-browser results into concise pi-facing summaries, text content, and optional inline image attachments.
- * Responsibilities: Orchestrate specialized presentation modules, attach inline images within size limits, and keep generic record formatting distinct from envelope parsing.
- * Scope: Presentation shaping only; upstream stdout parsing and snapshot compaction internals live in separate modules.
- */
 import { isRecord } from "../parsing.js";
 import { extractCommandTokens } from "../runtime.js";
 import { buildAgentBrowserNextActions } from "./action-recommendations.js";

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Centralize recovery-oriented nextAction ids and action construction.
- * Responsibilities: Build tab/about:blank/no-active-page/connected-session follow-ups and rich-input recovery ids.
- * Scope: Recovery action contracts only; result category classification and artifact follow-ups live elsewhere.
- * Usage: Imported by shared result action builders and the extension entrypoint.
- * Invariants/Assumptions: Ids are public machine-readable contracts mirrored by docs and tests.
- */
 import { buildNextToolAction, withOptionalSessionArgs } from "./next-actions.js";
 export const AGENT_BROWSER_RECOVERY_NEXT_ACTION_IDS = {
     aboutBlankListTabs: "list-tabs-for-about-blank-recovery",

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Build session-aware recovery nextActions that combine result category policy with known session/tab context.
- * Responsibilities: Prefix recovery argv with the active session and adapt tab/about:blank/no-active/stale-ref contexts into stable nextAction lists.
- * Scope: Recovery nextAction assembly only; diagnostic detection and action-list merge ordering stay in the extension entrypoint.
- * Usage: Imported by the extension entrypoint when adding recovery nextActions to tool details.
- * Invariants/Assumptions: Action ids and argv ordering are public contracts; session prefixing must not double-prefix explicit --session args.
- */
 import { buildAgentBrowserNextActions } from "./action-recommendations.js";
 import { withOptionalSessionArgs } from "./next-actions.js";
 export function buildConnectedSessionNextActions(sessionName) {

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Own pure selector-miss recovery diagnostics for visible refs and rich editable inputs.
- * Responsibilities: Parse find/semantic action targets, match current snapshot refs, build public diagnostics, text, and safe nextActions.
- * Scope: Selector recovery policy only; subprocess snapshot probing and result orchestration stay in the extension entrypoint.
- * Usage: The extension entrypoint supplies command tokens plus snapshot data after a selector-not-found failure.
- * Invariants/Assumptions: Public fill recovery must never echo or auto-submit the user-provided fill text; guarded semanticAction fill pre-resolution may execute only one exact current editable ref.
- */
 import { isRecord } from "../parsing.js";
 import { extractRefSnapshotFromData } from "../session-page-state.js";
 import { getEditableRefEvidence } from "./editable-ref-evidence.js";

package/dist/extensions/agent-browser/lib/results/snapshot-high-value-controls.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Select the omitted snapshot refs most likely to be actionable controls.
- * Responsibilities: Classify editable, surface, primary-action, and role-based control refs with deterministic diversity and top-up rules.
- * Scope: High-value control ranking only; snapshot parsing, noise filtering, and presentation text live in neighboring modules.
- * Usage: Snapshot presentation passes already-visible, non-noise omitted refs and receives the bounded high-value subset to surface.
- * Invariants/Assumptions: Ranking must preserve scarce control categories before filling dominant buckets so dense desktop hosts stay navigable.
- */
 import { compareRefIds } from "./text.js";
 const SNAPSHOT_HIGH_VALUE_EDITABLE_REF_FILL_TARGET_LINES = 4;
 const SNAPSHOT_HIGH_VALUE_SURFACE_REF_FILL_TARGET_LINES = 3;

package/dist/extensions/agent-browser/lib/results/snapshot-refs.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Own canonical parsing and enrichment of refs from agent-browser snapshot payloads.
- * Responsibilities: Read structured refs, correlate them with raw snapshot lines, and infer editable/ref role evidence once for consumers.
- * Scope: Snapshot ref metadata only; section preview, high-value ranking, and presentation assembly live in neighboring modules.
- * Usage: Imported by snapshot presentation and recovery diagnostics that need consistent ref/name/role/editable evidence.
- * Invariants/Assumptions: Snapshot text parsing is best-effort and must tolerate upstream formatting changes by preserving structured ref data when line parsing fails.
- */
 import { isRecord } from "../parsing.js";
 import { getEditableRefEvidence } from "./editable-ref-evidence.js";
 import { compareRefIds, normalizeWhitespace } from "./text.js";

package/dist/extensions/agent-browser/lib/results/snapshot-segments.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Parse raw agent-browser snapshot text into previewable sections.
- * Responsibilities: Identify signal lines, rank content segments, build structured previews, and provide raw-outline fallback previews.
- * Scope: Snapshot text/section planning only; ref enrichment, high-value control ranking, spill files, and final presentation live elsewhere.
- * Usage: Snapshot presentation uses this module before selecting displayed refs.
- * Invariants/Assumptions: Parsing is best-effort and must stay resilient to upstream snapshot text format changes.
- */
 import { normalizeWhitespace, truncateText } from "./text.js";
 const SNAPSHOT_MAX_ADDITIONAL_SECTIONS = 2;
 const SNAPSHOT_FALLBACK_PREVIEW_MAX_LINES = 12;

package/dist/extensions/agent-browser/lib/results/snapshot-spill.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Persist full compacted snapshot payloads when model-facing output is shortened.
- * Responsibilities: Write persistent or secure-temp snapshot spill files and merge spill retention metadata into the session artifact manifest.
- * Scope: Snapshot spill artifact lifecycle only; preview planning and presentation text live in snapshot.ts and sibling modules.
- * Usage: Snapshot presentation calls these helpers after deciding a snapshot is too large for inline output.
- * Invariants/Assumptions: Explicit full-output paths are reported but not deleted here; retention state mirrors the backing storage scope.
- */
 import { writePersistentSessionArtifactFile, writeSecureTempFile } from "../temp.js";
 import { buildEvictedSessionArtifactEntries, formatSessionArtifactRetentionSummary, mergeSessionArtifactManifest, } from "./artifact-manifest.js";
 const SNAPSHOT_SPILL_FILE_PREFIX = "pi-agent-browser-snapshot";

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Compact large agent-browser snapshots into actionable pi-facing previews while preserving access to the raw payload when budgets allow.
- * Responsibilities: Parse the current raw snapshot text format, detect when structured parsing is trustworthy, derive primary/additional content sections, rank high-value refs, and fall back to raw-outline previews when the upstream snapshot text format is unfamiliar.
- * Scope: Snapshot-specific rendering only; generic envelope parsing, non-snapshot summaries, and image attachment live in neighboring modules.
- * Usage: Imported by the focused presentation module for snapshot content and summary rendering.
- * Invariants/Assumptions: Snapshot compaction should stay helpful even if upstream snapshot text formatting shifts, so structured parsing is best-effort and always has a resilient raw-outline fallback.
- */
 import { isRecord } from "../parsing.js";
 import { isHighValueControlEntry, selectHighValueControlEntries } from "./snapshot-high-value-controls.js";
 import { buildFallbackSnapshotOutline, buildRefLineOrderMap, buildSegmentPreview, buildSnapshotSegments, canUseStructuredSnapshotPreview, chooseAdditionalSegments, choosePrimarySegment, getMeaningfulSegmentLines, getSnapshotRolePriority, isChromeSectionName, isNoiseName, parseSnapshotLines, } from "./snapshot-segments.js";

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

@@ -1,10 +1,3 @@
-/**
- * Purpose: Hold tiny text and ref-id helpers shared by result renderers.
- * Responsibilities: Convert unknown values to text, count lines, normalize whitespace, truncate labels, and sort ref ids naturally.
- * Scope: Generic pure utilities only; no agent-browser command policy belongs here.
- * Usage: Imported by envelope, presentation, snapshot, and diagnostic helpers.
- * Invariants/Assumptions: Helpers are deterministic and side-effect free.
- */
 export function stringifyUnknown(value) {
     if (typeof value === "string")
         return value;