pi-agent-browser-native 0.2.77 → 0.5.0

package/dist/extensions/agent-browser/lib/argv-descriptor.js

@@ -1,9 +1,4 @@
-/**
- * Purpose: Parse raw agent-browser argv once into a stable command descriptor for planners and policy.
- * Responsibilities: Own command-token extraction, command/subcommand identification, and descriptor construction.
- * Scope: Pure argv parsing; runtime planning and session policy consume descriptors instead of re-parsing tokens.
- */
-import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS, optionalGlobalValueFlagConsumesNext } from "./argv-grammar.js";
+import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS, optionalGlobalValueFlagConsumesNext, stripUpstreamGlobalFlags } from "./argv-grammar.js";
 import { isOpenNavigationCommand } from "./command-taxonomy.js";
 function isBooleanLiteral(token) {
     const normalized = token?.trim().toLowerCase();
@@ -38,6 +33,33 @@ export function extractCommandTokens(args) {
     const commandStartIndex = findCommandStartIndex(args);
     return commandStartIndex === undefined ? [] : args.slice(commandStartIndex);
 }
+export function extractUpstreamCommandTokens(args) {
+    return stripUpstreamGlobalFlags(extractCommandTokens(args));
+}
+export function parseWaitCommandTokens(commandTokens) {
+    if (commandTokens[0] !== "wait")
+        return {};
+    const considered = commandTokens.slice(1).map((token, offset) => ({ index: offset + 1, token }));
+    const timeoutIndex = considered.findIndex((entry) => entry.token === "--timeout");
+    if (timeoutIndex >= 0)
+        considered.splice(timeoutIndex, Math.min(2, considered.length - timeoutIndex));
+    for (const flags of [["--url", "-u"], ["--load", "-l"], ["--fn", "-f"], ["--text", "-t"]]) {
+        const match = considered.find((entry) => flags.includes(entry.token));
+        if (match)
+            return { subcommand: match.token };
+    }
+    const download = considered.find((entry) => entry.token === "--download" || entry.token === "-d");
+    if (download) {
+        const downloadPathIndex = download.index + 1;
+        const candidate = commandTokens[downloadPathIndex];
+        return {
+            downloadPath: candidate && !candidate.startsWith("--") ? candidate : undefined,
+            downloadPathIndex: candidate && !candidate.startsWith("--") ? downloadPathIndex : undefined,
+            subcommand: download.token,
+        };
+    }
+    return { subcommand: considered[0]?.token };
+}
 function getOpenCommandTarget(commandTokens) {
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
@@ -56,10 +78,13 @@ function getOpenCommandTarget(commandTokens) {
     return undefined;
 }
 export function parseCommandInfoFromTokens(commandTokens) {
-    const command = commandTokens[0];
+    const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
+    const command = upstreamCommandTokens[0];
     return {
         command,
-        subcommand: isOpenNavigationCommand(command) ? getOpenCommandTarget(commandTokens) : commandTokens[1],
+        subcommand: isOpenNavigationCommand(command)
+            ? getOpenCommandTarget(upstreamCommandTokens)
+            : command === "wait" ? parseWaitCommandTokens(upstreamCommandTokens).subcommand : upstreamCommandTokens[1],
     };
 }
 export function parseCommandInfo(args) {
@@ -67,8 +92,10 @@ export function parseCommandInfo(args) {
 }
 export function parseArgvDescriptor(args) {
     const commandTokens = extractCommandTokens(args);
+    const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
     return {
         commandInfo: parseCommandInfoFromTokens(commandTokens),
         commandTokens,
+        upstreamCommandTokens,
     };
 }

package/dist/extensions/agent-browser/lib/argv-grammar.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Shared argv flag-shape metadata and helpers for command discovery and sessionless policy checks.
- * Responsibilities: Own global/command value-flag sets and boolean/value-flag validation used during argv parsing.
- * Scope: Pure token grammar; command semantics and subprocess execution live elsewhere.
- */
 import { isKnownCommandToken } from "./command-taxonomy.js";
 export const GLOBAL_VALUE_FLAGS = [
     "--session",
@@ -95,6 +90,11 @@ export const GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES = new Set([
     "--ignore-https-errors",
     "--json",
     "--no-auto-dialog",
+    "--no-pin-tab",
+    "--offline",
+    "--pin-tab",
+    "--quick",
+    "--fix",
     "--quiet",
     "-q",
     "--verbose",
@@ -125,6 +125,10 @@ export function getBooleanFlagValue(args, flag) {
 export function isBooleanFlagEnabled(args, flag) {
     return getBooleanFlagValue(args, flag) ?? false;
 }
+/** Match upstream env_var_is_truthy exactly: lowercase only, without trimming or accepting "off". */
+export function isUpstreamEnvFlagEnabled(value) {
+    return value !== undefined && !["", "0", "false", "no"].includes(value.toLowerCase());
+}
 /** Mirror upstream sanitize_session_component for namespace/socket/state identity. */
 export function canonicalizeAgentBrowserNamespace(value) {
     if (value === undefined)
@@ -149,7 +153,7 @@ export function canonicalizeAgentBrowserNamespace(value) {
     }
     return normalized.replace(/[-_]+$/u, "") || undefined;
 }
-function foldAgentBrowserFilesystemIdentity(value, platform) {
+export function foldAgentBrowserFilesystemIdentity(value, platform) {
     if (platform !== "darwin" && platform !== "win32")
         return value;
     // APFS aliases include full Unicode folds such as ß/SS and ς/Σ, not just ASCII case.
@@ -161,7 +165,11 @@ export function getAgentBrowserSessionIdentityKey(sessionName, namespace, platfo
     const canonicalSessionName = foldAgentBrowserFilesystemIdentity(sessionName, platform);
     return identityNamespace ? `${identityNamespace}\0${canonicalSessionName}` : canonicalSessionName;
 }
-/** Mirror upstream 0.33.2 global parsing: full argv, no `--` sentinel, and only global value payloads are skipped. */
+export function isAgentBrowserSessionIdentityKeyInNamespace(identityKey, namespace) {
+    const prefix = getAgentBrowserSessionIdentityKey("", namespace);
+    return prefix ? identityKey.startsWith(prefix) : !identityKey.includes("\0");
+}
+/** Mirror upstream 0.34.0 global parsing: full argv, no `--` sentinel, and only global value payloads are skipped. */
 export function scanUpstreamGlobalFlagOccurrences(args, targetFlag) {
     const occurrences = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -258,6 +266,39 @@ export function optionalGlobalValueFlagConsumesNext(flag, nextToken) {
         return false;
     return !isKnownCommandToken(nextToken);
 }
+export function projectUpstreamGlobalFlags(args) {
+    const indices = [];
+    const tokens = [];
+    let seenCommand = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token.startsWith("--restore="))
+            continue;
+        if (token === "--restore") {
+            if (!seenCommand && optionalGlobalValueFlagConsumesNext(token, args[index + 1]))
+                index += 1;
+            continue;
+        }
+        if (PREVALIDATED_VALUE_FLAGS.has(token)) {
+            index += 1;
+            continue;
+        }
+        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token)) {
+            if (["true", "false"].includes(args[index + 1] ?? ""))
+                index += 1;
+            continue;
+        }
+        tokens.push(token);
+        indices.push(index);
+        if (isKnownCommandToken(token))
+            seenCommand = true;
+    }
+    return { indices, tokens };
+}
+/** Mirror upstream 0.34.0 clean_args: remove global flags wherever they appear before command parsing. */
+export function stripUpstreamGlobalFlags(args) {
+    return projectUpstreamGlobalFlags(args).tokens;
+}
 export function stripSessionlessShapeGlobalFlags(commandTokens) {
     const stripped = [];
     for (let index = 0; index < commandTokens.length; index += 1) {

package/dist/extensions/agent-browser/lib/batch-lifecycle.js

@@ -0,0 +1,71 @@
+import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
+import { isCloseAllCommand, isCloseCommand } from "./command-taxonomy.js";
+import { isRecord } from "./parsing.js";
+function getRowBrowserLaunched(row) {
+    const result = isRecord(row.result) ? row.result : isRecord(row.data) ? row.data : undefined;
+    const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : isRecord(result?.lifecycle) ? result.lifecycle : undefined;
+    const effectiveLaunch = isRecord(lifecycle?.effectiveLaunch) ? lifecycle.effectiveLaunch : undefined;
+    return typeof effectiveLaunch?.browserLaunched === "boolean" ? effectiveLaunch.browserLaunched : undefined;
+}
+export function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
+    if (!Array.isArray(data))
+        return false;
+    return data.some((row, index) => {
+        if (!isRecord(row) || row.success !== true)
+            return false;
+        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
+            ? row.command
+            : fallbackCommands[index];
+        return rowCommand ? isCloseAllCommand(extractUpstreamCommandTokens(rowCommand)) : false;
+    });
+}
+export function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
+    if (!Array.isArray(rows))
+        return undefined;
+    let sawClose = false;
+    let endsClosed = false;
+    let browserActiveAfterClose = false;
+    let recordingClosedAfterBatch = false;
+    let statePath;
+    for (const [index, row] of rows.entries()) {
+        if (!isRecord(row))
+            continue;
+        const stepSucceeded = row.success === true;
+        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
+            ? row.command
+            : fallbackCommands[index];
+        const browserLaunched = getRowBrowserLaunched(row);
+        if (!rowCommand) {
+            if (sawClose && browserLaunched !== false) {
+                endsClosed = false;
+                browserActiveAfterClose = true;
+                recordingClosedAfterBatch = false;
+            }
+            continue;
+        }
+        const [command, subcommand] = extractUpstreamCommandTokens(rowCommand);
+        if (stepSucceeded && isCloseCommand(command)) {
+            sawClose = true;
+            endsClosed = true;
+            browserActiveAfterClose = false;
+            recordingClosedAfterBatch = true;
+            const result = isRecord(row.result) ? row.result : isRecord(row.data) ? row.data : undefined;
+            statePath = typeof result?.statePath === "string" ? result.statePath : undefined;
+        }
+        else if (sawClose && command === "record") {
+            if (browserLaunched === true || (subcommand === "stop" && browserLaunched === undefined)) {
+                endsClosed = false;
+                browserActiveAfterClose = true;
+            }
+            if (stepSucceeded && subcommand === "stop")
+                recordingClosedAfterBatch = true;
+            else if (stepSucceeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart"))
+                recordingClosedAfterBatch = false;
+        }
+        else if (sawClose && browserLaunched !== false) {
+            endsClosed = false;
+            browserActiveAfterClose = true;
+        }
+    }
+    return sawClose ? { endsClosed, recordingClosedAfterBatch, statePath } : undefined;
+}

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

@@ -1,8 +1,3 @@
-/**
- * Purpose: Own upstream command-shape policies that decide whether the wrapper should allocate a managed browser session.
- * Responsibilities: Keep local/sessionless command grammar out of the runtime execution planner while preserving exact upstream shapes.
- * Scope: Pure argv-token policy; command discovery, subprocess execution, and presentation live in focused modules.
- */
 import { hasOnlyBooleanFlags, hasOnlyOptionFlags, isNonFlagToken, stripSessionlessShapeGlobalFlags } from "./argv-grammar.js";
 const SESSIONLESS_AUTH_SUBCOMMANDS = new Set(["save", "list", "show", "delete", "remove"]);
 const PLUGIN_SESSIONLESS_SUBCOMMANDS = new Set(["list", "show", "add", "run"]);
@@ -101,5 +96,5 @@ function isSessionlessCommand(commandTokens) {
     return false;
 }
 export function needsManagedSession(descriptor) {
-    return !isSessionlessCommand(descriptor.commandTokens);
+    return !isSessionlessCommand(descriptor.upstreamCommandTokens);
 }

package/dist/extensions/agent-browser/lib/command-taxonomy.js

@@ -1,9 +1,3 @@
-/**
- * Purpose: Centralize upstream agent-browser command capabilities that wrapper behavior depends on.
- * Responsibilities: Normalize command aliases once and expose capability predicates for runtime planning,
- * session/ref guards, result recommendations, and presentation summaries without coupling unrelated behaviors.
- * Scope: Static command capability taxonomy only; command-shape parsing, spawning, and formatting live elsewhere.
- */
 const ADDITIONAL_COMMAND_TOKENS = [
     "a11y", "auth", "chat", "clipboard", "confirm", "connect", "dashboard", "deny", "device", "dialog", "diff", "doctor", "errors", "eval", "find", "frame", "get", "highlight", "inspect", "install", "is", "mcp", "plugin", "plugins", "profiles", "profiler", "react", "record", "removeinitscript", "session", "set", "skills", "snapshot", "state", "stream", "trace", "upgrade", "vitals", "wait", "web-vitals", "window",
 ];
@@ -67,6 +61,10 @@ const COMMAND_CAPABILITIES = [
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "diff",
+        guardsPageRefs: true,
+    },
     {
         command: "download",
         eligibleForPageChangeSummary: true,
@@ -98,6 +96,10 @@ const COMMAND_CAPABILITIES = [
         command: "find",
         eligibleForElectronHealthProbe: true,
     },
+    {
+        command: "frame",
+        guardsPageRefs: true,
+    },
     {
         command: "focus",
         guardsPageRefs: true,
@@ -110,6 +112,14 @@ const COMMAND_CAPABILITIES = [
         navigationObservable: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "get",
+        guardsPageRefs: true,
+    },
+    {
+        command: "highlight",
+        guardsPageRefs: true,
+    },
     {
         command: "hover",
         eligibleForPageChangeSummary: true,
@@ -117,6 +127,10 @@ const COMMAND_CAPABILITIES = [
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "is",
+        guardsPageRefs: true,
+    },
     {
         command: "keydown",
         eligibleForElectronHealthProbe: true,
@@ -191,10 +205,12 @@ const COMMAND_CAPABILITIES = [
     {
         command: "screenshot",
         eligibleForPageChangeSummary: true,
+        guardsPageRefs: true,
     },
     {
         command: "scroll",
         eligibleForPageChangeSummary: true,
+        guardsPageRefs: true,
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
@@ -287,6 +303,9 @@ export function normalizeCommandName(command) {
 export function isCloseCommand(command) {
     return hasCommandCapability(command, "closesSession");
 }
+export function isCloseAllCommand(commandTokens) {
+    return isCloseCommand(commandTokens[0]) && commandTokens.slice(1).includes("--all");
+}
 export function isOpenNavigationCommand(command) {
     return hasCommandCapability(command, "openNavigation");
 }
@@ -299,8 +318,16 @@ export function isSessionTabPinningExcludedCommand(command) {
 export function isSessionTabPostCommandCorrectionExcludedCommand(command) {
     return hasCommandCapability(command, "excludedFromPostCommandCorrection");
 }
-export function isRefInvalidatingBatchCommand(command) {
-    return hasCommandCapability(command, "invalidatesBatchRefs");
+/** Upstream 0.33.2 record start swaps to a fresh active page before its already-active check, so even a failed start can replace the page; record restart navigates the current page only when a URL operand (any fourth token, mirroring upstream's positional slot) is present. */
+export function isRecordPageTransitionCommand(tokens) {
+    if (tokens[0] !== "record")
+        return false;
+    if (tokens[1] === "start")
+        return true;
+    return tokens[1] === "restart" && tokens.length >= 4;
+}
+export function isRefInvalidatingBatchCommand(step) {
+    return hasCommandCapability(step[0], "invalidatesBatchRefs") || isRecordPageTransitionCommand(step);
 }
 export function isRefGuardedCommand(command) {
     return hasCommandCapability(command, "guardsPageRefs");

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

@@ -1,9 +1,4 @@
 // @ts-check
-/**
- * Purpose: Canonical pi-agent-browser-native config policy shared by runtime and setup CLI.
- * Responsibilities: Own config paths, provider descriptors, credential source parsing, layer validation/merge, status projection, and redacted summaries.
- * Scope: Pure configuration policy plus synchronous status loading; secret command execution and browser/web-search runtime calls live elsewhere.
- */
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";

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

@@ -1,9 +1,3 @@
-/**
- * Purpose: Load pi-agent-browser-native package configuration from Pi-scoped global, project, or explicit paths.
- * Responsibilities: Resolve config layers, resolve secrets without exposing values, and provide redacted status for tools/CLIs.
- * Scope: Package-owned configuration only; canonical config policy lives in config-policy.js, browser command execution and web-search API calls live in focused modules.
- * Invariants/Assumptions: Credential sources from loaded config are passed through to the runtime; command credentials are resolved lazily at execution time and displayed values stay redacted.
- */
 import { exec as execCallback } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";

package/dist/extensions/agent-browser/lib/electron/cdp.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Parse and fetch Chrome DevTools Protocol metadata for wrapper-owned Electron launches.
- * Responsibilities: Normalize CDP version/target JSON and perform bounded localhost CDP JSON fetches.
- * Scope: Tiny Electron CDP boundary helpers only; launch, status, cleanup, and target selection stay in their owning modules.
- * Usage: Imported by Electron launch and cleanup paths when polling `/json/version` and `/json/list`.
- * Invariants/Assumptions: Malformed or unavailable CDP endpoints return undefined/empty metadata rather than throwing, matching prior caller behavior.
- */
 import { isRecord } from "../parsing.js";
 const ELECTRON_CDP_FETCH_TIMEOUT_MS = 1_000;
 function asString(value) {
@@ -49,3 +42,9 @@ export async function fetchCdpJson(url, signal) {
         clearTimeout(timeout);
     }
 }
+export function boundElectronProbeString(value, maxLength = 240) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > maxLength ? `${trimmed.slice(0, Math.max(0, maxLength - 3))}...` : trimmed;
+}

package/dist/extensions/agent-browser/lib/electron/cleanup.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Inspect and clean wrapper-owned Electron launch resources.
- * Responsibilities: Report CDP liveness/targets without mutation and remove only tracked process/profile resources during explicit or shutdown cleanup.
- * Scope: Host-side Electron status and resource cleanup only; upstream managed-session close remains in the extension entrypoint.
- * Usage: Called by electron.status, electron.cleanup, and session_shutdown handling.
- * Invariants/Assumptions: Cleanup operates only on launch records produced by this wrapper and prefers partial cleanup reporting over killing or deleting untracked resources.
- */
 import { execFile } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { promisify } from "node:util";

package/dist/extensions/agent-browser/lib/electron/discovery.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Discover installed Electron desktop applications without invoking upstream agent-browser.
- * Responsibilities: Scan bounded macOS app bundles and Linux .desktop launchers, apply Electron framework evidence gates, and return small platform-tagged app metadata.
- * Scope: Discovery only; launch, cleanup, status, and CDP attachment live in later Electron lifecycle work items.
- * Usage: Called by the agent_browser top-level electron.list shorthand and directly by tests through parameterized scan locations.
- * Invariants/Assumptions: Discovery is best-effort, missing scan roots are ignored, malformed .desktop files are skipped, and results are capped before they reach model-visible output.
- */
 import { constants as fsConstants } from "node:fs";
 import { access, readdir, readFile, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";

package/dist/extensions/agent-browser/lib/electron/launch.js

@@ -1,10 +1,3 @@
-/**
- * Purpose: Launch wrapper-owned Electron applications and discover their CDP endpoint.
- * Responsibilities: Resolve Electron targets, enforce caller-owned allow/deny policy, create isolated userDataDir profiles, launch with remote debugging on an OS-chosen port, poll DevToolsActivePort, and read bounded CDP version/target metadata.
- * Scope: Host-side Electron lifecycle setup only; upstream agent-browser attach/presentation stays in the extension entrypoint.
- * Usage: Called by the agent_browser electron.launch shorthand before routing through upstream `connect`.
- * Invariants/Assumptions: The wrapper only launches targets with Electron framework evidence, always uses an isolated temp profile, never accepts a caller-supplied remote debugging port, and cleans any spawned process/profile when cancellation interrupts readiness.
- */
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { readFile, rm } from "node:fs/promises";

package/dist/extensions/agent-browser/lib/input-modes/electron.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compile top-level Electron wrapper inputs into validated Electron actions.
- * Responsibilities: Enforce action-specific fields, launch-target rules, and wrapper-owned flag safety.
- * Scope: Electron input-mode validation only; launch/probe/cleanup execution stays in the extension entrypoint.
- */
 import { isRecord } from "../parsing.js";
 import { AGENT_BROWSER_ELECTRON_ACTIONS, AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_LIST_FIELDS, AGENT_BROWSER_ELECTRON_PROBE_FIELDS, AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, } from "./types.js";
 function validateOptionalNonEmptyString(input, fieldName) {

package/dist/extensions/agent-browser/lib/input-modes/job.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compile constrained job and lightweight QA wrapper inputs to upstream batch commands.
- * Responsibilities: Validate job/QA fields, produce argv/stdin, and summarize QA diagnostic results.
- * Scope: Job and QA modes only.
- */
 import { isRecord } from "../parsing.js";
 import { summarizeNetworkFailures } from "../results/network.js";
 import { getBatchResultItems, getCommandNameFromBatchItem, getSelectValues } from "./shared.js";
@@ -271,7 +266,7 @@ export function buildQaCompactPassText(options) {
         lines.push(`Page: ${pageParts.join(" — ")}`);
     lines.push(`Checks run: ${describeQaChecksRun(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
     if (options.checks.diagnosticsResetAtStart && (options.checks.checkNetwork || options.checks.checkConsole || options.checks.checkErrors)) {
-        lines.push("Diagnostic reset: URL QA cleared enabled network/console/page-error buffers before opening the target; reset rows in details.batchSteps are not counted as current-page failures.");
+        lines.push("Diagnostic isolation: URL QA clears enabled network/console buffers, then snapshots any page-error residue before opening the target. Only unchanged residue is ignored because upstream page-error clear is not reliable.");
     }
     if (options.checks.attached && !options.checks.diagnosticsResetAtStart && (options.checks.checkNetwork || options.checks.checkConsole || options.checks.checkErrors)) {
         lines.push("Attached diagnostics: existing upstream session console/network/error buffers were preserved; rows may include events from before qa.attached started.");
@@ -285,6 +280,19 @@ export function buildQaCompactPassText(options) {
     lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
     return lines.join("\n");
 }
+export function buildQaCompactFailureText(options) {
+    const lines = [options.qaPreset.summary];
+    const pageParts = [options.page?.title, options.page?.url].filter((part) => typeof part === "string" && part.length > 0);
+    if (pageParts.length > 0)
+        lines.push(`Page: ${pageParts.join(" — ")}`);
+    if (options.qaPreset.failedChecks.length > 0)
+        lines.push("Failed checks:", ...options.qaPreset.failedChecks.map((failure) => `- ${failure}`));
+    if (options.qaPreset.warnings.length > 0)
+        lines.push("Warnings:", ...options.qaPreset.warnings.map((warning) => `- ${warning}`));
+    lines.push(`Checks run: ${describeQaChecksRun(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}
 const QA_VISIBLE_TEXT_TIMEOUT_MS = 5_000;
 function formatQaExpectedTextPreview(text) {
     return JSON.stringify(text.length > 80 ? `${text.slice(0, 77)}...` : text);
@@ -353,6 +361,34 @@ function extractQaTextAssertionResultText(item) {
     }
     return undefined;
 }
+function qaErrorSignature(error) {
+    if (typeof error === "string")
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function subtractQaBaselineErrors(errors, baselineErrors) {
+    const baselineCounts = new Map();
+    for (const error of baselineErrors) {
+        const signature = qaErrorSignature(error);
+        baselineCounts.set(signature, (baselineCounts.get(signature) ?? 0) + 1);
+    }
+    let ignoredCount = 0;
+    const novelErrors = errors.filter((error) => {
+        const signature = qaErrorSignature(error);
+        const count = baselineCounts.get(signature) ?? 0;
+        if (count === 0)
+            return true;
+        baselineCounts.set(signature, count - 1);
+        ignoredCount += 1;
+        return false;
+    });
+    return { ignoredCount, novelErrors };
+}
 function isDiagnosticResetCommand(item) {
     const command = item.command;
     if (!Array.isArray(command) || !command.every((token) => typeof token === "string"))
@@ -377,17 +413,29 @@ export function analyzeQaPresetResults(data, compiled) {
         return undefined;
     const failedChecks = [];
     const warnings = [];
-    for (const item of items) {
+    const baselineErrorIndex = compiled?.checks.diagnosticsResetAtStart && compiled.checks.checkErrors
+        ? compiled.steps.findIndex((step) => step.generatedFrom === "qa.errorBaselineAfterClear")
+        : -1;
+    const baselineErrorItem = baselineErrorIndex >= 0 ? items[baselineErrorIndex] : undefined;
+    const baselineErrorResult = isRecord(baselineErrorItem?.result) ? baselineErrorItem.result : undefined;
+    const baselineErrors = Array.isArray(baselineErrorResult?.errors) ? baselineErrorResult.errors : [];
+    for (const [index, item] of items.entries()) {
         if (item.success === false) {
             failedChecks.push(`${getCommandNameFromBatchItem(item) ?? "step"} failed`);
         }
+        if (index === baselineErrorIndex)
+            continue;
         const result = isRecord(item.result) ? item.result : undefined;
         const commandName = getCommandNameFromBatchItem(item);
         if (compiled?.checks.diagnosticsResetAtStart && isDiagnosticResetCommand(item)) {
             continue;
         }
         if (commandName === "errors" && Array.isArray(result?.errors) && result.errors.length > 0) {
-            failedChecks.push(`${result.errors.length} page error(s)`);
+            const { ignoredCount, novelErrors } = subtractQaBaselineErrors(result.errors, baselineErrors);
+            if (novelErrors.length > 0)
+                failedChecks.push(`${novelErrors.length} page error(s)`);
+            if (ignoredCount > 0)
+                warnings.push(`${ignoredCount} post-clear page error residue row(s) ignored as unchanged`);
         }
         if (commandName === "console" && Array.isArray(result?.messages)) {
             const errorCount = result.messages.filter((message) => isRecord(message) && /error/i.test(String(message.type ?? message.level ?? ""))).length;
@@ -482,11 +530,15 @@ export function compileAgentBrowserQaPreset(input) {
         steps.push({ action: "wait", args: ["network", "requests", "--clear"] });
     if (diagnosticsResetAtStart && checkConsole)
         steps.push({ action: "wait", args: ["console", "--clear"] });
-    if (diagnosticsResetAtStart && checkErrors)
+    if (diagnosticsResetAtStart && checkErrors) {
         steps.push({ action: "wait", args: ["errors", "--clear"] });
+        steps.push({ action: "wait", args: ["errors"], generatedFrom: "qa.errorBaselineAfterClear" });
+    }
     if (!attached && normalizedUrl)
         steps.push({ action: "open", args: ["open", normalizedUrl] });
     steps.push({ action: "wait", args: ["wait", "--load", loadState] });
+    if (checkConsole || checkErrors)
+        steps.push({ action: "wait", args: ["wait", "150"], generatedFrom: "qa.diagnosticSettle" });
     for (const text of expectedText) {
         steps.push({ action: "assertText", args: ["wait", "--fn", buildQaVisibleTextPredicate(text), "--timeout", String(QA_VISIBLE_TEXT_TIMEOUT_MS)] });
     }

package/dist/extensions/agent-browser/lib/input-modes/lookups.js

@@ -1,8 +1,3 @@
-/**
- * Purpose: Compile and analyze experimental DOM/source and network source lookup input modes.
- * Responsibilities: Build lookup batches, collect DOM/React/workspace candidates, and redact network lookup surfaces.
- * Scope: Source lookup and network source lookup only.
- */
 import { readFile, readdir } from "node:fs/promises";
 import { extname, join } from "node:path";
 import { isRecord } from "../parsing.js";
@@ -266,8 +261,8 @@ export function compileAgentBrowserNetworkSourceLookup(input) {
         return { error: "networkSourceLookup.filter must be a non-empty string when provided." };
     if (requestId !== undefined && (typeof requestId !== "string" || requestId.trim().length === 0))
         return { error: "networkSourceLookup.requestId must be a non-empty string when provided." };
-    if (namespace !== undefined && (typeof namespace !== "string" || namespace.trim().length === 0))
-        return { error: "networkSourceLookup.namespace must be a non-empty string when provided." };
+    if (namespace !== undefined && (typeof namespace !== "string" || (namespace !== "" && namespace.trim().length === 0)))
+        return { error: "networkSourceLookup.namespace must be a non-empty string or the empty default namespace when provided." };
     if (session !== undefined && (typeof session !== "string" || session.trim().length === 0))
         return { error: "networkSourceLookup.session must be a non-empty string when provided." };
     if (url !== undefined && (typeof url !== "string" || url.trim().length === 0))