pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -1,60 +1,87 @@
-import { JsonSchema } from "../json-schema.js";
-import { StringEnum as localStringEnum } from "../string-enum-schema.js";
-import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS } from "../electron/discovery.js";
+import { JsonSchema as Type } from "../json-schema.js";
+import { StringEnum } from "../string-enum-schema.js";
+import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS, } from "../electron/discovery-types.js";
 import { AGENT_BROWSER_CODE_MAX_TIMEOUT_MS, AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, AGENT_BROWSER_QA_LOAD_STATES, AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, DEFAULT_SESSION_MODE, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
 const AGENT_BROWSER_ADVANCED_TOOLS = ["action", "qa", "electron", "source", "network"];
-function outputProperties(Type) {
+function outputProperties() {
     return {
-        outputPath: Type.Optional(Type.String({ description: "Result-data path, separate from browser artifact paths.", minLength: 1 })),
+        outputPath: Type.Optional(Type.String({
+            description: "Result-data path, separate from browser artifact paths.",
+            minLength: 1,
+        })),
         timeoutMs: Type.Optional(Type.Integer({ description: "Timeout in ms; exceed explicit waits.", minimum: 1 })),
     };
 }
-function sessionModeProperty(Type, StringEnum) {
+function sessionModeProperty() {
     return Type.Optional(StringEnum(["auto", "fresh"], {
         description: "Native configured sessions win; auto reuses the browser, fresh intentionally launches a separate managed browser.",
         default: DEFAULT_SESSION_MODE,
     }));
 }
 // Keep the always-on schemas small; specialized guidance belongs to each advanced tool.
-export function createAgentBrowserParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserParamsSchema() {
     return Type.Unsafe(Type.Object({
-        args: Type.Array(Type.String(), { description: "Native agent-browser argv without the binary or shell syntax. Fixed sequences: batch --bail with JSON-array stdin.", minItems: 1 }),
-        stdin: Type.Optional(Type.String({ description: "Native batch JSON, eval --stdin source, or auth save --password-stdin text." })),
-        ...outputProperties(Type),
-        sessionMode: sessionModeProperty(Type, StringEnum),
+        args: Type.Array(Type.String(), {
+            description: "Native agent-browser argv without the binary or shell syntax. Fixed sequences: batch --bail with JSON-array stdin.",
+            minItems: 1,
+        }),
+        stdin: Type.Optional(Type.String({
+            description: "Native batch JSON, eval --stdin source, or auth save --password-stdin text.",
+        })),
+        ...outputProperties(),
+        sessionMode: sessionModeProperty(),
     }, { additionalProperties: false }));
 }
-export function createAgentBrowserCodeParamsSchema(Type = JsonSchema) {
+export function createAgentBrowserCodeParamsSchema() {
     return Type.Unsafe(Type.Object({
-        code: Type.String({ description: "JavaScript with await browser({args, stdin?, timeoutMs?}), emit(JSON), and emitImage(image handle). Fresh JS context; persistent browser.", minLength: 1, maxLength: 65_536 }),
-        session: Type.Optional(Type.String({ description: "Explicit native session; omitted uses the ordinary default browser.", minLength: 1 })),
-        namespace: Type.Optional(Type.String({ description: "Native namespace; empty string selects the default namespace." })),
-        ...outputProperties(Type),
+        code: Type.String({
+            description: "JavaScript with await browser({args, stdin?, timeoutMs?}), emit(JSON), and emitImage(image handle). Fresh JS context; persistent browser.",
+            minLength: 1,
+            maxLength: 65_536,
+        }),
+        session: Type.Optional(Type.String({
+            description: "Explicit native session; omitted uses the ordinary default browser.",
+            minLength: 1,
+        })),
+        namespace: Type.Optional(Type.String({
+            description: "Native namespace; empty string selects the default namespace.",
+        })),
+        ...outputProperties(),
         timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: AGENT_BROWSER_CODE_MAX_TIMEOUT_MS })),
     }, { additionalProperties: false }));
 }
-export function createAgentBrowserActionParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserActionParamsSchema() {
     return Type.Unsafe(Type.Object({
         action: StringEnum(AGENT_BROWSER_SEMANTIC_ACTIONS),
-        locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, { description: "Select supports role or label." })),
-        value: Type.Optional(Type.String({ description: "Locator value or select option; label text for select by label." })),
-        values: Type.Optional(Type.Array(Type.String(), { description: "Select options; required for select by label.", minItems: 1 })),
+        locator: Type.Optional(StringEnum(AGENT_BROWSER_SEMANTIC_LOCATORS, {
+            description: "Select supports role or label.",
+        })),
+        value: Type.Optional(Type.String({
+            description: "Locator value or select option; label text for select by label.",
+        })),
+        values: Type.Optional(Type.Array(Type.String(), {
+            description: "Select options; required for select by label.",
+            minItems: 1,
+        })),
         selector: Type.Optional(Type.String({ description: "Direct selector or current @ref." })),
         text: Type.Optional(Type.String({ description: "Fill text." })),
         role: Type.Optional(Type.String({ description: "Role locator; select needs combobox or listbox." })),
         name: Type.Optional(Type.String({ description: "Accessible name." })),
         session: Type.Optional(Type.String({ description: "Upstream session name." })),
-        ...outputProperties(Type),
+        ...outputProperties(),
     }, {
         additionalProperties: false,
         // Top-level properties let Pi normalize optional nulls before validating branches.
         anyOf: [
-            Type.Object({ action: StringEnum(["select"]), locator: Type.Optional(StringEnum(["role", "label"])) }, { not: { required: ["text"] } }),
+            Type.Object({
+                action: StringEnum(["select"]),
+                locator: Type.Optional(StringEnum(["role", "label"])),
+            }, { not: { required: ["text"] } }),
             Type.Object({ action: StringEnum(["check", "click", "fill"]) }, { not: { required: ["values"] } }),
         ],
     }));
 }
-export function createAgentBrowserQaParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserQaParamsSchema() {
     return Type.Unsafe(Type.Object({
         url: Type.Optional(Type.String()),
         attached: Type.Optional(Type.Boolean()),
@@ -65,22 +92,28 @@ export function createAgentBrowserQaParamsSchema(Type = JsonSchema, StringEnum =
         checkErrors: Type.Optional(Type.Boolean()),
         checkNetwork: Type.Optional(Type.Boolean()),
         loadState: Type.Optional(StringEnum(AGENT_BROWSER_QA_LOAD_STATES)),
-        ...outputProperties(Type),
-        sessionMode: sessionModeProperty(Type, StringEnum),
+        ...outputProperties(),
+        sessionMode: sessionModeProperty(),
     }, {
         additionalProperties: false,
         anyOf: [
-            Type.Object({ attached: Type.Literal(true), sessionMode: Type.Optional(StringEnum(["auto"])) }, { not: { required: ["url"] } }),
+            Type.Object({
+                attached: Type.Literal(true),
+                sessionMode: Type.Optional(StringEnum(["auto"])),
+            }, { not: { required: ["url"] } }),
             Type.Object({ url: Type.String(), attached: Type.Optional(Type.Literal(false)) }),
         ],
     }));
 }
-export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
-    const common = { outputPath: outputProperties(Type).outputPath };
+export function createAgentBrowserElectronParamsSchema() {
+    const common = { outputPath: outputProperties().outputPath };
     const timeoutMs = Type.Optional(Type.Integer({ minimum: 1 }));
     const list = {
         query: Type.Optional(Type.String({ description: "Case-insensitive app filter.", minLength: 1 })),
-        maxResults: Type.Optional(Type.Integer({ description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`, minimum: 1 })),
+        maxResults: Type.Optional(Type.Integer({
+            description: `Result cap; default ${ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS}, clamped to ${ELECTRON_DISCOVERY_MAX_RESULTS}.`,
+            minimum: 1,
+        })),
     };
     const launch = {
         appPath: Type.Optional(Type.String({ description: "macOS .app path.", minLength: 1 })),
@@ -100,7 +133,10 @@ export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, String
     // Each branch retains its original action-specific field boundary.
     return Type.Unsafe(Type.Object({
         action: StringEnum(["list", "launch", "status", "cleanup", "probe"]),
-        ...list, ...launch, ...lifecycle, ...common,
+        ...list,
+        ...launch,
+        ...lifecycle,
+        ...common,
     }, {
         additionalProperties: false,
         anyOf: [
@@ -111,32 +147,42 @@ export function createAgentBrowserElectronParamsSchema(Type = JsonSchema, String
         ],
     }));
 }
-export function createAgentBrowserSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserSourceParamsSchema() {
     return Type.Unsafe(Type.Object({
         selector: Type.Optional(Type.String({ description: "Visible selector or @ref." })),
         reactFiberId: Type.Optional(Type.String({ description: "React fiber id; requires --enable react-devtools." })),
         componentName: Type.Optional(Type.String({ description: "Component for local source search." })),
         includeDomHints: Type.Optional(Type.Boolean({ description: "Inspect DOM hints; default true." })),
-        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        ...outputProperties(Type),
-        sessionMode: sessionModeProperty(Type, StringEnum),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({
+            description: "Source scan cap; default 2000.",
+            minimum: 1,
+            maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES,
+        })),
+        ...outputProperties(),
+        sessionMode: sessionModeProperty(),
     }, { additionalProperties: false }));
 }
-export function createAgentBrowserNetworkSourceParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserNetworkSourceParamsSchema() {
     return Type.Unsafe(Type.Object({
         filter: Type.Optional(Type.String({ description: "Network request filter." })),
         namespace: Type.Optional(Type.String()),
         requestId: Type.Optional(Type.String({ description: "Request id to inspect." })),
         session: Type.Optional(Type.String()),
         url: Type.Optional(Type.String({ description: "Failed URL or fragment." })),
-        maxWorkspaceFiles: Type.Optional(Type.Integer({ description: "Source scan cap; default 2000.", minimum: 1, maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES })),
-        ...outputProperties(Type),
-        sessionMode: sessionModeProperty(Type, StringEnum),
+        maxWorkspaceFiles: Type.Optional(Type.Integer({
+            description: "Source scan cap; default 2000.",
+            minimum: 1,
+            maximum: SOURCE_LOOKUP_MAX_WORKSPACE_FILES,
+        })),
+        ...outputProperties(),
+        sessionMode: sessionModeProperty(),
     }, { additionalProperties: false }));
 }
-export function createAgentBrowserToolsParamsSchema(Type = JsonSchema, StringEnum = localStringEnum) {
+export function createAgentBrowserToolsParamsSchema() {
     return Type.Unsafe(Type.Object({
-        enable: Type.Optional(Type.Array(StringEnum(AGENT_BROWSER_ADVANCED_TOOLS), { description: "Add capabilities to active tools; omit to list inventory." })),
+        enable: Type.Optional(Type.Array(StringEnum(AGENT_BROWSER_ADVANCED_TOOLS), {
+            description: "Add capabilities to active tools; omit to list inventory.",
+        })),
     }, { additionalProperties: false }));
 }
 export const AGENT_BROWSER_PARAMS = createAgentBrowserParamsSchema();

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

@@ -0,0 +1,268 @@
+import { isRecord } from "../parsing.js";
+import { summarizeNetworkFailures } from "../results/network.js";
+import { stringifyUnknown } from "../results/text.js";
+import { getBatchResultItems, getCommandNameFromBatchItem, isStringArray } from "./shared.js";
+function expectedTextPreview(text) {
+    return JSON.stringify(text.length > 80 ? `${text.slice(0, 77)}...` : text);
+}
+function visibleTextWaitPassed(item, step) {
+    if (step.args[0] !== "wait" || step.args[1] !== "--fn") {
+        return undefined;
+    }
+    if (item.success === false) {
+        return false;
+    }
+    if (typeof item.result === "boolean") {
+        return item.result;
+    }
+    if (isRecord(item.result) && typeof item.result.result === "boolean") {
+        return item.result.result;
+    }
+    return true;
+}
+function textAssertionResult(item) {
+    if (item.success === false) {
+        return undefined;
+    }
+    const result = item.result;
+    if (typeof result === "string") {
+        return result;
+    }
+    if (!isRecord(result)) {
+        return undefined;
+    }
+    for (const key of ["result", "text", "value"]) {
+        if (typeof result[key] === "string") {
+            return result[key];
+        }
+    }
+    return undefined;
+}
+function subtractBaselineErrors(errors, baseline) {
+    const counts = new Map();
+    for (const error of baseline) {
+        const signature = stringifyUnknown(error);
+        counts.set(signature, (counts.get(signature) ?? 0) + 1);
+    }
+    let matchedCount = 0;
+    const novelErrors = errors.filter((error) => {
+        const signature = stringifyUnknown(error);
+        const count = counts.get(signature) ?? 0;
+        if (count === 0) {
+            return true;
+        }
+        counts.set(signature, count - 1);
+        matchedCount++;
+        return false;
+    });
+    return { matchedCount, novelErrors };
+}
+function isResetCommand(item) {
+    const command = item.command;
+    if (!isStringArray(command)) {
+        return false;
+    }
+    const [name, subcommand] = command;
+    return (command.includes("--clear") &&
+        (name === "console" || name === "errors" || (name === "network" && subcommand === "requests")));
+}
+function describeDiagnosticCheck(step) {
+    if (step.args.includes("--clear")) {
+        return undefined;
+    }
+    switch (step.args[0]) {
+        case "network":
+            return "network diagnostics";
+        case "console":
+            return "console diagnostics";
+        case "errors":
+            return step.generatedFrom === "qa.errorBaselineAfterClear"
+                ? undefined
+                : "page error diagnostics";
+        default:
+            return undefined;
+    }
+}
+function describePlannedCheck(step, checks) {
+    if (step.args[0] === "wait" && step.args[1] === "--load") {
+        return `load state: ${step.args[2]}`;
+    }
+    const selector = checks.expectedSelector;
+    if (selector !== undefined &&
+        selector.length > 0 &&
+        step.args[0] === "wait" &&
+        step.args[1] === selector) {
+        return `expected selector: ${expectedTextPreview(selector)}`;
+    }
+    if (step.action === "screenshot") {
+        return `screenshot: ${expectedTextPreview(step.args[1] ?? "")}`;
+    }
+    return describeDiagnosticCheck(step);
+}
+function describeNotRunChecks(compiled, count) {
+    let textIndex = 0;
+    const descriptions = compiled.steps.map((step) => {
+        if (step.action !== "assertText") {
+            return describePlannedCheck(step, compiled.checks);
+        }
+        const text = compiled.checks.expectedText.at(textIndex++);
+        return text === undefined || text.length === 0
+            ? undefined
+            : `expected text: ${expectedTextPreview(text)}`;
+    });
+    return descriptions
+        .slice(count)
+        .filter((description) => description !== undefined && description.length > 0);
+}
+function baselineIndex(compiled) {
+    if (compiled?.checks.diagnosticsResetAtStart !== true || !compiled.checks.checkErrors) {
+        return -1;
+    }
+    return compiled.steps.findIndex((step) => step.generatedFrom === "qa.errorBaselineAfterClear");
+}
+/** Owns one QA verdict; native diagnostic rows remain observations, not mutable state. */
+class QaVerdict {
+    failures = [];
+    warnings = [];
+    observeDiagnostic(item, baseline) {
+        const result = item.result;
+        if (!isRecord(result)) {
+            return;
+        }
+        switch (getCommandNameFromBatchItem(item)) {
+            case "errors":
+                this.observeErrors(result.errors, baseline);
+                break;
+            case "console":
+                this.observeConsole(result.messages);
+                break;
+            case "network":
+                this.observeNetwork(result.requests);
+                break;
+            case undefined:
+                break;
+            default:
+                break;
+        }
+    }
+    observeErrors(value, baseline) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return;
+        }
+        const { matchedCount, novelErrors } = subtractBaselineErrors(value, baseline);
+        if (novelErrors.length > 0) {
+            this.failures.push(`${novelErrors.length} page error(s)`);
+        }
+        if (matchedCount > 0) {
+            this.failures.push(`page-error check could not be verified (${matchedCount} row(s) matched the post-clear baseline; old residue and identical new errors are indistinguishable)`);
+        }
+    }
+    observeConsole(value) {
+        if (!Array.isArray(value)) {
+            return;
+        }
+        const errors = value.filter((message) => isRecord(message) && /error/i.test(stringifyUnknown(message.type ?? message.level ?? ""))).length;
+        if (errors > 0) {
+            this.failures.push(`${errors} console error message(s)`);
+        }
+    }
+    observeNetwork(value) {
+        if (!Array.isArray(value)) {
+            return;
+        }
+        const network = summarizeNetworkFailures(value);
+        if (network.actionableCount > 0) {
+            this.failures.push(`${network.actionableCount} actionable failed network request(s)`);
+        }
+        if (network.benignCount > 0) {
+            this.warnings.push(`${network.benignCount} benign network request failure(s) ignored`);
+        }
+    }
+    observeBatch(items, compiled) {
+        const baselineErrorIndex = baselineIndex(compiled);
+        const baselineResult = baselineErrorIndex >= 0 ? items.at(baselineErrorIndex)?.result : undefined;
+        const baseline = isRecord(baselineResult) && Array.isArray(baselineResult.errors) ? baselineResult.errors : [];
+        items.forEach((item, index) => {
+            if (item.success === false) {
+                this.failures.push(`${getCommandNameFromBatchItem(item) ?? "step"} failed`);
+            }
+            if (index === baselineErrorIndex ||
+                (compiled?.checks.diagnosticsResetAtStart === true && isResetCommand(item))) {
+                return;
+            }
+            this.observeDiagnostic(item, baseline);
+        });
+    }
+    observeExpectedText(items, compiled) {
+        let textIndex = 0;
+        compiled.steps.forEach((step, index) => {
+            if (step.action !== "assertText") {
+                return;
+            }
+            const expected = compiled.checks.expectedText.at(textIndex++);
+            const item = items.at(index);
+            if (expected === undefined || expected.length === 0 || item === undefined) {
+                return;
+            }
+            if (visibleTextWaitPassed(item, step) === true) {
+                return;
+            }
+            const actual = textAssertionResult(item);
+            if (actual === undefined || !actual.includes(expected)) {
+                this.failures.push(`expected text not found: ${expectedTextPreview(expected)}`);
+            }
+        });
+    }
+    finish(items, compiled) {
+        const stoppedEarly = compiled !== undefined && items.length < compiled.steps.length;
+        const failedFast = stoppedEarly && items.at(-1)?.success === false;
+        if (stoppedEarly && !failedFast) {
+            this.failures.push("QA execution could not be verified (incomplete batch results)");
+        }
+        const failedChecks = [...new Set(this.failures)];
+        const warnings = [...new Set(this.warnings)];
+        const notRunChecks = compiled !== undefined && failedFast ? describeNotRunChecks(compiled, items.length) : [];
+        return {
+            failedChecks,
+            warnings,
+            notRunChecks,
+            passed: failedChecks.length === 0,
+            summary: verdictSummary(failedChecks, warnings),
+        };
+    }
+}
+function verdictSummary(failures, warnings) {
+    if (failures.length > 0) {
+        return `QA preset failed: ${failures.join("; ")}.`;
+    }
+    return warnings.length === 0
+        ? "QA preset passed."
+        : `QA preset passed with warnings: ${warnings.join("; ")}.`;
+}
+export function analyzeQaPresetResults(data, compiled) {
+    const items = getBatchResultItems(data);
+    if (items.length === 0) {
+        return undefined;
+    }
+    const verdict = new QaVerdict();
+    verdict.observeBatch(items, compiled);
+    if (compiled !== undefined && compiled.checks.expectedText.length > 0) {
+        verdict.observeExpectedText(items, compiled);
+    }
+    return verdict.finish(items, compiled);
+}
+export function analyzeQaPresetTimeout(compiled) {
+    if (compiled.checks.expectedText.length === 0) {
+        return undefined;
+    }
+    const failedChecks = compiled.checks.expectedText.map((text) => `expected text was not verified before timeout: ${expectedTextPreview(text)}`);
+    return {
+        failedChecks,
+        notRunChecks: [],
+        passed: false,
+        summary: `QA preset failed: ${failedChecks.join("; ")}.`,
+        warnings: [
+            "The wrapper timed out before expected-text evidence could be verified; inspect timeoutPartialProgress and retry with a narrower readiness condition if the page was still loading.",
+        ],
+    };
+}

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

@@ -0,0 +1,117 @@
+import { isRecord } from "../parsing.js";
+import { truncateText } from "../results/text.js";
+import { getBatchResultItems, getCommandNameFromBatchItem } from "./shared.js";
+function hasPageContext(page) {
+    return (page?.title?.length ?? 0) > 0 || (page?.url?.length ?? 0) > 0;
+}
+function pageLine(page) {
+    const parts = [page?.title, page?.url].filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length === 0 ? [] : [`Page: ${parts.join(" — ")}`];
+}
+function describeChecks(checks) {
+    const parts = [`load:${checks.loadState}`];
+    if (checks.expectedText.length > 0) {
+        parts.push(`text×${checks.expectedText.length}`);
+    }
+    const enabledChecks = [
+        ["selector", (checks.expectedSelector ?? "").length > 0],
+        ["network", checks.checkNetwork],
+        ["console", checks.checkConsole],
+        ["errors", checks.checkErrors],
+    ];
+    for (const [name, enabled] of enabledChecks) {
+        if (enabled) {
+            parts.push(name);
+        }
+    }
+    if (checks.diagnosticsResetAtStart) {
+        parts.push("diagnostics-reset");
+    }
+    else if (hasDiagnostics(checks)) {
+        parts.push("attached-diagnostics-preserved");
+    }
+    if ((checks.screenshotPath ?? "").length > 0) {
+        parts.push("screenshot");
+    }
+    return parts.join(", ");
+}
+function hasDiagnostics(checks) {
+    return checks.checkNetwork || checks.checkConsole || checks.checkErrors;
+}
+function isolationLines(checks) {
+    if (!hasDiagnostics(checks)) {
+        return [];
+    }
+    if (checks.diagnosticsResetAtStart) {
+        return [
+            "Diagnostic isolation: URL QA requests clears of enabled diagnostic buffers before opening the target.",
+        ];
+    }
+    if (checks.attached) {
+        return [
+            "Attached diagnostics: existing upstream session console/network/error buffers were preserved; rows may include events from before qa.attached started.",
+        ];
+    }
+    return [];
+}
+export function extractQaPageContext(options) {
+    if (hasPageContext(options.attachedTarget)) {
+        return { title: options.attachedTarget?.title, url: options.attachedTarget?.url };
+    }
+    const page = extractBatchPageContext(options.batchData);
+    if (page !== undefined) {
+        return page;
+    }
+    const url = options.compiled?.checks.url;
+    return url === undefined || url.length === 0 ? {} : { url };
+}
+function extractBatchPageContext(data) {
+    for (const item of getBatchResultItems(data)) {
+        if (getCommandNameFromBatchItem(item) !== "open" || !isRecord(item.result)) {
+            continue;
+        }
+        const page = {
+            url: typeof item.result.url === "string" ? item.result.url : undefined,
+            title: typeof item.result.title === "string" ? item.result.title : undefined,
+        };
+        if (hasPageContext(page)) {
+            return page;
+        }
+    }
+    return undefined;
+}
+export function buildQaCompactPassText(options) {
+    const lines = [options.qaPreset.summary, ...pageLine(options.page)];
+    lines.push(`Checks run: ${describeChecks(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
+    lines.push(...isolationLines(options.checks));
+    const path = options.checks.screenshotPath;
+    if (path !== undefined && path.length > 0) {
+        const verification = options.artifactVerification;
+        lines.push(verification
+            ? `Screenshot: ${path} (${verification.verifiedCount}/${verification.artifacts.length} verified on disk)`
+            : `Screenshot: ${path}`);
+    }
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}
+export function buildQaCompactFailureText(options) {
+    const error = options.causalError;
+    const lines = [
+        error !== undefined && error.length > 0
+            ? truncateText(error.replace(/\s+/g, " ").trim(), 700)
+            : options.qaPreset.summary,
+        ...pageLine(options.page),
+    ];
+    for (const [label, entries] of [
+        ["Failed checks:", options.qaPreset.failedChecks],
+        ["Not run:", options.qaPreset.notRunChecks],
+        ["Warnings:", options.qaPreset.warnings],
+    ]) {
+        if (entries.length > 0) {
+            lines.push(label, ...entries.map((entry) => `- ${entry}`));
+        }
+    }
+    lines.push(`Execution: ${options.executedStepCount ?? "unknown"}/${options.plannedStepCount} batch steps`);
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}