rea-agents 3.2.1 → 4.0.1

package/dist/browser/CdpObservationSession.js

@@ -4,6 +4,7 @@ import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
 import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
+import { isMainFrameNavigation } from "./CdpCaptureEventHelpers.js";
 /** Observe external user actions without rejecting approved same-origin navigation. */
 export const observeCdpSession = async (context) => {
     const allowedOrigins = new Set(context.input.allowed_origins);
@@ -33,7 +34,7 @@ export const observeCdpSession = async (context) => {
             phase: "browser_observation",
             completed: 1,
             total: 2,
-            message: "Browser observation armed; perform the approved user action now",
+            message: "Browser observation armed; perform the requested user action now",
         });
         let endReason = await waitForWindow(context.input.observation_ms, capture, context.signal);
         if (endReason === "window_elapsed")
@@ -96,13 +97,13 @@ class TimelineCapture {
             return;
         switch (event.method) {
             case "Page.frameRequestedNavigation":
-                this.#navigationRequested(params);
+                this.#navigationRequested(event, params);
                 break;
             case "Page.frameNavigated":
-                this.#navigationCommitted(params);
+                this.#navigationCommitted(event, params);
                 break;
             case "Page.navigatedWithinDocument":
-                this.#sameDocument(params);
+                this.#sameDocument(event, params);
                 break;
             case "Network.requestWillBeSent":
                 this.#redirect(params);
@@ -150,8 +151,8 @@ class TimelineCapture {
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
         this.finalUrl = destination.scope === "approved" ? destination.url : null;
     }
-    #navigationRequested(params) {
-        if (stringValue(params.frameId) !== this.mainFrameId)
+    #navigationRequested(event, params) {
+        if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
         const reason = safeDetail(params.reason);
         this.#pendingReload = reason === "reload";
@@ -163,9 +164,9 @@ class TimelineCapture {
             detail: reason,
         });
     }
-    #navigationCommitted(params) {
+    #navigationCommitted(event, params) {
         const frame = recordValue(params.frame);
-        if (stringValue(frame?.id) !== this.mainFrameId)
+        if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
         const rawUrl = stringValue(frame?.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
@@ -185,8 +186,8 @@ class TimelineCapture {
             this.end("target_left_scope");
         }
     }
-    #sameDocument(params) {
-        if (stringValue(params.frameId) !== this.mainFrameId)
+    #sameDocument(event, params) {
+        if (!isMainFrameNavigation(event, this.mainFrameId))
             return;
         const rawUrl = stringValue(params.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
@@ -206,6 +207,9 @@ class TimelineCapture {
         }
     }
     #redirect(params) {
+        const resourceType = stringValue(params.type);
+        if (resourceType !== undefined && resourceType !== "Document")
+            return;
         if (stringValue(params.frameId) !== this.mainFrameId ||
             recordValue(params.redirectResponse) === undefined)
             return;

package/dist/browser/CdpPageCapture.js

@@ -24,7 +24,7 @@ export const capturePage = async (context) => {
         allowedOrigins,
         limitations: [
             "Observation starts when REA attaches; prior network and console activity is unavailable.",
-            "Raw network headers, bodies, cookies, storage values, console objects, and WebSocket payloads are never retained; separately approved captures retain only redacted text or value-free shapes.",
+            "Raw network headers, bodies, cookies, storage values, console objects, and WebSocket payloads are never retained; explicitly requested primitive console text is retained verbatim, while payload captures retain value-free shapes.",
             "Source maps are reported only as declarative URLs and are not fetched.",
             "URL-less scripts and console events without an allowed source URL are excluded because their origin cannot be proven.",
         ],

package/dist/browser/CdpPageCaptureScripts.js

@@ -20,7 +20,7 @@ const buildScriptDraft = async (script, state) => {
     let source = state
         .context.input.include_script_sources
         ? await captureScriptSource(script, state)
-        : sourceExcluded("source capture was not approved");
+        : sourceExcluded("source capture was not selected");
     const inventoryScript = {
         frame_id: state.events.frameForScript(script, state.frameIds),
         url: script.url,

package/dist/browser/CdpSafeMetadata.js

@@ -148,14 +148,15 @@ const linkParameters = (value) => {
 const safeDestination = (value, baseUrl, allowedOrigins) => {
     try {
         const parsed = new URL(value, baseUrl);
+        const sanitized = sanitizeBrowserUrl(parsed.href).url;
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
-            return { url: null, scope: "unsupported" };
+            return { url: sanitized, scope: "unsupported" };
         if (!allowedOrigins.has(parsed.origin))
-            return { url: null, scope: "outside_policy" };
-        return { url: sanitizeBrowserUrl(parsed.href).url, scope: "approved" };
+            return { url: sanitized, scope: "outside_policy" };
+        return { url: sanitized, scope: "approved" };
     }
     catch {
-        return { url: null, scope: "unsupported" };
+        return { url: value, scope: "unsupported" };
     }
 };
 const permissionFeatures = (value) => [

package/dist/browser/CdpScreenshot.js

@@ -1,5 +1,6 @@
 import { createWebScreenshotArtifact } from "../domain/webScreenshot.js";
 import { BrowserObservationError } from "../domain/errors.js";
+import { isMainFrameNavigation } from "./CdpCaptureEventHelpers.js";
 import { allowedSanitizedUrl, recordValue, stringValue, } from "./CdpCaptureValues.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
 import { captureFrames } from "./CdpCaptureDocuments.js";
@@ -21,7 +22,13 @@ export const captureCdpScreenshot = async (context) => {
     const mainFrame = captureFrames(before, origins, 1).items[0];
     if (authorized === undefined || mainFrame === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-    const navigation = { changed: false, leftScope: false };
+    const initialFrame = recordValue(recordValue(recordValue(before)?.frameTree)?.frame);
+    const navigation = {
+        changed: false,
+        leftScope: false,
+        url: beforeUrl,
+        loaderId: stringValue(initialFrame?.loaderId),
+    };
     const removeListener = context.connection.onEvent((event) => {
         if (event.sessionId !== context.sessionId)
             return;
@@ -67,19 +74,23 @@ export const captureCdpScreenshot = async (context) => {
         artifact: createWebScreenshotArtifact(bytes),
         completeness: new CdpCaptureCompleteness().snapshot(),
         limitations: [
-            "The screenshot contains the visible viewport and may include sensitive on-screen content; capture requires separate approval.",
+            "The screenshot contains the visible viewport, including on-screen content.",
             "REA does not scroll, evaluate JavaScript, or capture beyond the current viewport.",
         ],
     };
 };
 const observeScreenshotNavigation = (event, mainFrameId, origins, state) => {
+    if (!isMainFrameNavigation(event, mainFrameId))
+        return;
     const params = recordValue(event.params);
     if (params === undefined)
         return;
     const frame = event.method === "Page.frameNavigated" ? recordValue(params.frame) : params;
-    if ((event.method !== "Page.frameNavigated" &&
-        event.method !== "Page.navigatedWithinDocument") ||
-        (stringValue(frame?.id) ?? stringValue(frame?.frameId)) !== mainFrameId)
+    if (event.method === "Page.frameNavigated" &&
+        state.loaderId !== undefined &&
+        state.loaderId !== "" &&
+        stringValue(frame?.loaderId) === state.loaderId &&
+        stringValue(frame?.url) === state.url)
         return;
     state.changed = true;
     if (allowedSanitizedUrl(frame?.url, origins) === undefined)

package/dist/browser/CdpTargetSession.js

@@ -17,24 +17,45 @@ export const openCdpTargetSession = async (discovery, target, operation, signal)
     }
 };
 /** Disable enabled domains, detach browser sessions, and close REA's socket. */
-export const closeCdpTargetSession = async (targetSession, enabledDomains) => {
+export const closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
     const { connection, sessionId } = targetSession;
-    for (const domain of enabledDomains)
+    for (const [index, domain] of enabledDomains.entries()) {
+        if (signal?.aborted === true) {
+            await closeCancelledTargetSession(targetSession, enabledDomains.slice(index));
+            return;
+        }
         try {
-            await connection.send(`${domain}.disable`, {}, sessionId);
+            await connection.send(`${domain}.disable`, {}, sessionId, signal);
         }
         catch {
             // Cleanup continues to the detach or direct-socket close boundary.
         }
+    }
+    if (signal?.aborted === true) {
+        await closeCancelledTargetSession(targetSession, []);
+        return;
+    }
     if (sessionId !== undefined)
         try {
-            await connection.send("Target.detachFromTarget", { sessionId });
+            await connection.send("Target.detachFromTarget", { sessionId }, undefined, signal);
         }
         catch {
             // Closing REA's socket is the final non-destructive cleanup boundary.
         }
     await connection.close();
 };
+const closeCancelledTargetSession = async ({ connection, sessionId }, enabledDomains) => {
+    const commands = enabledDomains.map((domain) => connection.send(`${domain}.disable`, {}, sessionId));
+    if (sessionId !== undefined)
+        commands.push(connection.send("Target.detachFromTarget", { sessionId }));
+    const settled = Promise.allSettled(commands);
+    try {
+        await connection.close();
+    }
+    finally {
+        await settled;
+    }
+};
 const attachedSessionId = (value, operation) => {
     if (typeof value !== "object" ||
         value === null ||

package/dist/browser/CdpWebMcpDiscovery.js

@@ -3,9 +3,8 @@ import { inferJsonShape } from "../domain/jsonShape.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { BrowserObservationError } from "../domain/errors.js";
 import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
-import { captureFrames, mainFrameUrl } from "./CdpCaptureDocuments.js";
+import { captureFrames, mainFrameUrl, walkFrameTrees, } from "./CdpCaptureDocuments.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
-import { redactSensitiveText } from "./SensitiveTextCapture.js";
 /** Discover WebMCP registrations without evaluating or invoking page code. */
 export const discoverWebMcp = async (context) => {
     const origins = new Set(context.input.allowed_origins);
@@ -20,16 +19,16 @@ export const discoverWebMcp = async (context) => {
     if (allowedSanitizedUrl(initialUrl, origins) === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     const frames = captureFrames(frameTree, origins, undefined, completeness).items;
-    const frameUrls = new Map(frames.map((frame) => [
-        frame.frame_id,
-        {
-            url: frame.url,
-            origin: frame.origin,
-            parentFrameId: frame.parent_frame_id,
-        },
-    ]));
+    const frameUrls = initialFrameScope(frameTree, frames, completeness);
     const tools = new Map();
-    const frameScope = { origins, frames: frameUrls, tools, completeness };
+    const frameScope = {
+        origins,
+        frames: frameUrls,
+        tools,
+        completeness,
+        transientFrames: new Set(),
+        resolvedTransientFrames: new Set(),
+    };
     const removeListener = context.connection.onEvent((event) => {
         if (event.sessionId !== context.sessionId)
             return;
@@ -41,6 +40,8 @@ export const discoverWebMcp = async (context) => {
             frames: frameUrls,
             tools,
             completeness,
+            transientFrames: frameScope.transientFrames,
+            resolvedTransientFrames: frameScope.resolvedTransientFrames,
         });
     });
     await context.progress?.report({
@@ -59,6 +60,8 @@ export const discoverWebMcp = async (context) => {
             // CDP sends the enable response before the required toolsAdded replay.
             await delayWithCancellation(context.input.observation_ms, "discover_webmcp_tools", context.signal);
         await assertStableAuthorizedFrame(context, initialUrl, origins);
+        if (frameScope.transientFrames.size > 0)
+            completeness.attachLimited("webmcp_tools");
         return buildWebMcpResult({
             context,
             frameTree,
@@ -79,6 +82,27 @@ export const discoverWebMcp = async (context) => {
         });
     }
 };
+const initialFrameScope = (frameTree, frames, completeness) => {
+    const scoped = new Map(frames.map((frame) => [
+        frame.frame_id,
+        {
+            url: frame.url,
+            origin: frame.origin,
+            parentFrameId: frame.parent_frame_id,
+        },
+    ]));
+    const root = recordValue(recordValue(frameTree)?.frameTree);
+    if (root === undefined)
+        return scoped;
+    for (const tree of walkFrameTrees(root, () => completeness.exclude("webmcp_tools", "invalid_protocol_value"))) {
+        const frame = recordValue(tree.frame);
+        const frameId = stringValue(frame?.id);
+        const prior = frameId === undefined ? undefined : scoped.get(frameId);
+        if (frameId !== undefined && prior !== undefined)
+            scoped.set(frameId, { ...prior, loaderId: stringValue(frame?.loaderId) });
+    }
+    return scoped;
+};
 const ingestFrameScopeEvent = (event, state) => {
     const params = recordValue(event.params);
     if (params === undefined)
@@ -87,9 +111,9 @@ const ingestFrameScopeEvent = (event, state) => {
         case "Page.frameDetached":
             return handleFrameDetached(params, state);
         case "Page.frameNavigated":
-            return handleFrameUpdate(recordValue(params.frame), state);
+            return handleFrameUpdate(recordValue(params.frame), state, true);
         case "Page.navigatedWithinDocument":
-            return handleFrameUpdate(params, state);
+            return handleFrameUpdate(params, state, false);
         default:
             return false;
     }
@@ -101,30 +125,72 @@ const handleFrameDetached = (params, state) => {
         return true;
     }
     removeFrame(frameId, state.frames, state.tools);
+    state.transientFrames.delete(frameId);
+    state.resolvedTransientFrames.delete(frameId);
     return true;
 };
-const handleFrameUpdate = (frame, state) => {
+const handleFrameUpdate = (frame, state, documentCommitted) => {
+    if (frame === undefined) {
+        state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
+        return true;
+    }
     const frameId = stringValue(frame?.id) ?? stringValue(frame?.frameId);
     if (frameId === undefined) {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
     }
+    const rawUrl = stringValue(frame?.url);
+    // Chromium can briefly commit an inherited, empty document while replacing
+    // a subframe. That intermediate URL says nothing about the frame's eventual
+    // scope or its registered tools; wait for the next committed URL (or the
+    // authoritative frame-tree re-probe at the end of discovery).
+    if (isTransientFrameUrl(rawUrl)) {
+        if (documentCommitted) {
+            removeFrameTools(frameId, state.tools);
+            state.transientFrames.add(frameId);
+            state.resolvedTransientFrames.delete(frameId);
+        }
+        return true;
+    }
+    updateFrameScope(frame, frameId, state, documentCommitted);
+    return true;
+};
+const updateFrameScope = (frame, frameId, state, documentCommitted) => {
     const url = allowedSanitizedUrl(frame?.url, state.origins);
     if (url === undefined || url.origin === null) {
-        removeFrame(frameId, state.frames, state.tools);
+        removeFrameTools(frameId, state.tools);
+        state.frames.delete(frameId);
         state.completeness.exclude("webmcp_tools", "out_of_target_scope");
-        return true;
+        return;
     }
+    const previous = state.frames.get(frameId);
+    const loaderId = stringValue(frame?.loaderId);
+    if (hasNewDocument(documentCommitted, previous, url.url, loaderId))
+        removeFrameTools(frameId, state.tools);
+    if (documentCommitted && state.transientFrames.has(frameId))
+        state.resolvedTransientFrames.add(frameId);
     state.frames.set(frameId, {
         url: url.url,
         origin: url.origin,
+        ...(loaderId === undefined ? {} : { loaderId }),
         parentFrameId: (stringValue(frame?.parentId) ??
             state.frames.get(frameId)?.parentFrameId ??
             "") ||
             null,
     });
-    return true;
 };
+const hasNewDocument = (documentCommitted, previous, url, loaderId) => documentCommitted &&
+    previous !== undefined &&
+    (previous.url !== url ||
+        (loaderId !== undefined &&
+            previous.loaderId !== undefined &&
+            previous.loaderId !== loaderId));
+const removeFrameTools = (frameId, tools) => {
+    for (const [key, tool] of tools)
+        if (tool.frame_id === frameId)
+            tools.delete(key);
+};
+const isTransientFrameUrl = (url) => url === "" || url === "about:blank" || url === "about:srcdoc";
 const removeFrame = (frameId, frames, tools) => {
     const pending = [frameId];
     const removed = new Set();
@@ -151,7 +217,7 @@ const assertStableAuthorizedFrame = async (context, initialUrl, origins) => {
         throw new BrowserObservationError("inspect_web_page", "target_changed");
 };
 const ingestWebMcpEvent = (options) => {
-    const { event, input, frames, tools, completeness } = options;
+    const { event, input, frames, tools, completeness, transientFrames, resolvedTransientFrames, } = options;
     const params = recordValue(event.params);
     if (params === undefined)
         return;
@@ -170,6 +236,13 @@ const ingestWebMcpEvent = (options) => {
     if (event.method !== "WebMCP.toolsAdded")
         return;
     for (const declared of recordsValue(params.tools)) {
+        const frameId = stringValue(declared.frameId);
+        if (frameId !== undefined && transientFrames.has(frameId)) {
+            if (!resolvedTransientFrames.has(frameId))
+                continue;
+            transientFrames.delete(frameId);
+            resolvedTransientFrames.delete(frameId);
+        }
         const normalized = normalizeTool(declared, input, frames, completeness);
         if (normalized === undefined)
             continue;
@@ -187,11 +260,11 @@ const normalizeTool = (value, input, frames, completeness) => {
         completeness.exclude("webmcp_tools", "out_of_target_scope");
         return undefined;
     }
-    const description = redactSensitiveText(stringValue(value.description) ?? "");
+    const description = stringValue(value.description) ?? "";
     const annotations = recordValue(value.annotations);
     return {
         tool_key: toolKey(frame.url, name),
-        name: redactSensitiveText(name),
+        name,
         description,
         frame_id: frameId,
         frame_url: frame.url,

package/dist/browser/JavaScriptRuntimeScope.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "node:url";
 import { browserOriginSchema, sanitizeBrowserUrl, } from "../domain/browserObservation.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Resolve a protocol location exposed by the explicitly selected Inspector endpoint. */
@@ -34,5 +35,30 @@ export const authorizeRuntimeLocation = async (value) => {
         },
     };
 };
-/** Authorize a target whose Node Inspector URL omits its main entry path. */
-export const authorizeRuntimeTargetLocation = async (value) => authorizeRuntimeLocation(value);
+/** Interpret Node's lossy discovery metadata separately from scriptParsed URLs. */
+export const authorizeRuntimeTargetLocation = async (value, context) => {
+    if (context.type !== "node" ||
+        !/^node\.js\/v/iu.test(context.product) ||
+        !value.startsWith("file://"))
+        return authorizeRuntimeLocation(value);
+    const reportedPath = value.slice("file://".length);
+    if (!reportedPath.startsWith("/") && !/^[a-z]:[/\\_]/iu.test(reportedPath))
+        return authorizeRuntimeLocation(value);
+    // Node concatenates the pathname, then replaces quotes and backslashes with
+    // underscores. A remaining underscore cannot prove which pathname was used.
+    if (process.platform !== "win32" && !/[_"\\]/u.test(reportedPath)) {
+        if (reportedPath.startsWith("/")) {
+            const decision = await authorizeRuntimeLocation(pathToFileURL(reportedPath).href);
+            if (decision.allowed)
+                return decision;
+        }
+    }
+    return {
+        allowed: true,
+        location: {
+            kind: "unresolved",
+            reported_url: value,
+            reason: "unverifiable-file-location",
+        },
+    };
+};

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -1,4 +1,3 @@
-import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserScenarioCaptureSchema, classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
 import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
@@ -53,8 +52,8 @@ const createStep = (input) => browserScenarioStepSchema.parse({
     action: input.action,
     status: input.status,
     elapsed_ms: input.elapsedMs,
-    before_url: sanitizeBrowserUrl(input.beforeUrl),
-    after_url: sanitizeBrowserUrl(input.afterUrl),
+    before_url: input.beforeUrl,
+    after_url: input.afterUrl,
     error: input.error,
     event_sequence_start: input.eventStart,
     event_sequence_end: input.eventEnd,
@@ -70,8 +69,8 @@ const initialStep = async (input) => {
         action: "goto_start",
         status: "completed",
         elapsedMs,
-        beforeUrl: session.initialUrl,
-        afterUrl: session.currentUrl(),
+        beforeUrl: session.sanitizeUrl(session.initialUrl),
+        afterUrl: session.sanitizeUrl(session.currentUrl()),
         error: null,
         eventStart: 1,
         eventEnd: session.lastEventSequence(),
@@ -80,7 +79,7 @@ const initialStep = async (input) => {
 };
 const executeStep = async (input) => {
     const { session, scenario, action, stepIndex, priorFailure, signal } = input;
-    const beforeUrl = session.currentUrl();
+    const beforeUrl = session.sanitizeUrl(session.currentUrl());
     const eventStart = session.nextEventSequence();
     const requested = requestedForStep(scenario, stepIndex);
     if (priorFailure)
@@ -128,7 +127,7 @@ const executeStep = async (input) => {
         ...outcome,
         elapsedMs: Date.now() - actionStartedAt,
         beforeUrl,
-        afterUrl: session.currentUrl(),
+        afterUrl: session.sanitizeUrl(session.currentUrl()),
         eventStart,
         eventEnd: session.lastEventSequence(),
         artifacts,
@@ -139,6 +138,8 @@ const globalCompleteness = (scenario, session, steps) => {
     const truncated = steps.flatMap(({ completeness }) => completeness.truncated_sections);
     if (session.mode === "connect")
         missing.push("events");
+    if ((session.eventLimitations?.().length ?? 0) > 0)
+        missing.push("events");
     return classifyBrowserScenarioCompleteness(missing, truncated);
 };
 const runScenario = async (factory, scenario, options) => {
@@ -184,7 +185,6 @@ const runScenario = async (factory, scenario, options) => {
         },
         scenario: {
             start_origin: new URL(scenario.start_url.url).origin,
-            allowed_origins: scenario.allowed_origins,
             action_count: scenario.actions.length,
             secret_references: scenario.secrets.map(({ secret_id: id }) => id).sort(),
         },
@@ -196,6 +196,7 @@ const runScenario = async (factory, scenario, options) => {
             "Event sequence records provider receipt order; simultaneous browser causality is not inferred.",
             "Response bodies are not retained.",
             "Storage values are hashed only after declared-secret redaction.",
+            ...(session.eventLimitations?.() ?? []),
             ...(session.mode === "connect"
                 ? [
                     "CDP attachment cannot recover pre-attach events or guarantee launch-time context options.",

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { BrowserObservationError } from "../domain/errors.js";
-import { redactSensitiveText } from "./SensitiveTextCapture.js";
 const OPERATION = "capture_electron_scenario";
 const hookEventSchema = z.strictObject({
     sequence: z.number().int().min(1),
@@ -123,7 +122,7 @@ export const runElectronActions = async (application, input, options) => {
                 target: selectedWindow === undefined ? null : `window:${String(windowIndex)}`,
                 status: options.signal?.aborted ? "cancelled" : "failed",
                 elapsed_ms: Date.now() - actionStartedAt,
-                error: safeActionErrorMessage(cause, action),
+                error: safeActionErrorMessage(cause),
             });
             break;
         }
@@ -298,12 +297,6 @@ export const runWithExecutionLimits = async (operation, signal, deadline) => {
             signal?.removeEventListener("abort", abortListener);
     }
 };
-const safeActionErrorMessage = (cause, action) => {
-    let message = cause instanceof Error ? cause.message : "Electron action failed";
-    const inputValues = Object.values(action)
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .sort((left, right) => right.length - left.length);
-    for (const value of inputValues)
-        message = message.split(value).join("<redacted-input>");
-    return redactSensitiveText(message);
+const safeActionErrorMessage = (cause) => {
+    return cause instanceof Error ? cause.message : "Electron action failed";
 };

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -1,10 +1,10 @@
 import { realpath } from "node:fs/promises";
+import { dirname } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { _electron as electron } from "playwright-core";
 import { electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
 import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
-import { isPathContained } from "../domain/permissionPolicy.js";
 import { err, ok } from "../domain/result.js";
 import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, observeOwnedProcessLineage, selectCapturedProcessGroupIds, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
 import { runElectronActions, readApplicationState, runWithExecutionLimits, } from "./PlaywrightElectronActiveActions.js";
@@ -243,13 +243,13 @@ const createResult = (paths, input, actions, state) => {
     });
 };
 const canonicalPaths = async (input) => {
-    const [executable, application, root] = await Promise.all([
+    const [executable, application] = await Promise.all([
         realpath(input.executable_path),
         realpath(input.application_path),
-        realpath(input.application_root),
     ]);
-    if (!isPathContained(root, application))
-        throw new BrowserObservationError(OPERATION, "target_not_allowed");
+    const root = input.application_root === undefined
+        ? dirname(application)
+        : await realpath(input.application_root);
     return { executable, application, root };
 };
 const safeElectronEnvironment = (runId) => Object.fromEntries([

package/dist/browser/PlaywrightScenarioActions.js

@@ -5,7 +5,7 @@ const resolveLocator = (page, locator) => {
         case "role":
             return page.getByRole(locator.role, {
                 name: locator.name,
-                exact: locator.exact,
+                exact: true,
             });
         case "css":
             return page.locator(locator.selector);