rea-agents 3.0.0 → 3.1.0

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -0,0 +1,294 @@
+import { realpath } from "node:fs/promises";
+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";
+const OPERATION = "capture_electron_scenario";
+/** Public identity for provider-owned Electron runtime experiments. */
+export const PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY = Object.freeze({
+    id: "rea-playwright-electron-active",
+    name: "REA Playwright active Electron observation provider",
+    version: "1",
+});
+const hookPath = fileURLToPath(new URL("../../scripts/electron-active-hook.cjs", import.meta.url));
+const observableEventFamilies = [
+    "app-lifecycle",
+    "window-lifecycle",
+    "web-contents-lifecycle",
+    "navigation",
+    "shell-attempt",
+    "process-lifecycle",
+    "permission",
+    "popup-attempt",
+    "download",
+    "protocol",
+    "preload",
+    "preload-configuration",
+    "renderer-ipc",
+    "native-addon",
+    "updater",
+    "error",
+    "ipc",
+];
+const ipcEventKinds = new Set([
+    "main-handler-invocation",
+    "main-event-invocation",
+    "utility-process-fork",
+    "utility-process-message",
+    "ipc-main-to-renderer",
+    "ipc-utility-to-main",
+    "ipc-renderer-send",
+    "ipc-renderer-invoke",
+    "ipc-renderer-post-message",
+]);
+const createCoverage = (hookSnapshot) => {
+    const observedEventFamilies = [
+        ...new Set(hookSnapshot.events.map(({ kind, process_type }) => {
+            if (kind === "preload" && process_type === "main")
+                return "preload-configuration";
+            if (kind.startsWith("ipc-renderer") && process_type !== "renderer")
+                return "ipc";
+            return ipcEventKinds.has(kind) ? "ipc" : kind;
+        })),
+    ].sort();
+    const unavailableEventFamilies = new Set(observableEventFamilies.filter((family) => !observedEventFamilies.includes(family)));
+    const observedRoles = [
+        ...new Set(hookSnapshot.events.flatMap(({ process_type, kind }) => [
+            ...(process_type === null ? [] : [process_type]),
+            ...(kind === "window-lifecycle" ? ["window"] : []),
+            ...(kind === "web-contents-lifecycle" || kind === "navigation"
+                ? ["web_contents"]
+                : []),
+            ...(kind === "preload" && process_type === "preload"
+                ? ["preload"]
+                : []),
+            ...(kind.startsWith("ipc-renderer") && process_type === "renderer"
+                ? ["renderer"]
+                : []),
+        ])),
+    ].sort();
+    const rendererContextObserved = hookSnapshot.events.some(({ process_type }) => process_type === "renderer" || process_type === "preload");
+    if (!rendererContextObserved) {
+        unavailableEventFamilies.add("preload");
+        unavailableEventFamilies.add("renderer-ipc");
+    }
+    return {
+        status: hookSnapshot.hook_error
+            ? "hook_conflict"
+            : hookSnapshot.truncated
+                ? "capture_truncated"
+                : "partial_attach",
+        observed_event_families: observedEventFamilies,
+        unavailable_event_families: [...unavailableEventFamilies].sort(),
+        observed_roles: observedRoles,
+        pre_capture_activity: "unavailable",
+    };
+};
+/** Launch an owned Electron application through the official Playwright API. */
+export class PlaywrightElectronActiveProvider {
+    identity() {
+        return PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY;
+    }
+    async capture(input, options = {}) {
+        let application;
+        let ownership;
+        let lineage;
+        let outcome;
+        const runId = randomUUID();
+        try {
+            if (options.signal?.aborted === true)
+                throw new BrowserObservationError(OPERATION, "cancelled");
+            const deadline = Date.now() + input.limits.max_duration_ms;
+            const paths = await canonicalPaths(input);
+            application = await electron.launch({
+                executablePath: paths.executable,
+                cwd: paths.root,
+                env: safeElectronEnvironment(input.limits.max_ipc_events, input.limits.max_runtime_events, runId),
+                args: ["-r", hookPath, paths.application, ...input.args],
+                timeout: Math.max(1, deadline - Date.now()),
+            });
+            const leaderPid = application.process().pid;
+            if (typeof leaderPid !== "number" ||
+                !Number.isSafeInteger(leaderPid) ||
+                leaderPid <= 0)
+                throw new BrowserObservationError(OPERATION, "process_ownership_unavailable");
+            ownership = {
+                runId,
+                leaderPid,
+                processGroupId: leaderPid,
+                expectedParentPid: process.pid,
+                expectedCommand: paths.executable,
+                sweepTokenOwnedProcesses: true,
+            };
+            const actions = await runElectronActions(application, input, options, deadline);
+            const state = await runWithExecutionLimits(readApplicationState(application, input.limits.max_windows), options.signal, deadline);
+            outcome = ok(createResult(paths, input, actions, state));
+        }
+        catch (cause) {
+            outcome = err(providerError(cause));
+        }
+        if (application !== undefined) {
+            if (ownership !== undefined)
+                lineage = await observeOwnedProcessLineage(ownership);
+            let closeError;
+            try {
+                await runWithExecutionLimits(application.close(), undefined, Date.now() + 5_000);
+            }
+            catch (cause) {
+                closeError = cause;
+            }
+            const cleanup = ownership === undefined
+                ? {
+                    cleaned: false,
+                    reason: "owned Electron process identity was unavailable",
+                }
+                : await cleanupElectronProcesses(ownership, lineage);
+            if (!cleanup.cleaned)
+                return err(providerError(new BrowserObservationError(OPERATION, "cleanup_failed", {
+                    cause: new Error(cleanup.reason),
+                })));
+            if (closeError !== undefined)
+                return err(providerError(closeError));
+        }
+        return outcome;
+    }
+}
+const cleanupElectronProcesses = async (ownership, lineage) => {
+    if (process.platform === "win32") {
+        const root = await cleanupWindowsProcessTree(ownership.leaderPid);
+        if (!root.cleaned)
+            return root;
+        if (lineage?.status !== "verified")
+            return {
+                cleaned: false,
+                reason: "owned Electron lineage was unavailable; helper cleanup was not proven",
+            };
+        for (const descendant of lineage.lineage.descendants) {
+            const result = await cleanupWindowsProcessTree(descendant.pid);
+            if (!result.cleaned)
+                return result;
+        }
+        return root;
+    }
+    if (lineage?.status !== "verified") {
+        const root = await cleanupOwnedProcessGroup(ownership);
+        return root.cleaned
+            ? {
+                cleaned: false,
+                reason: "owned Electron lineage was unavailable; helper cleanup was not proven",
+            }
+            : root;
+    }
+    const groupIds = selectCapturedProcessGroupIds(ownership.leaderPid, lineage.lineage.descendants.map(({ pid, processGroupId }) => ({
+        pid,
+        process_group_id: processGroupId,
+    })));
+    let signaled = false;
+    for (const processGroupId of groupIds) {
+        const cleanupOwnership = processGroupId === ownership.processGroupId
+            ? { ...ownership, leaderPid: processGroupId, processGroupId }
+            : {
+                runId: ownership.runId,
+                leaderPid: processGroupId,
+                processGroupId,
+            };
+        const result = await cleanupOwnedProcessGroup(cleanupOwnership);
+        if (!result.cleaned)
+            return result;
+        signaled ||= result.signaled;
+    }
+    const remaining = await verifyNoTokenOwnedProcesses(ownership.runId);
+    if (!remaining.cleaned)
+        return remaining;
+    return { cleaned: true, signaled };
+};
+const createResult = (paths, input, actions, state) => {
+    const { hookSnapshot } = state;
+    const ipcEvents = hookSnapshot.events.filter(({ kind }) => ipcEventKinds.has(kind));
+    return electronActiveObservationResultSchema.parse({
+        schema_version: 1,
+        application: {
+            executable_path: paths.executable,
+            application_path: paths.application,
+            electron_version: state.electronVersion,
+            process_ownership: "provider-owned",
+            cleanup: "terminated-owned-process",
+        },
+        actions,
+        windows: state.windows.slice(0, input.limits.max_windows),
+        windows_truncated: state.windowsTruncated,
+        processes: {
+            items: state.metrics.slice(0, input.limits.max_processes),
+            truncated: state.metrics.length > input.limits.max_processes,
+        },
+        ipc: {
+            events: ipcEvents.slice(0, input.limits.max_ipc_events),
+            observed: hookSnapshot.observed_ipc,
+            retained: Math.min(ipcEvents.length, input.limits.max_ipc_events),
+            truncated: hookSnapshot.truncated ||
+                ipcEvents.length > input.limits.max_ipc_events,
+        },
+        timeline: {
+            events: hookSnapshot.events.slice(0, input.limits.max_runtime_events),
+            observed: hookSnapshot.observed,
+            retained: Math.min(hookSnapshot.events.length, input.limits.max_runtime_events),
+            truncated: hookSnapshot.truncated ||
+                hookSnapshot.events.length > input.limits.max_runtime_events,
+        },
+        coverage: createCoverage(hookSnapshot),
+        limitations: [
+            "IPC payloads are represented only by bounded value shapes; values are never retained, channels are capped at 1,024 characters, and argument-shape arrays at 32 entries.",
+            "IPC direction and sender/receiver identifiers are observed only where Electron exposes them at the hooked boundary.",
+            "The runtime timeline records bounded lifecycle, navigation, shell, permission, popup, download, protocol, preload, native-addon, process, and IPC events; activity before hook installation is unavailable.",
+            "The preload and renderer process contexts are not instrumented by the main-process -r hook; preload configuration and contextBridge API-shape events are main-boundary observations, not proof of renderer-side execution.",
+            "Process metrics are an Electron API snapshot and do not prove hostile-local-user isolation.",
+            "External shell opens, external navigation, permission grants, downloads, popup windows, updater relaunches, and OS integration are blocked and recorded by the active hook; other application filesystem and network behavior is not sandboxed by this provider.",
+            ...(state.windowsTruncated
+                ? ["Windows beyond max_windows were not retained."]
+                : []),
+            ...(hookSnapshot.hook_error
+                ? ["The active IPC hook could not be installed."]
+                : []),
+        ],
+    });
+};
+const canonicalPaths = async (input) => {
+    const [executable, application, root] = 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");
+    return { executable, application, root };
+};
+const safeElectronEnvironment = (maxIpcEvents, maxRuntimeEvents, runId) => Object.fromEntries([
+    ...[
+        "HOME",
+        "LANG",
+        "PATH",
+        "TMP",
+        "TMPDIR",
+        "USER",
+        "DISPLAY",
+        "WAYLAND_DISPLAY",
+    ]
+        .map((name) => [name, process.env[name]])
+        .filter((entry) => entry[1] !== undefined),
+    ["REA_ELECTRON_ACTIVE_MAX_IPC_EVENTS", String(maxIpcEvents)],
+    [
+        "REA_ELECTRON_ACTIVE_MAX_RUNTIME_EVENTS",
+        String(maxRuntimeEvents),
+    ],
+    ["REA_PROCESS_RUN_ID", runId],
+]);
+const providerError = (cause) => cause instanceof AnalysisError
+    ? cause
+    : new ProviderAdapterError(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id, OPERATION, {
+        cause,
+    });

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -89,9 +89,9 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, maxim
             await configureAttachedEnvironment(target.context, target.page, scenario);
             return { ...target, browser, profilePath: undefined };
         }
-        catch (error) {
+        catch (cause) {
             await browser.close();
-            throw error;
+            throw cause;
         }
     }
     const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
@@ -125,9 +125,9 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, maxim
         const page = context.pages()[0] ?? (await context.newPage());
         return { context, page, browser, profilePath };
     }
-    catch (error) {
+    catch (cause) {
         await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
-        throw error;
+        throw cause;
     }
 };
 export const closePlaywrightScenarioBrowser = async ({ context, browser, profilePath, }) => {

package/dist/browser/PlaywrightScenarioSession.js

@@ -201,11 +201,11 @@ export class PlaywrightScenarioSession {
         try {
             opened = await withPlaywrightExecutionBoundary(() => opening, remaining(), options.signal);
         }
-        catch (error) {
+        catch (cause) {
             void opening
                 .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened))
                 .catch(() => undefined);
-            throw error;
+            throw cause;
         }
         try {
             await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), remaining(), options.signal);
@@ -224,9 +224,9 @@ export class PlaywrightScenarioSession {
             }), remaining(), options.signal);
             return session;
         }
-        catch (error) {
+        catch (cause) {
             await closePlaywrightScenarioBrowser(opened);
-            throw error;
+            throw cause;
         }
     }
     currentUrl() {

package/dist/browser/SensitiveTextCapture.js

@@ -1,4 +1,4 @@
-const SECRET_ASSIGNMENT = /\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|cookie|session)\b\s*[:=]\s*(?:Bearer\s+[A-Za-z0-9._~+/=-]+|"[^"]*"|'[^']*'|[^\s,;]+)/giu;
+const SECRET_ASSIGNMENT = /\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|cookie|session)\b\s*[:=]\s*(?:Bearer\s+[A-Za-z0-9._~+/=-]+|"[^"]*"|'[^']*'|[^\s,;]+)/giu;
 const BEARER = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
 const JWT = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/gu;
 /** Redact credential-shaped substrings before approved console text is retained. */

package/dist/browser/V8InspectorCaptureProjection.js

@@ -11,6 +11,7 @@ export const describeInspectorTargetLimitations = () => [
     "REA attaches to an already-running exact target and never launches, resumes, evaluates, pauses, or mutates it.",
     "Only Runtime.enable and Debugger.enable are sent; source text, object values, EventEmitter activity, and Electron IPC are not inspected.",
     "Target IDs and locations are authorized, but the Inspector protocol does not authenticate an operating-system process ID or Electron role.",
+    "Some Electron main targets report only file://; for those targets, the first approved file root is recorded as a scope fallback and script locations are authorized independently.",
     "No runtime graph depth is traversed because passive Inspector events do not establish require/import caller edges.",
 ];
 /** Canonically authorize, deduplicate, and sort one bounded raw capture. */

package/dist/browser/V8InspectorProvider.js

@@ -3,7 +3,7 @@ import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from ".
 import { err, ok } from "../domain/result.js";
 import { boundedText, numberValue, recordValue, stringValue, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { CdpConnection } from "./CdpConnection.js";
-import { authorizeRuntimeLocation, canonicalRuntimeRoots, } from "./JavaScriptRuntimeScope.js";
+import { authorizeRuntimeTargetLocation, canonicalRuntimeRoots, } from "./JavaScriptRuntimeScope.js";
 import { createInspectorExclusionCounts, describeInspectorTargetLimitations, finalizeInspectorCapture, } from "./V8InspectorCaptureProjection.js";
 import { discoverV8Inspector, } from "./V8InspectorEndpoint.js";
 /** Public identity committed by passive V8 Inspector observations. */
@@ -24,7 +24,7 @@ export class V8InspectorProvider {
             const allowed = [];
             const excluded = createInspectorExclusionCounts();
             for (const target of discovery.targets) {
-                const decision = await authorizeRuntimeLocation(target.url, roots, input.allowed_origins);
+                const decision = await authorizeRuntimeTargetLocation(target.url, target.type, roots, input.allowed_origins);
                 if (!decision.allowed) {
                     excluded[decision.reason] += 1;
                     continue;
@@ -104,7 +104,7 @@ const authorizedTarget = async (targets, input, roots) => {
     const target = targets.find(({ id }) => id === input.target_id);
     if (target === undefined)
         throw new BrowserObservationError("observe_javascript_runtime", "target_not_found");
-    const decision = await authorizeRuntimeLocation(target.url, roots, input.allowed_origins);
+    const decision = await authorizeRuntimeTargetLocation(target.url, target.type, roots, input.allowed_origins);
     if (target.attached ||
         !decision.allowed ||
         decision.location.kind === "builtin")

package/dist/catalogIdentity.js

@@ -12,12 +12,18 @@ const toolCatalog = TOOL_CONTRACTS.map((contract) => ({
     description: contract.description,
     effects: { ...contract.effects },
     annotations: contract.annotations,
-    input_schema: z.toJSONSchema(contract.inputSchema, {
-        unrepresentable: "any",
-    }),
-    output_schema: z.toJSONSchema(contract.outputSchema, {
-        unrepresentable: "any",
-    }),
+    input_schema: {
+        type: "object",
+        ...z.toJSONSchema(contract.inputSchema, {
+            unrepresentable: "any",
+        }),
+    },
+    output_schema: {
+        type: "object",
+        ...z.toJSONSchema(contract.outputSchema, {
+            unrepresentable: "any",
+        }),
+    },
 })).sort((left, right) => left.name.localeCompare(right.name));
 const promptCatalog = PROMPT_CONTRACTS.map((contract) => ({
     name: contract.name,

package/dist/cli/managedCommands.js

@@ -388,7 +388,7 @@ const registerPlanManagedRuntimeCorrelation = (cli, logger) => {
             if (!authority.ok)
                 return projectAnalysisError(authority.error);
             const result = await planManagedRuntimeCorrelationEvidence({
-                policy: config.value.managedRuntimePolicy,
+                policy: () => config.value.managedRuntimePolicy,
                 authority: authority.value,
             }, input.value);
             return result.ok ? result.value : projectAnalysisError(result.error);

package/dist/cliApplicationCommands.js

@@ -75,7 +75,7 @@ export const registerApplicationCommands = (cli, logger) => {
             if (!authority.ok)
                 return projectAnalysisError(authority.error);
             const result = await runControlledReplay({
-                policy: config.value.javascriptReplayPolicy,
+                policy: () => config.value.javascriptReplayPolicy,
                 host: new SystemJavaScriptReplayHost(),
                 runner: new LinuxJavaScriptReplayRunner(),
                 authority: authority.value,
@@ -193,7 +193,7 @@ const configuredAuthority = async () => {
         : { ok: false, error: projectAnalysisError(configured.error) };
 };
 const replayDependencies = (config, authority) => ({
-    policy: config.javascriptReplayPolicy,
+    policy: () => config.javascriptReplayPolicy,
     host: new SystemJavaScriptReplayHost(),
     runner: new LinuxJavaScriptReplayRunner(),
     authority,

package/dist/cliBrowserAdvancedCommands.js

@@ -4,7 +4,7 @@ import { loadConfiguredPermissionAuthority } from "./application/PermissionConfi
 import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
 import { logCliCommand } from "./cliLogging.js";
 import { parseConfig } from "./config.js";
-import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, projectAnalysisError, } from "./domain/errors.js";
 import { browserCaptureComparisonInputSchema } from "./domain/browserCaptureComparison.js";
 import { discoverWebMcpToolsInputSchema } from "./domain/webMcpDiscovery.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } from "./domain/webScreenshot.js";
@@ -69,7 +69,7 @@ const registerWebMcp = (cli, logger) => {
                 .describe("Maximum nesting depth in one declared tool schema"),
         }),
         run: ({ args, options }) => logCliCommand(logger, "discover-webmcp-tools", async () => {
-            const context = await browserContext();
+            const context = await browserContext("discover_webmcp_tools");
             if (!context.ok)
                 return context.error;
             const parsed = discoverWebMcpToolsInputSchema.safeParse({
@@ -155,7 +155,7 @@ const registerScreenshot = (cli, logger) => {
                 .describe("Maximum captured PNG size"),
         }),
         run: ({ args, options }) => logCliCommand(logger, "capture-web-screenshot", async () => {
-            const context = await browserContext();
+            const context = await browserContext("capture_web_screenshot");
             if (!context.ok)
                 return context.error;
             const parsed = captureWebScreenshotInputSchema.safeParse({
@@ -210,10 +210,16 @@ const registerScreenshotDiff = (cli, logger) => {
         }),
     });
 };
-const browserContext = async () => {
+const browserContext = async (operation) => {
     const config = parseConfig(process.env);
     if (!config.ok)
         return { ok: false, error: cliError(config.error) };
+    const policy = config.value.browserObservationPolicy;
+    if (policy.status === "disabled")
+        return {
+            ok: false,
+            error: cliError(new AnalysisCapabilityUnavailableError("rea-cdp-browser", operation, "browser observation is disabled; configure exact endpoints and origins before enabling it")),
+        };
     const authority = await loadConfiguredPermissionAuthority(config.value);
     if (!authority.ok)
         return { ok: false, error: cliError(authority.error) };
@@ -221,7 +227,7 @@ const browserContext = async () => {
         ok: true,
         authority: authority.value,
         provider: new CdpBrowserProvider(),
-        allowedBrowserOrigins: config.value.browserAllowedOrigins,
+        allowedBrowserOrigins: policy.allowedOrigins,
     };
 };
 const parseJson = (value) => {

package/dist/cliBrowserCommands.js

@@ -7,7 +7,7 @@ import { parseConfig } from "./config.js";
 import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "./domain/browserObservation.js";
 import { analyzeWebBundleInputSchema } from "./domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema } from "./domain/browserSession.js";
-import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, projectAnalysisError, } from "./domain/errors.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { browserPageInspectionOptions } from "./cliObservationOptions.js";
 const browserScopeOptions = {
@@ -49,7 +49,7 @@ const registerTargetList = (cli, logger) => {
             limit: boundedCount("browser targets to return", 200, 100),
         }),
         run: ({ args, options }) => logCliCommand(logger, "list-browser-targets", async () => {
-            const context = await browserContext();
+            const context = await browserContext("list_browser_targets");
             if (!context.ok)
                 return context.error;
             const parsed = listBrowserTargetsInputSchema.safeParse({
@@ -75,7 +75,7 @@ const registerPageInspection = (cli, logger) => {
         }),
         options: browserPageInspectionOptions,
         run: ({ args, options }) => logCliCommand(logger, "inspect-web-page", async () => {
-            const context = await browserContext();
+            const context = await browserContext("inspect_web_page");
             if (!context.ok)
                 return context.error;
             const parsed = inspectWebPageInputSchema.safeParse({
@@ -92,6 +92,7 @@ const registerPageInspection = (cli, logger) => {
                 include_websocket_shapes: options.includeWebsocketShapes,
                 websocket_shape_approved: options.websocketShapeApproved,
                 include_script_sources: options.includeScriptSources,
+                source_capture_approved: options.sourceCaptureApproved,
                 include_storage_keys: options.includeStorageKeys,
                 include_storage_fingerprints: options.includeStorageFingerprints,
                 limits: {
@@ -157,7 +158,7 @@ const registerBundleAnalysis = (cli, logger) => {
             maxOriginalSources: boundedCount("original source files", 20_000, 2_000),
         }),
         run: ({ args, options }) => logCliCommand(logger, "analyze-web-bundle", async () => {
-            const context = await browserContext();
+            const context = await browserContext("analyze_web_bundle");
             if (!context.ok)
                 return context.error;
             const parsed = analyzeWebBundleInputSchema.safeParse({
@@ -200,7 +201,7 @@ const registerObservationSession = (cli, logger) => {
             maxTimelineEvents: boundedCount("timeline events", 20_000, 2_000),
         }),
         run: ({ args, options }) => logCliCommand(logger, "observe-web-session", async () => {
-            const context = await browserContext();
+            const context = await browserContext("observe_web_session");
             if (!context.ok)
                 return context.error;
             const parsed = observeWebSessionInputSchema.safeParse({
@@ -218,10 +219,16 @@ const registerObservationSession = (cli, logger) => {
         }),
     });
 };
-const browserContext = async () => {
+const browserContext = async (operation) => {
     const config = parseConfig(process.env);
     if (!config.ok)
         return { ok: false, error: cliError(config.error) };
+    const policy = config.value.browserObservationPolicy;
+    if (policy.status === "disabled")
+        return {
+            ok: false,
+            error: cliError(new AnalysisCapabilityUnavailableError("rea-cdp-browser", operation, "browser observation is disabled; configure exact endpoints and origins before enabling it")),
+        };
     const authority = await loadConfiguredPermissionAuthority(config.value);
     if (!authority.ok)
         return { ok: false, error: cliError(authority.error) };
@@ -229,7 +236,7 @@ const browserContext = async () => {
         ok: true,
         authority: authority.value,
         provider: new CdpBrowserProvider(),
-        allowedBrowserOrigins: config.value.browserAllowedOrigins,
+        allowedBrowserOrigins: policy.allowedOrigins,
     };
 };
 const cliError = (error) => ({

package/dist/cliCommandNames.js

@@ -50,6 +50,7 @@ export const CLI_COMMANDS = Object.freeze({
     captureBrowserScenario: "capture-browser-scenario",
     listElectronTargets: "list-electron-targets",
     inspectElectronPage: "inspect-electron-page",
+    captureElectronScenario: "capture-electron-scenario",
     listJavaScriptRuntimeTargets: "list-javascript-runtime-targets",
     observeJavaScriptRuntime: "observe-javascript-runtime",
     analyzeJavaScriptApplication: "analyze-javascript-application",