rea-agents 3.1.0 → 3.2.0

package/dist/application/DirectAnalysis.js

@@ -1,16 +1,17 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
+import { artifactExtractionPermissionRequest } from "./ArtifactExtractionDestination.js";
 import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { createBinarySession } from "./runtime.js";
 import { silentLogger } from "../logger.js";
 import { createEvidence } from "../domain/evidence.js";
-import { EvidenceIntegrityError, AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { EvidenceIntegrityError, projectAnalysisError, } from "../domain/errors.js";
 import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./AnalysisSnapshotFiles.js";
-import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
 import { err, ok } from "../domain/result.js";
 import { loadConfiguredPermissionAuthority } from "./PermissionConfiguration.js";
-import { authorizeFileReadWithDeferredWrite, } from "./DeferredFileAuthorization.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 export { runCapabilityStatus, runProviderStatus, } from "./DirectAnalysisStatus.js";
@@ -40,26 +41,13 @@ const authorizeAnalysis = async (authority, tool, arguments_) => {
     const requests = [];
     if (tool === "extract_artifact" && typeof arguments_.output_root === "string")
         requests.push({
-            capability: "artifact_extract",
-            path: arguments_.output_root,
+            request: artifactExtractionPermissionRequest(),
             access: "write",
         });
     for (const request of requests) {
-        const result = await authority.authorize({
-            capability: request.capability,
-            roots: [request.path],
-            executables: [],
-            environment_names: [],
-            network: "none",
-            mount: false,
-            operation_identity: `${tool}:${request.capability}:${request.path}`,
-        }, request.access);
+        const result = await authority.authorize(request.request, request.access);
         if (!result.ok)
-            return err(result.error instanceof PermissionRequiredError
-                ? result.error
-                : new AnalysisProtocolError(result.error.message, {
-                    cause: result.error,
-                }));
+            return err(projectPermissionFailure(result.error));
     }
     if (["inventory_artifact", "inspect_artifact"].includes(tool) &&
         arguments_.native_mount_approved === true) {
@@ -73,26 +61,13 @@ const authorizeAnalysis = async (authority, tool, arguments_) => {
             operation_identity: `${tool}:native_mount`,
         }, "read");
         if (!result.ok)
-            return err(result.error instanceof PermissionRequiredError
-                ? result.error
-                : new AnalysisProtocolError(result.error.message, {
-                    cause: result.error,
-                }));
+            return err(projectPermissionFailure(result.error));
     }
     return ok(null);
 };
 const permissionAuthorityFor = (config, supplied) => supplied === undefined
     ? loadConfiguredPermissionAuthority(config)
     : Promise.resolve(ok(supplied));
-const authorizeSnapshotAccess = async (authority, tool, snapshotPath) => snapshotPath === undefined
-    ? ok(undefined)
-    : authorizeFileReadWithDeferredWrite(authority, {
-        path: snapshotPath,
-        readCapability: "snapshot_read",
-        writeCapability: "snapshot_write",
-        operation: tool,
-    });
-const authorizeDeferredWrite = (authorization) => authorization?.authorizeWrite() ?? Promise.resolve(ok(null));
 const authorizeAnalysisRun = async (input) => {
     const authority = await permissionAuthorityFor(input.config, input.suppliedAuthority);
     if (!authority.ok)
@@ -100,7 +75,7 @@ const authorizeAnalysisRun = async (input) => {
     const operation = await authorizeAnalysis(authority.value, input.tool, input.arguments);
     if (!operation.ok)
         return operation;
-    return authorizeSnapshotAccess(authority.value, input.tool, input.snapshotPath);
+    return ok(null);
 };
 const runAnalysis = async (path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
@@ -112,7 +87,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         suppliedAuthority: options.permissionAuthority,
         tool,
         arguments: arguments_,
-        snapshotPath,
     });
     if (!authorization.ok)
         return cliError(authorization.error);
@@ -121,7 +95,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
-            policy: config.value.analysisSnapshotFilePolicy,
         });
         if (!prepared.ok)
             return cliError(prepared.error);
@@ -137,7 +110,8 @@ const runAnalysis = async (path, tool, arguments_, options) => {
             return cliError(opened.error);
         const evidenceProfile = analysisProfileForEvidence(session, tool);
         const bindingProfile = session.analysisProfile();
-        if (snapshot !== undefined &&
+        if (tool !== "trace_native_ui_action" &&
+            snapshot !== undefined &&
             evidenceProfile !== undefined &&
             bindingProfile !== undefined) {
             const cached = snapshotEvidenceForQuery(snapshot, {
@@ -151,9 +125,6 @@ const runAnalysis = async (path, tool, arguments_, options) => {
             if (cached !== undefined)
                 return cached;
         }
-        const writable = await authorizeDeferredWrite(authorization.value);
-        if (!writable.ok)
-            return cliError(writable.error);
         const { output, evidence } = await executeAnalysisTool({
             session,
             openedTarget: opened.value,
@@ -164,11 +135,13 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         });
         if (evidence !== undefined)
             session.recordEvidence(evidence);
-        if (snapshotPath !== undefined && evidence !== undefined) {
+        if (tool !== "trace_native_ui_action" &&
+            snapshotPath !== undefined &&
+            evidence !== undefined) {
             const snapshot = session.exportAnalysisSnapshot();
             if (!snapshot.ok)
                 return cliError(snapshot.error);
-            const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true, config.value.analysisSnapshotFilePolicy);
+            const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true);
             if (!written.ok)
                 return cliError(written.error);
         }
@@ -183,7 +156,9 @@ const executeAnalysisTool = async (input) => {
     if (tool === "binary_overview" ||
         tool === "analyze_function" ||
         tool === "inspect_native_api" ||
-        tool === "trace_feature") {
+        tool === "inspect_native_dispatch_metadata" ||
+        tool === "trace_feature" ||
+        tool === "trace_native_ui_action") {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
             return { output: cliError(result.error) };
@@ -235,10 +210,10 @@ const withProcessCancellation = async (suppliedSignal, operation) => {
     }
 };
 const prepareSnapshot = async (options) => {
-    const { path, snapshotPath, policy } = options;
+    const { path, snapshotPath } = options;
     if (snapshotPath === undefined || !(await fileExists(snapshotPath)))
         return ok({});
-    const loaded = await readAnalysisSnapshot(snapshotPath, policy);
+    const loaded = await readAnalysisSnapshot(snapshotPath);
     if (!loaded.ok)
         return loaded;
     const target = await parseBinaryTarget(path);
@@ -259,7 +234,8 @@ const analysisProfileForEvidence = (session, tool) => {
 };
 const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
     tool === "inspect_native_api" ||
-    tool === "trace_feature";
+    tool === "trace_feature" ||
+    tool === "trace_native_ui_action";
 const fileExists = async (path) => {
     try {
         await access(path);

package/dist/application/DirectAnalysisStatus.js

@@ -1,7 +1,7 @@
 import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/errors.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { createServerIdentity, createServerIdentitySummary, } from "../serverIdentity.js";
+import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
 import { createBinarySession } from "./runtime.js";
 const runSessionStatus = async (logger = silentLogger) => {
@@ -21,63 +21,7 @@ const runSessionStatus = async (logger = silentLogger) => {
         await session.close();
     }
 };
-/** List provider identities, selection, and availability without capability bodies. */
-export const runProviderStatus = async (logger = silentLogger, detail = "summary") => {
-    const fullStatus = await runSessionStatus(logger);
-    if (detail === "full")
-        return fullStatus;
-    const parsedStatus = jsonObjectSchema.safeParse(fullStatus);
-    if (!parsedStatus.success || parsedStatus.data.error !== undefined)
-        return fullStatus;
-    const status = parsedStatus.data;
-    return {
-        open: status.open ?? false,
-        provider: status.provider ?? null,
-        providers: status.providers ?? [],
-        analysis_provider_binding: status.analysis_provider_binding ?? null,
-        analysis_provider_candidates: projectJsonObjectArray(status.analysis_provider_candidates, ["provider", "availability", "target_support", "selected"]),
-        server_identity: createServerIdentitySummary({
-            startedAt: new Date().toISOString(),
-        }),
-    };
-};
-/** List concise operation availability, with explicit full descriptor opt-in. */
-export const runCapabilityStatus = async (logger = silentLogger, detail = "summary") => {
-    const fullStatus = await runSessionStatus(logger);
-    if (detail === "full")
-        return fullStatus;
-    const parsedStatus = jsonObjectSchema.safeParse(fullStatus);
-    if (!parsedStatus.success || parsedStatus.data.error !== undefined)
-        return fullStatus;
-    const status = parsedStatus.data;
-    const capabilities = projectJsonObjectArray(status.capabilities, [
-        "operation",
-        "available",
-        "reason",
-    ]);
-    const available = capabilities.filter((candidate) => typeof candidate === "object" &&
-        candidate !== null &&
-        "available" in candidate &&
-        candidate.available === true).length;
-    return {
-        open: status.open ?? false,
-        summary: {
-            total: capabilities.length,
-            available,
-            unavailable: capabilities.length - available,
-        },
-        capabilities,
-        analysis_provider_binding: status.analysis_provider_binding ?? null,
-        server_identity: createServerIdentitySummary({
-            startedAt: new Date().toISOString(),
-        }),
-    };
-};
-const projectJsonObjectArray = (value, keys) => Array.isArray(value)
-    ? value.map((candidate) => {
-        const parsed = jsonObjectSchema.safeParse(candidate);
-        if (!parsed.success)
-            return candidate;
-        return Object.fromEntries(keys.flatMap((key) => parsed.data[key] === undefined ? [] : [[key, parsed.data[key]]]));
-    })
-    : [];
+/** List complete provider identities, capabilities, and availability. */
+export const runProviderStatus = (logger = silentLogger) => runSessionStatus(logger);
+/** List complete operation descriptors and availability. */
+export const runCapabilityStatus = (logger = silentLogger) => runSessionStatus(logger);

package/dist/application/Doctor.js

@@ -2,9 +2,8 @@ import { constants } from "node:fs";
 import { access, readFile, readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
+import { execFileOutput } from "../process/ExecFileOutput.js";
 import { probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
@@ -13,7 +12,6 @@ import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
 import { inspectRuntimeExecutables, } from "./RuntimeExecutableDiagnostics.js";
 import { collectDoctorDiagnostics, doctorHealthy, } from "./DoctorDiagnostics.js";
 import { normalizeDoctorScope, scopeDoctorChecks, } from "./DoctorScope.js";
-const execFileAsync = promisify(execFile);
 /** Deep provider IDs whose readiness can be selected explicitly by doctor. */
 export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra"];
 /**
@@ -56,14 +54,14 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
 };
 const collectDoctorIdentity = async (host, runtimeExecutables) => {
     const installationPaths = (await host.installationPaths?.()) ?? [];
-    const installedSkillIdentity = await readInstalledSkillIdentity(host);
+    const installedSkillIdentity = await host.installedSkillIdentity?.();
     const skillAligned = skillIdentityAligned(installedSkillIdentity);
     const registrations = (await host.clientRegistrations?.()) ?? [];
     return {
         checks: [
             ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
             ...registrations
-                .filter(({ state }) => state !== "aligned")
+                .filter((registration) => registration.state !== "aligned")
                 .map(registrationCheck),
         ],
         value: {
@@ -73,7 +71,7 @@ const collectDoctorIdentity = async (host, runtimeExecutables) => {
             catalog: CATALOG_IDENTITY,
             live_server: {
                 state: "unknown",
-                remediation: "Compare rea://server/identity or binary_session from the active client; an on-disk registration cannot prove the running server version.",
+                remediation: "Call binary_session in the active client to inspect the running server identity.",
             },
             installations: {
                 paths: installationPaths,
@@ -97,15 +95,6 @@ const collectDoctorIdentity = async (host, runtimeExecutables) => {
         },
     };
 };
-const readInstalledSkillIdentity = async (host) => {
-    const observed = await host.installedSkillIdentity?.();
-    if (observed !== undefined)
-        return observed;
-    const legacyVersion = await host.installedSkillVersion?.();
-    return legacyVersion === undefined
-        ? undefined
-        : { version: legacyVersion, toolCount: null, catalogDigest: null };
-};
 const skillIdentityAligned = (identity) => identity?.version === PRODUCT_IDENTITY.skillVersion &&
     identity.toolCount === CATALOG_IDENTITY.counts.mcp_tools &&
     identity.catalogDigest === CATALOG_IDENTITY.digests.combined_sha256;
@@ -123,8 +112,7 @@ const registrationCheck = (registration) => ({
     ok: false,
     classification: "config_drift",
     detail: registration.config_path,
-    remediation: registration.remediation ??
-        "Run rea setup, then restart the affected client.",
+    remediation: registration.remediation,
 });
 const installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
 /** Create diagnostics backed by the current process and host commands. */
@@ -149,7 +137,7 @@ export const systemDoctorHost = (options = {}) => ({
     async brewHopperPath() {
         return probeHomebrew(async (command) => {
             try {
-                const prefix = (await execFileAsync(command, [
+                const prefix = (await execFileOutput(command, [
                     "--prefix",
                     "--cask",
                     "hopper-disassembler",
@@ -171,7 +159,7 @@ export const systemDoctorHost = (options = {}) => ({
     async ilspyCmdVersion(path) {
         try {
             await access(path, constants.X_OK);
-            return firstIlspyVersionLine((await execFileAsync(path, ["--version"], { timeout: 10_000 })).stdout);
+            return firstIlspyVersionLine((await execFileOutput(path, ["--version"], { timeout: 10_000 })).stdout);
         }
         catch {
             return undefined;
@@ -189,19 +177,18 @@ export const systemDoctorHost = (options = {}) => ({
         try {
             const command = process.platform === "win32" ? "where" : "which";
             const arguments_ = process.platform === "win32" ? ["rea"] : ["-a", "rea"];
-            return uniqueLines((await execFileAsync(command, arguments_)).stdout);
+            return uniqueLines((await execFileOutput(command, arguments_)).stdout);
         }
         catch {
             return [];
         }
     },
-    installedSkillVersion,
     installedSkillIdentity,
     clientRegistrations: () => readClientRegistrationStatuses(homedir()),
 });
 const readMacosVersion = async () => {
     try {
-        return (await execFileAsync("sw_vers", ["-productVersion"])).stdout.trim();
+        return (await execFileOutput("sw_vers", ["-productVersion"])).stdout.trim();
     }
     catch {
         return undefined;
@@ -212,7 +199,7 @@ const executableAvailable = async (path) => {
         await access(path, constants.X_OK);
         if (process.platform !== "linux")
             return true;
-        const linked = await execFileAsync("ldd", [path]);
+        const linked = await execFileOutput("ldd", [path]);
         return linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`);
     }
     catch {
@@ -242,14 +229,6 @@ const manualHopperPaths = async () => {
     return paths;
 };
 const readInstalledSkill = () => readFile(join(homedir(), ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
-const installedSkillVersion = async () => {
-    try {
-        return /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(await readInstalledSkill())?.[1];
-    }
-    catch {
-        return undefined;
-    }
-};
 const installedSkillIdentity = async () => {
     try {
         const content = await readInstalledSkill();

package/dist/application/DoctorDiagnostics.js

@@ -70,9 +70,8 @@ const runtimeChecks = (inventory) => {
     const detail = broken.length === 0
         ? `${String(inventory.candidates.length)} runtime executable candidates passed bounded version probes.`
         : `${String(broken.length)} of ${String(inventory.candidates.length)} runtime executable candidates failed bounded version probes: ${broken
-            .slice(0, 5)
             .map(({ lexical_path: path }) => path)
-            .join(", ")}${broken.length > 5 ? ", …" : ""}`;
+            .join(", ")}`;
     return [
         check("node-toolchains", broken.length === 0, detail, {
             remediation: "Select a verified healthy Node toolchain or repair the failing installation, then rerun rea doctor. Do not create compatibility-library symlinks.",

package/dist/application/DoctorScope.js

@@ -88,7 +88,7 @@ const registrationCheck = (status) => ({
     ok: false,
     classification: "config_drift",
     detail: status.config_path,
-    remediation: status.remediation ?? "Run rea setup, then restart the affected client.",
+    remediation: status.remediation,
 });
 const selectedSkillCheck = (state, checks) => checks.find(({ name }) => name === "skill:identity") ?? {
     name: "skill:identity",

package/dist/application/ElectronActiveEvidence.js

@@ -1,9 +1,9 @@
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { digestJson } from "./JavaScriptReplayPlanning.js";
-/** Create Evidence v2 without retaining arbitrary runtime argument values. */
+/** Create Evidence without retaining arbitrary runtime argument values. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
-    predicateType: "rea.electron-active-scenario/v1",
+    predicateType: "rea.electron-active-scenario",
     operation: "capture_electron_scenario",
     parameters: parameters(input),
     result: jsonValueSchema.parse(result),
@@ -18,14 +18,11 @@ export const createElectronActiveEvidence = (input, result, provider) => createE
     limitations: result.limitations,
 });
 const scenarioProjection = (input) => ({
-    approved: input.approved,
-    schema_version: input.schema_version,
     executable_path: input.executable_path,
     application_path: input.application_path,
     application_root: input.application_root,
     args: redactArguments(input.args),
     actions: input.actions.map(({ step_id, kind }) => ({ step_id, kind })),
-    limits: input.limits,
 });
 const parameters = (input) => ({
     ...scenarioProjection(input),
@@ -49,7 +46,5 @@ const sensitiveFlag = /^--?(?:password|token|secret|api[-_]?key|authorization|co
 const redactArgument = (argument) => {
     if (/^--?(?:password|token|secret|api[-_]?key|authorization|cookie)=/iu.test(argument))
         return `${argument.slice(0, argument.indexOf("=") + 1)}<redacted>`;
-    return argument.length > 256
-        ? `${argument.slice(0, 256)}<redacted>`
-        : argument;
+    return argument;
 };

package/dist/application/ElectronActiveObservationService.js

@@ -1,6 +1,7 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { realpath } from "node:fs/promises";
 import { digestJson } from "./JavaScriptReplayPlanning.js";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/errors.js";
 import { isPathContained } from "../domain/permissionPolicy.js";
 import { err } from "../domain/result.js";
 import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
@@ -57,11 +58,7 @@ const authorize = async (authority, input) => {
         operation_identity: `${OPERATION}:${digestJson(canonical.value)}`,
     }, "write");
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     return canonical;
 };
 /** Authorize and execute one bounded, provider-owned Electron experiment. */

package/dist/application/ElectronBoundaryAnalysis.js

@@ -70,12 +70,13 @@ export const summarizeElectronBoundaries = (analysis) => {
         },
         sender_validation_observations: validations.length,
         utility_processes: utilities.length,
-        resolved_utility_entrypoints: utilities.filter(({ file, finding }) => resolvesToFile({
-            file,
-            specifier: finding.module_path,
-            context: finding.module_resolution_context ?? "module-specifier",
-            files,
-        })).length,
+        resolved_utility_entrypoints: utilities.filter(({ file, finding }) => finding.module_path !== null &&
+            resolvesToFile({
+                file,
+                specifier: finding.module_path,
+                context: finding.module_resolution_context,
+                files,
+            })).length,
         native_addon_bindings: nativeBindings.length,
         resolved_native_addon_bindings: nativeBindings.filter(({ file, finding }) => resolvesToFile({
             file,
@@ -97,8 +98,6 @@ const isPairableRendererTransmission = (record) => isRendererTransmission(record
 const isMainHandler = ({ finding }) => finding.side === "main" &&
     (finding.mode === "listen" || finding.mode === "handle");
 const resolvesToFile = (input) => {
-    if (input.specifier === null)
-        return false;
     const resolved = resolveArtifactPathByContext({
         declaredPath: input.specifier,
         sourcePath: input.file.path,

package/dist/application/ElectronBoundaryGraphContext.js

@@ -9,7 +9,7 @@ export const electronObservationIdentity = (context, scope, key) => ({
     strategy: "observation-fingerprint",
     stability: "observation-only",
     observation_sha256: sha256Text(`${context.snapshot.manifest.root_sha256}\0${scope}\0${key}`),
-    scope: scope.slice(0, 4_096),
+    scope,
 });
 /** Add a direct AST syntax relationship. */
 export const addElectronAstEdge = (context, input) => {

package/dist/application/ElectronBoundaryGraphIpc.js

@@ -96,7 +96,7 @@ const addHandlerNode = (input) => {
     const handlerRange = finding.handler_location ?? finding.location;
     const handler = context.accumulator.addNode({
         kind: "ipc-handler",
-        identity: artifactLocalIdentity(file.sha256, "electron-ipc-handler", `${finding.side}:${finding.operation}:${finding.channel ?? finding.channel_expression ?? "[missing]"}:${electronRangeKey(handlerRange)}`),
+        identity: artifactLocalIdentity(file.sha256, "electron-ipc-handler", `${finding.side}:${finding.operation}:${finding.channel ?? finding.channel_expression}:${electronRangeKey(handlerRange)}`),
         observations: [
             {
                 label: finding.channel,
@@ -177,7 +177,7 @@ const addValidationObservations = (state) => {
         const { file, javascript } = analyzed;
         if (javascript === null)
             continue;
-        const coverage = javascriptAnalysisCoverage(javascript, state.context.input);
+        const coverage = javascriptAnalysisCoverage(javascript);
         for (const validation of javascript.electron.sender_validations) {
             const handlerRecord = containingHandler(state.records, file, validation);
             const target = handlerRecord === undefined
@@ -238,5 +238,5 @@ const coverageFor = (context, file) => {
     const javascript = context.analysis.files.find(({ file: candidate }) => candidate.path === file.path)?.javascript;
     return javascript === null || javascript === undefined
         ? undefined
-        : javascriptAnalysisCoverage(javascript, context.input);
+        : javascriptAnalysisCoverage(javascript);
 };

package/dist/application/ElectronBoundaryGraphNative.js

@@ -7,7 +7,7 @@ export const addElectronNativeBoundaries = (context) => {
         const { file, javascript } = analyzed;
         if (javascript === null)
             continue;
-        const coverage = javascriptAnalysisCoverage(javascript, context.input);
+        const coverage = javascriptAnalysisCoverage(javascript);
         for (const value of javascript.electron.native_addon_bindings)
             addNativeBinding({ context, file, value, coverage });
     }
@@ -29,7 +29,6 @@ const addNativeBinding = (input) => {
                     specifier: value.specifier,
                     binding_kind: value.binding_kind,
                     requested_members: value.members,
-                    members_truncated: value.members_truncated,
                     resolved_path: resolved,
                     native_export_verification: "not-performed",
                 },

package/dist/application/ElectronBoundaryGraphWindows.js

@@ -8,7 +8,7 @@ export const addElectronWindowBoundaries = (context) => {
         const { file, javascript } = analyzed;
         if (javascript === null)
             continue;
-        const coverage = javascriptAnalysisCoverage(javascript, context.input);
+        const coverage = javascriptAnalysisCoverage(javascript);
         for (const value of javascript.electron.browser_windows) {
             const source = electronFindingSourceNode(context, file, value.module_key);
             if (source !== undefined)
@@ -39,7 +39,6 @@ const addBrowserWindow = (input) => {
                     options_status: value.options_status,
                     web_preferences_status: value.web_preferences_status,
                     web_preferences: value.web_preferences,
-                    omitted_web_preferences: value.omitted_web_preferences,
                     preload_path: value.preload_path,
                     preload_resolution_context: value.preload_resolution_context,
                     absence_means_default: false,
@@ -70,13 +69,13 @@ const addBrowserWindow = (input) => {
     addWindowPreload(input, window);
 };
 const addWindowPreload = (input, window) => {
-    const declared = input.value.preload_path;
-    if (declared === null)
+    if (input.value.preload_path === null)
         return;
+    const { preload_path: declared, preload_resolution_context: resolutionContext, } = input.value;
     const resolution = resolveArtifactPathByContext({
         declaredPath: declared,
         sourcePath: input.file.path,
-        context: input.value.preload_resolution_context ?? "module-specifier",
+        context: resolutionContext,
         files: input.context.filesByPath,
     });
     const role = createElectronRoleNode(input.context, {
@@ -127,7 +126,6 @@ const addContextBridge = (input) => {
                     api_status: value.api_status,
                     members: value.members,
                     unknown_members: value.unknown_members,
-                    omitted_members: value.omitted_members,
                 },
                 evidence: astObservationEvidence({
                     sha256: file.sha256,
@@ -158,7 +156,7 @@ const addUtilityProcess = (input) => {
     const { context, file, value, coverage } = input;
     const utility = context.accumulator.addNode({
         kind: "electron-utility",
-        identity: artifactLocalIdentity(file.sha256, "electron-utility-process", `${value.module_path ?? value.module_expression ?? "[missing]"}:${electronRangeKey(value.location)}`),
+        identity: artifactLocalIdentity(file.sha256, "electron-utility-process", `${value.module_path ?? value.module_expression}:${electronRangeKey(value.location)}`),
         observations: [
             {
                 label: value.service_name ?? value.module_path,
@@ -196,7 +194,7 @@ const addUtilityProcess = (input) => {
     const resolution = resolveArtifactPathByContext({
         declaredPath: value.module_path,
         sourcePath: file.path,
-        context: value.module_resolution_context ?? "module-specifier",
+        context: value.module_resolution_context,
         files: context.filesByPath,
     });
     const resolved = resolution.resolved_path;

package/dist/application/ElectronEvidence.js

@@ -1,10 +1,10 @@
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-/** Create Evidence v2 for one root-confined Electron observation. */
+/** Create Evidence for one Electron observation. */
 export const createElectronEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: operation === "list_electron_targets"
-        ? "rea.electron-target-list/v1"
-        : "rea.electron-page-inspection/v1",
+        ? "rea.electron-target-list"
+        : "rea.electron-page-inspection",
     operation,
     parameters: parameters(input),
     result: jsonValueSchema.parse(result),
@@ -22,14 +22,11 @@ export const createElectronEvidence = (operation, input, result, provider) => cr
 });
 const parameters = (input) => ({
     cdp_endpoint: input.cdp_endpoint,
-    allowed_file_roots: input.allowed_file_roots,
     ...("target_id" in input
         ? {
             target_id: input.target_id,
             observation_ms: input.observation_ms,
             include_script_sources: input.include_script_sources,
-            source_capture_approved: input.source_capture_approved,
-            limits: input.limits,
         }
-        : { offset: input.offset, limit: input.limit }),
+        : {}),
 });