pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/orchestration/browser-run/text-visibility-diagnostics.js

@@ -0,0 +1,182 @@
+import { isRecord } from "../../parsing.js";
+import { withOptionalSessionArgs } from "../../results/next-actions.js";
+import { redactSensitiveText } from "../../runtime-redaction.js";
+import { extractBatchResultCommand, extractStringResultField, runSessionCommandData, } from "./session-state.js";
+import { rawNumberField, rawStringField } from "./diagnostic-values.js";
+const SELECTOR_TEXT_VISIBILITY_CANDIDATE_LIMIT = 8;
+function buildVisibleTextProbeScript(selector) {
+    return `(() => {\n  const selector = ${JSON.stringify(selector)};\n  const isVisible = (element) => {\n    const style = window.getComputedStyle(element);\n    if (!style || style.display === 'none' || style.visibility === 'hidden' || style.visibility === 'collapse' || Number(style.opacity) === 0) return false;\n    return Array.from(element.getClientRects()).some((rect) => rect.width > 0 && rect.height > 0);\n  };\n  let matches = [];\n  try {\n    matches = Array.from(document.querySelectorAll(selector));\n  } catch (error) {\n    return JSON.stringify({ selector, error: error instanceof Error ? error.message : String(error) });\n  }\n  const visible = matches.filter(isVisible);\n  const trim = (value) => typeof value === 'string' ? value.trim().replace(/\\s+/g, ' ').slice(0, 200) : undefined;\n  const describeCandidate = (element) => {\n    const index = matches.indexOf(element);\n    const role = element.getAttribute('role');\n    const candidate = { index, tagName: element.tagName.toLowerCase(), textPreview: trim(element.textContent) };\n    if (role) candidate.role = role;\n    return candidate;\n  };\n  const visibleCandidates = visible.slice(0, ${SELECTOR_TEXT_VISIBILITY_CANDIDATE_LIMIT}).map(describeCandidate);\n  return JSON.stringify({ selector, matchCount: matches.length, visibleCount: visible.length, firstMatchVisible: matches[0] ? isVisible(matches[0]) : undefined, firstTextPreview: trim(matches[0]?.textContent), firstVisibleTextPreview: trim(visible[0]?.textContent), visibleCandidates });\n})()`;
+}
+function parseVisibleTextCandidate(entry) {
+    if (!isRecord(entry) || typeof entry.index !== "number" || typeof entry.tagName !== "string") {
+        return [];
+    }
+    const role = rawStringField(entry, "role");
+    const text = rawStringField(entry, "textPreview");
+    const textPreview = text !== undefined && text !== "" ? redactSensitiveText(text) : undefined;
+    return [
+        {
+            index: entry.index,
+            tagName: entry.tagName,
+            ...(role !== undefined && role !== "" ? { role } : {}),
+            ...(textPreview !== undefined && textPreview !== "" ? { textPreview } : {}),
+        },
+    ];
+}
+function parseSelectorTextVisibilityCandidates(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const candidates = value.flatMap(parseVisibleTextCandidate);
+    return candidates.length > 0 ? candidates : undefined;
+}
+function parseSelectorTextVisibilityProbe(data, selector) {
+    const result = extractStringResultField(data, "result");
+    if (result === undefined) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(parsed) || typeof parsed.error === "string") {
+        return undefined;
+    }
+    const matchCount = rawNumberField(parsed, "matchCount");
+    const visibleCount = rawNumberField(parsed, "visibleCount");
+    if (matchCount === undefined || visibleCount === undefined) {
+        return undefined;
+    }
+    const preview = rawStringField(parsed, "firstVisibleTextPreview");
+    return {
+        firstMatchVisible: typeof parsed.firstMatchVisible === "boolean" ? parsed.firstMatchVisible : undefined,
+        firstVisibleTextPreview: preview !== undefined && preview !== "" ? redactSensitiveText(preview) : undefined,
+        matchCount,
+        selector,
+        visibleCandidates: parseSelectorTextVisibilityCandidates(parsed.visibleCandidates),
+        visibleCount,
+    };
+}
+export function selectorMayExposeSensitiveLiteral(selector) {
+    return (redactSensitiveText(selector) !== selector ||
+        /\[[^\]]*[~|^$*]?=\s*(?:"[^"]*"|'[^']*'|[^\]\s]+)\s*(?:[is]\s*)?\]/.test(selector));
+}
+function canProbeVisibleText(selector) {
+    return (selector !== undefined &&
+        selector !== "" &&
+        !/^@e\d+$/.test(selector) &&
+        !/^#[A-Za-z_][\w-]*$/.test(selector) &&
+        !selectorMayExposeSensitiveLiteral(selector));
+}
+function selectorVisibilitySummary(parsed) {
+    const visibleMatchNoun = `visible match${parsed.visibleCount === 1 ? "" : "es"}`;
+    const visibleMatchVerb = parsed.visibleCount === 1 ? "exists" : "exist";
+    return parsed.firstMatchVisible === false
+        ? `Selector ${JSON.stringify(parsed.selector)} matched ${parsed.matchCount} elements; the first match is hidden while ${parsed.visibleCount} ${visibleMatchNoun} ${visibleMatchVerb}.`
+        : `Selector ${JSON.stringify(parsed.selector)} matched ${parsed.matchCount} elements; get text reads the first upstream match, which may not be the intended visible tab/panel.`;
+}
+async function collectSelectorTextVisibilityDiagnosticForSelector(options) {
+    const { selector } = options;
+    if (!canProbeVisibleText(selector)) {
+        return undefined;
+    }
+    const probe = await runSessionCommandData({
+        args: ["eval", "--stdin"],
+        cwd: options.cwd,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        signal: options.signal,
+        stdin: buildVisibleTextProbeScript(selector),
+    });
+    const parsed = parseSelectorTextVisibilityProbe(probe, selector);
+    if (!parsed ||
+        (parsed.matchCount <= 1 && parsed.firstMatchVisible !== false) ||
+        parsed.visibleCount === 0) {
+        return undefined;
+    }
+    return { ...parsed, summary: selectorVisibilitySummary(parsed) };
+}
+function getBatchGetTextSelectors(data) {
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    return data.flatMap((item) => {
+        if (!isRecord(item) || item.success === false) {
+            return [];
+        }
+        const tokens = extractBatchResultCommand(item);
+        const selector = tokens.at(2);
+        return tokens[0] === "get" && tokens[1] === "text" && selector !== undefined && selector !== ""
+            ? [selector]
+            : [];
+    });
+}
+export function getSuccessfulGetTextSelectors(options) {
+    if (options.commandInfo.command === "get" && options.commandInfo.subcommand === "text") {
+        return [options.commandTokens.at(2)].filter((selector) => typeof selector === "string" && selector.length > 0);
+    }
+    return options.commandInfo.command === "batch" ? getBatchGetTextSelectors(options.data) : [];
+}
+export async function collectSelectorTextVisibilityDiagnostics(options) {
+    const selectors = getSuccessfulGetTextSelectors(options);
+    const diagnostics = [];
+    for (const selector of selectors) {
+        // Native helper decisions and selector observations must remain in session order.
+        // oxlint-disable-next-line no-await-in-loop
+        const diagnostic = await collectSelectorTextVisibilityDiagnosticForSelector({
+            cwd: options.cwd,
+            namespace: options.namespace,
+            selector,
+            sessionName: options.sessionName,
+            signal: options.signal,
+        });
+        if (diagnostic) {
+            diagnostics.push(diagnostic);
+        }
+    }
+    return diagnostics.sort((left, right) => Number(right.firstMatchVisible === false) - Number(left.firstMatchVisible === false));
+}
+function formatVisibleCandidate(candidate) {
+    const role = candidate.role !== undefined && candidate.role !== "" ? ` role=${candidate.role}` : "";
+    const preview = candidate.textPreview !== undefined && candidate.textPreview !== ""
+        ? `: ${JSON.stringify(candidate.textPreview)}`
+        : "";
+    return `- [${candidate.index}] ${candidate.tagName}${role}${preview}`;
+}
+function formatSelectorVisibilityDiagnostic(diagnostic, index) {
+    const actionId = index === 0
+        ? "inspect-visible-text-candidates"
+        : `inspect-visible-text-candidates-${index + 1}`;
+    const lines = [`Selector text visibility warning: ${diagnostic.summary}`];
+    if (diagnostic.firstVisibleTextPreview !== undefined &&
+        diagnostic.firstVisibleTextPreview !== "") {
+        lines.push(`First visible text preview: ${JSON.stringify(diagnostic.firstVisibleTextPreview)}`);
+    }
+    if (diagnostic.visibleCandidates && diagnostic.visibleCandidates.length > 0) {
+        lines.push(`Visible candidates (${diagnostic.visibleCandidates.length} shown, querySelectorAll index):`, ...diagnostic.visibleCandidates.map(formatVisibleCandidate));
+    }
+    lines.push(`Next action: use details.nextActions ${actionId} before trusting this selector text.`);
+    return lines;
+}
+export function formatSelectorTextVisibilityText(diagnostics) {
+    return diagnostics.length === 0
+        ? undefined
+        : diagnostics.flatMap(formatSelectorVisibilityDiagnostic).join("\n");
+}
+export function buildSelectorTextVisibilityNextActions(options) {
+    return options.diagnostics.map((diagnostic, index) => ({
+        id: index === 0
+            ? "inspect-visible-text-candidates"
+            : `inspect-visible-text-candidates-${index + 1}`,
+        params: {
+            args: withOptionalSessionArgs(options.sessionName, ["eval", "--stdin"]),
+            stdin: buildVisibleTextProbeScript(diagnostic.selector),
+        },
+        reason: "Inspect selector match count and visible text before trusting get text on tabbed or hidden DOM content.",
+        safety: "Read-only DOM inspection; use a more specific visible selector or current @ref before acting on hidden-tab text.",
+        tool: "agent_browser",
+    }));
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/timeout-diagnostics.js

@@ -0,0 +1,256 @@
+import { stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { setTimeout as sleepMs } from "node:timers/promises";
+import { isOpenNavigationCommand } from "../../command-taxonomy.js";
+import { isBrowserIndependentRead } from "../../command-policy.js";
+import { redactInvocationArgs, redactSensitiveText } from "../../runtime-redaction.js";
+import { getUpstreamEffectiveBatchSteps } from "../batch-stdin.js";
+import { getExplicitArtifactDestination } from "./artifact-paths.js";
+import { extractStringResultField, runSessionCommandData } from "./session-state.js";
+import { redactSensitivePathSegmentsForDiagnostic, sanitizeCurrentPageUrlForTimeoutDiagnostic, } from "./timeout-progress.js";
+function getTimeoutProgressSteps(options) {
+    if (options.compiledJob) {
+        return options.compiledJob.steps.map((step, index) => ({
+            args: step.args,
+            generatedFrom: step.generatedFrom,
+            index: index + 1,
+            status: "unknown",
+            reason: "Upstream did not report this step's outcome before timeout.",
+        }));
+    }
+    return getUpstreamEffectiveBatchSteps(options.commandTokens, options.stdin).map((args, index) => ({
+        args,
+        index: index + 1,
+        status: "unknown",
+        reason: "Upstream did not report this step's outcome before timeout.",
+    }));
+}
+function getLastPositionalToken(args, startIndex = 1) {
+    for (let index = args.length - 1; index >= startIndex; index -= 1) {
+        const token = args[index];
+        if (token !== "" && !token.startsWith("-")) {
+            return token;
+        }
+    }
+    return undefined;
+}
+function getTimeoutStepArtifactPath(commandTokens) {
+    return ["screenshot", "pdf", "download", "wait"].includes(commandTokens[0])
+        ? getExplicitArtifactDestination(commandTokens)
+        : undefined;
+}
+async function statTimeoutArtifactPath(absolutePath) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            // Retries observe a still-finishing native writer only after the prior stat settles.
+            // oxlint-disable-next-line no-await-in-loop
+            const stats = await stat(absolutePath);
+            return { exists: true, sizeBytes: stats.size };
+        }
+        catch {
+            if (attempt < 2) {
+                // Backoff must complete before the next artifact observation.
+                // oxlint-disable-next-line no-await-in-loop
+                await sleepMs(25);
+            }
+        }
+    }
+    return { exists: false };
+}
+async function collectTimeoutArtifactEvidence(cwd, steps) {
+    const evidence = [];
+    for (const step of steps) {
+        const path = getTimeoutStepArtifactPath(step.args);
+        if (path === undefined || path === "") {
+            continue;
+        }
+        const absolutePath = isAbsolute(path) ? path : resolve(cwd, path);
+        // Preserve each declared path's retry window before observing the next native step's output.
+        // oxlint-disable-next-line no-await-in-loop
+        const artifact = await statTimeoutArtifactPath(absolutePath);
+        evidence.push({
+            absolutePath,
+            exists: artifact.exists,
+            path,
+            ...(artifact.exists ? { sizeBytes: artifact.sizeBytes } : {}),
+            state: artifact.exists ? "verified" : "missing",
+            stepIndex: step.index,
+        });
+    }
+    return evidence;
+}
+function getPlannedCurrentPageUrl(steps) {
+    for (let index = steps.length - 1; index >= 0; index -= 1) {
+        const args = steps.at(index)?.args ?? [];
+        if (isOpenNavigationCommand(args[0]) || args[0] === "pushstate") {
+            return getLastPositionalToken(args);
+        }
+    }
+    return undefined;
+}
+const TIMEOUT_RETRYABLE_COMMANDS = new Set([
+    "console",
+    "diff",
+    "errors",
+    "get",
+    "goto",
+    "navigate",
+    "network",
+    "open",
+    "pdf",
+    "pushstate",
+    "screenshot",
+    "snapshot",
+    "tab",
+    "vitals",
+    "wait",
+]);
+function getTimeoutStepRetry(step) {
+    const command = step.args.at(0);
+    return command !== undefined && command !== "" && TIMEOUT_RETRYABLE_COMMANDS.has(command)
+        ? { args: ["batch"], stdin: JSON.stringify([step.args]) }
+        : undefined;
+}
+function timeoutRetryStep(steps) {
+    const singleStep = steps.length === 1 ? steps.at(0) : undefined;
+    const retry = singleStep ? getTimeoutStepRetry(singleStep) : undefined;
+    return singleStep && retry ? { ...singleStep, retry } : undefined;
+}
+function currentPageSource(recoveredUrl, plannedUrl, title) {
+    if ((recoveredUrl ?? "") !== "") {
+        return "live";
+    }
+    if ((plannedUrl ?? "") !== "") {
+        return "planned";
+    }
+    return (title ?? "") !== "" ? "live" : undefined;
+}
+async function probeTimeoutPage(options) {
+    const urlData = await runSessionCommandData({
+        args: ["get", "url"],
+        cwd: options.cwd,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+    });
+    const recoveredUrl = extractStringResultField(urlData, "result") ?? extractStringResultField(urlData, "url");
+    const titleData = (recoveredUrl ?? "") !== ""
+        ? await runSessionCommandData({
+            args: ["get", "title"],
+            cwd: options.cwd,
+            namespace: options.namespace,
+            sessionName: options.sessionName,
+        })
+        : undefined;
+    const title = extractStringResultField(titleData, "result") ?? extractStringResultField(titleData, "title");
+    return { recoveredUrl, title };
+}
+function timeoutPageSummary(recoveredUrl, title, plannedUrl) {
+    if ((recoveredUrl ?? "") !== "" || (title ?? "") !== "") {
+        return " and current page state";
+    }
+    return (plannedUrl ?? "") !== "" ? " and planned page URL" : "";
+}
+function buildTimeoutPage(observed, steps) {
+    const { recoveredUrl, title } = observed;
+    const plannedUrl = (recoveredUrl ?? "") !== "" ? undefined : getPlannedCurrentPageUrl(steps);
+    const url = recoveredUrl ?? plannedUrl;
+    const source = currentPageSource(recoveredUrl, plannedUrl, title);
+    return {
+        currentPage: (url ?? "") !== "" || (title ?? "") !== "" ? { source, title, url } : undefined,
+        liveUrlRecovered: recoveredUrl !== undefined,
+        summary: timeoutPageSummary(recoveredUrl, title, plannedUrl),
+    };
+}
+function formatTimeoutSummary(stepCount, artifacts, pageSummary) {
+    const foundArtifacts = artifacts.filter((artifact) => artifact.exists).length;
+    return `Timed out before upstream returned final results; ${stepCount} planned step outcome${stepCount === 1 ? " is" : "s are"} unknown. Found ${foundArtifacts}/${artifacts.length} declared artifact path${artifacts.length === 1 ? "" : "s"}${pageSummary}; these observations do not prove step execution.`;
+}
+export async function collectTimeoutPartialProgress(options) {
+    if ((options.commandTokens[0] === "session" && options.commandTokens[1] === "info") ||
+        isBrowserIndependentRead(options.commandTokens, options.stdin)) {
+        return undefined;
+    }
+    const rawSteps = getTimeoutProgressSteps(options);
+    const artifacts = await collectTimeoutArtifactEvidence(options.operationCwd ?? options.cwd, rawSteps);
+    const page = buildTimeoutPage(await probeTimeoutPage(options), rawSteps);
+    if (rawSteps.length === 0 && artifacts.length === 0 && !page.currentPage) {
+        return undefined;
+    }
+    // A matching URL or existing file is current state, not an execution receipt.
+    const steps = rawSteps;
+    return {
+        artifacts,
+        currentPage: page.currentPage,
+        liveUrlRecovered: page.liveUrlRecovered,
+        retryStep: timeoutRetryStep(steps),
+        steps: steps.length > 0 ? steps : undefined,
+        summary: formatTimeoutSummary(steps.length, artifacts, page.summary),
+    };
+}
+function formatTimeoutSteps(steps) {
+    if (!steps || steps.length === 0) {
+        return [];
+    }
+    const shownSteps = steps.slice(0, 6);
+    const lines = [
+        "Planned steps:",
+        ...shownSteps.map((step) => {
+            const commandText = redactSensitivePathSegmentsForDiagnostic(redactInvocationArgs(step.args).join(" "));
+            const generatedFrom = step.generatedFrom !== undefined && step.generatedFrom !== ""
+                ? `, generated from ${step.generatedFrom}`
+                : "";
+            const reason = step.reason !== undefined && step.reason !== ""
+                ? ` — ${redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(step.reason))}`
+                : "";
+            return `- Step ${step.index} [${step.status}${generatedFrom}]: ${commandText}${reason}`;
+        }),
+    ];
+    if (steps.length > shownSteps.length) {
+        lines.push(`- ... ${steps.length - shownSteps.length} more step${steps.length - shownSteps.length === 1 ? "" : "s"} omitted`);
+    }
+    return lines;
+}
+function formatTimeoutRetry(step, pageTargetUnknown) {
+    if (!step?.retry) {
+        return undefined;
+    }
+    const payload = JSON.stringify({
+        ...step.retry,
+        stdin: JSON.stringify([redactInvocationArgs(step.args)]),
+    });
+    return pageTargetUnknown
+        ? `Retry candidate for step ${step.index}: ${payload}. Verify the current URL before running it.`
+        : `Retry candidate for step ${step.index} (outcome unknown): ${payload}`;
+}
+function formatTimeoutArtifact(artifact) {
+    const size = typeof artifact.sizeBytes === "number" ? `, ${artifact.sizeBytes} bytes` : "";
+    const state = artifact.exists ? `exists${size}` : "missing";
+    return `Artifact from step ${artifact.stepIndex}: ${redactSensitivePathSegmentsForDiagnostic(artifact.path)} (${state})`;
+}
+function formatTimeoutCurrentPage(page) {
+    if (!page) {
+        return undefined;
+    }
+    const title = page.title ?? "";
+    const url = page.url ?? "";
+    if (title === "" && url === "") {
+        return undefined;
+    }
+    const currentPageTitle = title !== "" ? redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(title)) : undefined;
+    const currentPageUrl = url !== "" ? sanitizeCurrentPageUrlForTimeoutDiagnostic(url) : undefined;
+    return `Current page: ${[currentPageTitle, currentPageUrl].filter(Boolean).join(" — ")}`;
+}
+export function formatTimeoutPartialProgressText(progress, pageTargetUnknown = false) {
+    const lines = [`Timeout partial progress: ${progress.summary}`];
+    const currentPage = formatTimeoutCurrentPage(progress.currentPage);
+    if (currentPage !== undefined) {
+        lines.push(currentPage);
+    }
+    lines.push(...formatTimeoutSteps(progress.steps));
+    const retry = formatTimeoutRetry(progress.retryStep, pageTargetUnknown);
+    if (retry !== undefined) {
+        lines.push(retry);
+    }
+    lines.push(...progress.artifacts.map(formatTimeoutArtifact));
+    return lines.join("\n");
+}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/timeout-progress.js

@@ -0,0 +1,108 @@
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveText } from "../../runtime-redaction.js";
+function isStringList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function optionalStringFields(value, fields) {
+    return fields.every((field) => value[field] === undefined || typeof value[field] === "string");
+}
+function isTimeoutArtifact(value) {
+    return (isRecord(value) &&
+        typeof value.absolutePath === "string" &&
+        typeof value.exists === "boolean" &&
+        typeof value.path === "string" &&
+        (value.sizeBytes === undefined || typeof value.sizeBytes === "number") &&
+        (value.state === "missing" || value.state === "verified") &&
+        typeof value.stepIndex === "number");
+}
+function isTimeoutRetry(value) {
+    return (value === undefined ||
+        (isRecord(value) && isStringList(value.args) && typeof value.stdin === "string"));
+}
+function isTimeoutStep(value) {
+    return (isRecord(value) &&
+        isStringList(value.args) &&
+        typeof value.index === "number" &&
+        value.status === "unknown" &&
+        optionalStringFields(value, ["generatedFrom", "reason"]) &&
+        isTimeoutRetry(value.retry));
+}
+function isTimeoutCurrentPage(value) {
+    return (value === undefined ||
+        (isRecord(value) &&
+            (value.source === undefined || value.source === "live" || value.source === "planned") &&
+            optionalStringFields(value, ["title", "url"])));
+}
+function isTimeoutSteps(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isTimeoutStep));
+}
+export function isTimeoutPartialProgress(value) {
+    if (!isRecord(value) ||
+        !Array.isArray(value.artifacts) ||
+        !value.artifacts.every(isTimeoutArtifact)) {
+        return false;
+    }
+    return (typeof value.summary === "string" &&
+        isTimeoutCurrentPage(value.currentPage) &&
+        (value.liveUrlRecovered === undefined || typeof value.liveUrlRecovered === "boolean") &&
+        (value.retryStep === undefined || isTimeoutStep(value.retryStep)) &&
+        isTimeoutSteps(value.steps));
+}
+export function redactSensitivePathSegmentsForDiagnostic(path) {
+    return path
+        .split(/([/\\]+)/)
+        .map((segment) => {
+        if (segment === "/" || segment === "\\" || /^[/\\]+$/.test(segment)) {
+            return segment;
+        }
+        return redactSensitiveText(segment) !== segment ||
+            /(?:secret|token|password|passwd|credential|auth|api[-_]?key|bearer)/i.test(segment)
+            ? "[REDACTED]"
+            : segment;
+    })
+        .join("");
+}
+export function sanitizeCurrentPageUrlForTimeoutDiagnostic(url) {
+    try {
+        const parsedUrl = new URL(url);
+        parsedUrl.pathname = parsedUrl.pathname
+            .split("/")
+            .map(redactSensitivePathSegmentsForDiagnostic)
+            .join("/");
+        for (const [key, value] of parsedUrl.searchParams.entries()) {
+            if (redactSensitiveText(key) !== key ||
+                redactSensitiveText(value) !== value ||
+                /(?:secret|token|password|passwd|credential|auth|api[-_]?key|bearer)/i.test(`${key} ${value}`)) {
+                parsedUrl.searchParams.set(key, "[REDACTED]");
+            }
+        }
+        if (parsedUrl.hash !== "") {
+            parsedUrl.hash = redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(parsedUrl.hash));
+        }
+        return redactSensitiveText(parsedUrl.toString());
+    }
+    catch {
+        return redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(url));
+    }
+}
+function redactProgressValue(value) {
+    if (typeof value === "string") {
+        return /^https?:\/\//i.test(value)
+            ? sanitizeCurrentPageUrlForTimeoutDiagnostic(value)
+            : redactSensitivePathSegmentsForDiagnostic(redactSensitiveText(value));
+    }
+    if (Array.isArray(value)) {
+        return value.map(redactProgressValue);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactProgressValue(item)]));
+    }
+    return value;
+}
+export function redactTimeoutPartialProgress(progress) {
+    const redacted = redactProgressValue(progress);
+    if (!isTimeoutPartialProgress(redacted)) {
+        throw new Error("Invalid timeout partial-progress evidence.");
+    }
+    return redacted;
+}

package/dist/extensions/agent-browser/lib/orchestration/code-artifact-observation.js

@@ -0,0 +1,39 @@
+import { isRecord } from "../parsing.js";
+export function collectCodeArtifactReceipts(value) {
+    if (!isRecord(value) || !Array.isArray(value.artifacts)) {
+        return [];
+    }
+    const entries = [];
+    for (const entry of value.artifacts) {
+        if (!isRecord(entry) || typeof entry.path !== "string") {
+            continue;
+        }
+        const states = [
+            "missing",
+            "pending",
+            "unverified",
+            "verified",
+        ];
+        const state = states.find((candidate) => candidate === entry.state);
+        if (state === undefined) {
+            continue;
+        }
+        entries.push({
+            ...entry,
+            path: entry.path,
+            state,
+            absolutePath: typeof entry.absolutePath === "string" ? entry.absolutePath : undefined,
+        });
+    }
+    return entries;
+}
+export function collectCodeFileArtifacts(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter(isRecord)
+        .flatMap((entry) => typeof entry.absolutePath === "string"
+        ? [{ ...entry, absolutePath: entry.absolutePath }]
+        : []);
+}