rea-agents 3.0.0 → 3.2.0

package/dist/contracts/electronToolContracts.js

@@ -1,89 +1,28 @@
-import { z } from "zod";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
 import { electronPageInspectionSchema, electronTargetListSchema, inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
-import { analyzeJavaScriptApplicationInputSchema, javaScriptApplicationAnalysisResultV1Schema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "../domain/javascriptApplicationGraphSchemas.js";
-import { applicationCoverageSchema } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { electronActiveObservationInputSchema, electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
+import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
 import { javascriptRuntimeReconciliationResultSchema, reconcileJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeReconciliationSchemas.js";
 import { JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE } from "./javascriptRuntimeReconciliationExample.js";
 const listOutputSchema = evidenceResultOf(electronTargetListSchema);
 const inspectionOutputSchema = evidenceResultOf(electronPageInspectionSchema);
-/** MCP-only response selection; analysis identity does not depend on projection. */
-export const analyzeJavaScriptApplicationToolInputSchema = analyzeJavaScriptApplicationInputSchema.extend({
-    detail: z
-        .enum(["summary", "full"])
-        .default("summary")
-        .describe("summary returns bounded findings and paged graph resource URIs; full returns the complete graph only when explicitly required"),
-});
-/** Bounded default projection for agent-facing JavaScript application analysis. */
-const applicationGraphSummarySchema = z.strictObject({
-    graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
-    node_count: z.number().int().min(0),
-    edge_count: z.number().int().min(0),
-    roots: z.strictObject({
-        items: z.array(z.string().regex(/^jag_node_[a-f0-9]{64}$/u)),
-        total: z.number().int().min(0),
-        truncated: z.boolean(),
-    }),
-    node_kinds: z.array(z.strictObject({
-        kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
-        count: z.number().int().min(1),
-    })),
-    top_findings: z.array(z.strictObject({
-        node_id: z.string().regex(/^jag_node_[a-f0-9]{64}$/u),
-        kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
-        label: z.string().nullable(),
-        authority: z.string(),
-        state: z.string(),
-        confidence: z.string(),
-        location: z.json(),
-    })),
-    coverage: applicationCoverageSchema,
-    limitations: z.array(z.string()),
-    pages: z.strictObject({
-        nodes: z.string().startsWith("rea://evidence/"),
-        edges: z.string().startsWith("rea://evidence/"),
-        page_limit: z.number().int().min(1).max(500),
-    }),
-});
-const semanticGraphSummarySchema = z.strictObject({
-    graph_id: z.string().regex(/^jsrg_[a-f0-9]{64}$/u),
-    nodes: z.number().int().min(0),
-    relations: z.number().int().min(0),
-    unknown_frontiers: z.number().int().min(0),
-    fingerprints: z.number().int().min(0),
-    coverage: z.enum(["complete", "partial", "unknown", "unavailable"]),
-    query_tool: z.literal("trace_javascript_semantics"),
-});
-const summaryFields = {
-    unknowns: z.array(z.string().min(1).max(4_096)).max(1_000),
-    graph: applicationGraphSummarySchema,
-};
-/** Bounded default projection for agent-facing JavaScript application analysis. */
-export const javascriptApplicationAnalysisSummarySchema = z.discriminatedUnion("schema_version", [
-    javaScriptApplicationAnalysisResultV1Schema
-        .omit({ graph: true })
-        .extend(summaryFields),
-    javaScriptApplicationAnalysisResultV1Schema.omit({ graph: true }).extend({
-        schema_version: z.literal(2),
-        ...summaryFields,
-        semantic_graph: semanticGraphSummarySchema,
-    }),
-]);
-const applicationOutputSchema = evidenceResultOf(z.union([
-    javascriptApplicationAnalysisSummarySchema,
-    javascriptApplicationAnalysisResultSchema,
-]));
+const applicationOutputSchema = evidenceResultOf(javascriptApplicationAnalysisResultSchema);
 const reconciliationOutputSchema = evidenceResultOf(javascriptRuntimeReconciliationResultSchema);
 const endpoint = "http://127.0.0.1:9223";
-const root = "/Applications/Example.app/Contents/Resources";
+const activeExample = {
+    executable_path: "/Applications/Electron.app/Contents/MacOS/Electron",
+    application_path: "/Applications/Example.app/Contents/Resources/main.js",
+    application_root: "/Applications/Example.app/Contents/Resources",
+    args: [],
+    actions: [{ step_id: "exercise-ipc", kind: "click", selector: "#run" }],
+};
 /** Root-confined Electron file-page discovery and inspection contracts. */
 export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "list_electron_targets",
         ...toolContractMetadata("list_electron_targets"),
-        description: "List Electron file:// page targets from an approved user-owned loopback CDP endpoint. Every path is canonicalized and must remain contained by an approved filesystem root, including after symlink resolution.",
+        description: "List every Electron file:// page target from an approved user-owned loopback CDP endpoint. Every path is canonicalized and must remain contained by an approved filesystem root, including after symlink resolution.",
         kind: "electron-provider",
         inputSchema: listElectronTargetsInputSchema,
         outputSchema: listOutputSchema,
@@ -92,10 +31,6 @@ export const ELECTRON_TOOL_CONTRACTS = [
                 title: "List approved Electron file pages",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_file_roots: [root],
-                    approved: true,
-                    offset: 0,
-                    limit: 100,
                 },
             },
         ],
@@ -103,7 +38,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "inspect_electron_page",
         ...toolContractMetadata("inspect_electron_page"),
-        description: "Passively inspect one approved Electron file page through CDP. Returns root-confined frames, DOM structure, resource paths, and scripts without evaluating renderer JavaScript or invoking Electron APIs; script contents require separate approval.",
+        description: "Passively inspect one Electron file page by supplying its loopback CDP endpoint and target ID. The provider rechecks that the target currently exists at that endpoint and is a local file page. Returns frames, DOM structure, resource paths, and scripts without evaluating renderer JavaScript or invoking Electron APIs. The selected endpoint exposes every local file page and its metadata to this tool.",
         kind: "electron-provider",
         inputSchema: inspectElectronPageInputSchema,
         outputSchema: inspectionOutputSchema,
@@ -112,21 +47,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
                 title: "Inspect an approved Electron page",
                 input: {
                     cdp_endpoint: endpoint,
-                    allowed_file_roots: [root],
                     target_id: "TARGET_ID_FROM_LIST_ELECTRON_TARGETS",
-                    approved: true,
-                    observation_ms: 100,
-                    include_script_sources: false,
-                    source_capture_approved: false,
-                    limits: {
-                        max_frames: 200,
-                        max_dom_nodes: 2_000,
-                        max_scripts: 500,
-                        max_resources: 2_000,
-                        max_workers: 500,
-                        max_script_source_bytes: 1_048_576,
-                        max_total_script_source_bytes: 4_194_304,
-                    },
                 },
             },
         ],
@@ -134,19 +55,16 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "analyze_javascript_application",
         ...toolContractMetadata("analyze_javascript_application"),
-        description: "Statically reconstruct one approved local ASAR or extracted JavaScript application without executing it. The default summary returns architecture/security counts, top evidence-backed findings, unknowns, and paged graph resource URIs; request detail=full only when the complete graph must be returned immediately. Identical inputs are deterministic, so do not repeat the call or reread full Evidence without a specific missing detail.",
+        description: "Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns all recovered graph nodes, edges, semantic relations, limitations, and coverage.",
         kind: "electron-provider",
-        inputSchema: analyzeJavaScriptApplicationToolInputSchema,
+        inputSchema: analyzeJavaScriptApplicationInputSchema,
         outputSchema: applicationOutputSchema,
         examples: [
             {
-                title: "Analyze one approved local Electron application",
+                title: "Analyze one local JavaScript application",
                 input: {
                     input_path: "/Applications/Example.app/Contents/Resources/app.asar",
                     format: "auto",
-                    approved: true,
-                    source_map_read_approved: false,
-                    detail: "summary",
                 },
             },
         ],
@@ -154,7 +72,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "reconcile_javascript_runtime",
         ...toolContractMetadata("reconcile_javascript_runtime"),
-        description: "Reconcile verified static JavaScript application graphs with existing passive web or Electron CDP Evidence. Exact captured-source digests take priority over caller-declared file/URL mappings; target, frame, script, and worker ambiguity remains explicit, and source-map authority stays separate.",
+        description: "Reconcile verified static JavaScript application graphs with existing passive web/Electron CDP, passive V8 Inspector, or provider-owned active Electron Evidence. Active Electron captures contribute an explicitly partial target-only runtime record; they never invent renderer scripts, frames, workers, or execution claims. Exact captured-source digests take priority over caller-declared file/URL mappings; target, frame, script, and worker ambiguity remains explicit, and source-map authority stays separate.",
         kind: "electron-provider",
         inputSchema: reconcileJavaScriptRuntimeInputSchema,
         outputSchema: reconciliationOutputSchema,
@@ -165,4 +83,15 @@ export const ELECTRON_TOOL_CONTRACTS = [
             },
         ],
     },
+    {
+        name: "capture_electron_scenario",
+        ...toolContractMetadata("capture_electron_scenario"),
+        description: "Use this for an explicitly approved, provider-owned Electron run when passive CDP or Inspector observation cannot exercise application behavior. REA owns startup and teardown, accepts caller-defined click/wait actions plus window-targeted renderer reload/crash and synthetic open-url/second-instance delivery, and returns correlated window/WebContents/process/preload/session/navigation/shell/IPC evidence without retaining payload values. Results identify observed and unavailable event families, coverage status, action targets, and truncation. External shell, navigation, permission, download, popup, updater, and OS-integration effects are blocked and recorded. Use passive Electron tools for observation-only work.",
+        kind: "electron-provider",
+        inputSchema: electronActiveObservationInputSchema,
+        outputSchema: evidenceResultOf(electronActiveObservationResultSchema),
+        examples: [
+            { title: "Exercise an owned Electron application", input: activeExample },
+        ],
+    },
 ];

package/dist/contracts/enhancedInputs.js

@@ -1,106 +1,59 @@
 import { z } from "zod";
-const traceLiteralInputSchema = z.object({
+const traceLiteralInputSchema = z.strictObject({
     query: z.string().min(1),
     case_sensitive: z.boolean().default(false),
-    limit: z.number().int().min(1).max(100).default(20),
-    max_operations: z.number().int().min(1).max(100).default(20),
-    unknown_registry_approved: z
-        .literal(true)
-        .optional()
-        .describe("Explicit approval to record bounded residuals durably"),
 });
 /** Input schemas shared by MCP registration and enhanced application dispatch. */
 export const enhancedInputSchemas = {
-    swift_classes: z.object({ pattern: z.string().default("") }),
-    get_objc_classes: z.object({ pattern: z.string().default("") }),
-    get_objc_protocols: z.object({}),
-    batch_decompile: z.object({
+    inspect_native_dispatch_metadata: z.strictObject({
+        max_records: z.number().int().min(1).max(20_000).default(5_000),
+    }),
+    get_objc_classes: z.strictObject({ pattern: z.string().default("") }),
+    get_objc_protocols: z.strictObject({}),
+    batch_decompile: z.strictObject({
         addresses: z
             .array(z.string().describe("A provider-normalized procedure address"))
-            .max(20)
             .default([]),
     }),
-    get_call_graph: z.object({
+    get_call_graph: z.strictObject({
         address: z.string().describe("A provider-normalized procedure address"),
         direction: z.enum(["forward", "backward"]).default("forward"),
-        depth: z.number().int().min(1).max(5).default(2),
     }),
-    analyze_swift_types: z.object({}),
-    find_xrefs_to_name: z.object({ name: z.string() }),
-    binary_overview: z.object({
-        detail: z.enum(["concise", "detailed"]).default("concise"),
-        limit: z.number().int().min(1).max(50).default(10),
+    analyze_swift_types: z.strictObject({
+        category: z
+            .enum(["classes", "structs", "enums", "protocols", "extensions", "other"])
+            .optional()
+            .describe("Limit results to one Swift symbol category."),
+        pattern: z
+            .string()
+            .optional()
+            .describe("Case-sensitive literal filter applied to mangled symbol names."),
     }),
-    analyze_function: z.object({
+    find_xrefs_to_name: z.strictObject({ name: z.string() }),
+    binary_overview: z.strictObject({}),
+    analyze_function: z.strictObject({
         procedure: z.string().describe("A procedure name or address"),
-        include_assembly: z.boolean().default(false),
-        limit: z.number().int().min(1).max(500).default(100),
-        max_pseudocode_chars: z.number().int().min(1).max(100_000).default(20_000),
-        max_instructions: z.number().int().min(1).max(5_000).default(500),
-        pseudocode_offset: z.number().int().min(0).default(0),
-        assembly_offset: z.number().int().min(0).default(0),
-        collection_offset: z
-            .object({
-            comments: z.number().int().min(0).default(0),
-            callers: z.number().int().min(0).default(0),
-            callees: z.number().int().min(0).default(0),
-            incoming_references: z.number().int().min(0).default(0),
-            outgoing_references: z.number().int().min(0).default(0),
-            referenced_strings: z.number().int().min(0).default(0),
-            referenced_names: z.number().int().min(0).default(0),
-            basic_blocks: z.number().int().min(0).default(0),
-        })
-            .default({
-            comments: 0,
-            callers: 0,
-            callees: 0,
-            incoming_references: 0,
-            outgoing_references: 0,
-            referenced_strings: 0,
-            referenced_names: 0,
-            basic_blocks: 0,
-        }),
     }),
-    inspect_native_api: z.object({
+    inspect_native_api: z.strictObject({
         procedure: z.string().describe("A procedure name or address"),
-        max_pseudocode_chars: z.number().int().min(1).max(100_000).default(20_000),
-        max_instructions: z.number().int().min(1).max(5_000).default(500),
-        unknown_registry_approved: z
-            .literal(true)
-            .optional()
-            .describe("Explicit approval to record unsupported native API branches durably"),
     }),
     trace_feature: traceLiteralInputSchema,
     find_code_for_string: traceLiteralInputSchema,
-    trace_call_path: z.object({
+    trace_call_path: z.strictObject({
         start: z.string().describe("A provider-normalized procedure address"),
         goal: z
             .string()
             .describe("An optional provider-normalized destination address")
             .optional(),
         direction: z.enum(["forward", "backward"]).default("forward"),
-        max_depth: z.number().int().min(1).max(10).default(5),
-        max_nodes: z.number().int().min(1).max(500).default(100),
-        max_operations: z.number().int().min(1).max(500).default(100),
-        unknown_registry_approved: z
-            .literal(true)
-            .optional()
-            .describe("Explicit approval to record bounded residuals durably"),
+    }),
+    trace_native_ui_action: z.strictObject({
+        action: z
+            .string()
+            .min(1)
+            .describe("A unique compiled UI action selector or interface object ID"),
+        max_depth: z.number().int().min(0).max(32).default(8),
+        max_nodes: z.number().int().min(1).max(2_000).default(250),
+        max_edges: z.number().int().min(1).max(5_000).default(500),
     }),
 };
-/** Runtime parser for dispatching only the closed enhanced names. */
-export const enhancedToolNameSchema = z.enum([
-    "swift_classes",
-    "get_objc_classes",
-    "get_objc_protocols",
-    "batch_decompile",
-    "get_call_graph",
-    "analyze_swift_types",
-    "find_xrefs_to_name",
-    "binary_overview",
-    "analyze_function",
-    "inspect_native_api",
-    "trace_feature",
-    "find_code_for_string",
-    "trace_call_path",
-]);

package/dist/contracts/errorSchemas.js

@@ -91,7 +91,6 @@ export const analysisErrorProjectionSchema = z.discriminatedUnion("code", [
     generic("process_capture_failed"),
     generic("cleanup_incomplete"),
     generic("revision_conflict"),
-    generic("outside_approved_root"),
     generic("configuration_invalid"),
     generic("target_unavailable"),
     generic("execution_failure"),

package/dist/contracts/functionComparisonExample.js

@@ -1,13 +1,6 @@
 import { enhancedInputSchemas } from "./enhancedInputs.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-const bounded = (items) => ({
-    items,
-    total: items.length,
-    returned: items.length,
-    truncated: false,
-    next_offset: null,
-});
 const dossier = (text) => jsonValueSchema.parse({
     procedure: {
         address: "0x1000",
@@ -15,23 +8,16 @@ const dossier = (text) => jsonValueSchema.parse({
         signature: "int main(void)",
         locals: [],
     },
-    pseudocode: {
-        text,
-        total_chars: [...text].length,
-        returned_chars: [...text].length,
-        truncated: false,
-        next_offset: null,
-    },
-    assembly: bounded([]),
-    comments: bounded([]),
-    callers: bounded([]),
-    callees: bounded([]),
-    incoming_references: bounded([]),
-    outgoing_references: bounded([]),
-    referenced_strings: bounded([]),
-    referenced_names: bounded([]),
-    basic_blocks: bounded([{ start: "0x1000", end: "0x1001", successors: [] }]),
-    instruction_scan: { scanned: 1, truncated: false },
+    pseudocode: text,
+    assembly: [],
+    comments: [],
+    callers: [],
+    callees: [],
+    incoming_references: [],
+    outgoing_references: [],
+    referenced_strings: [],
+    referenced_names: [],
+    basic_blocks: [{ start: "0x1000", end: "0x1001", successors: [] }],
 });
 const observe = (digit, text) => createEvidence({
     path: `/tmp/function-${digit}`,

package/dist/contracts/functionInstructionContract.js

@@ -1,8 +1,6 @@
 import { z } from "zod";
-/** Provider-neutral input for one bounded raw function-instruction window. */
+/** Provider-neutral input for a function's complete raw instruction list. */
 export const functionInstructionInputSchema = z.object({
     procedure: z.string().describe("The procedure name or address"),
-    offset: z.number().int().min(0).max(100_000).default(0),
-    limit: z.number().int().min(1).max(500).default(64),
     document: z.string().optional().describe("The document name"),
 });

package/dist/contracts/functionWorkflowToolContracts.js

@@ -3,11 +3,10 @@ import { enhancedInputSchemas } from "./enhancedInputs.js";
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { enhancedOutputSchemas } from "./toolOutputSchemas.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 const functionWorkflow = (name, description) => {
     const inputSchema = enhancedInputSchemas[name];
-    const outputSchema = enhancedOutputSchemas[name];
-    if (outputSchema === undefined)
-        throw new Error(`Missing function workflow output schema for ${name}`);
+    const outputSchema = requireOutputSchema(enhancedOutputSchemas, name);
     return {
         name,
         ...toolContractMetadata(name),
@@ -25,6 +24,6 @@ const functionWorkflow = (name, description) => {
 };
 /** Function dossier and native API reconstruction workflow contracts. */
 export const FUNCTION_WORKFLOW_TOOL_CONTRACTS = [
-    functionWorkflow("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, provider-specific pseudocode, optional assembly, comments, calls, typed-or-explicitly-unavailable references, referenced strings/names, and local CFG blocks with exact truncation metadata. Providers with a structured decompiler model also expose native API boundary types, confidence, evidence, jump-table data/target addresses, and explicit decompiler-artifact labels."),
-    functionWorkflow("inspect_native_api", "Reconstruct one native function boundary through inspectable substeps. Returns structured inferred return/parameter types with confidence and evidence, jump-table dispatch/data/target mappings, explicit decompiler-artifact labels, unsupported branches, and residual unknowns."),
+    functionWorkflow("analyze_function", "Build a dossier for one native function identified by symbol or provider-returned address. Returns identity, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations."),
+    functionWorkflow("inspect_native_api", "Analyze a native API boundary in one function identified by symbol or provider-returned address. Returns confidence, evidence, jump-table dispatch/data/target mappings, unsupported branches, and residual unknowns."),
 ];

package/dist/contracts/hopperMemoryContracts.js

@@ -3,14 +3,14 @@ const document = z.string().optional().describe("The document name");
 const address = z
     .string()
     .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");
-/** Bounded Hopper memory and file-mapping contracts. */
+/** Hopper memory and file-mapping contracts. */
 export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
     {
         name: "read_bytes",
-        description: "Read at most 4,096 analyzed bytes from one provider-normalized virtual address. The hexadecimal payload reports the exact returned length; incomplete reads remain explicit and unsupported provider APIs return typed capability unavailability.",
+        description: "Read analyzed bytes from one provider-normalized virtual address. The hexadecimal payload reports the exact returned length; incomplete reads remain explicit and unsupported provider APIs return typed capability unavailability.",
         inputSchema: z.object({
             address,
-            length: z.number().int().min(1).max(4_096).default(256),
+            length: z.number().int().min(1).default(256),
             document,
         }),
     },

package/dist/contracts/investigationExamples.js

@@ -1,22 +1,20 @@
 import { compareFunctions } from "../domain/functionComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, processCaptureSchema, } from "../domain/processCapture.js";
+import { compareProcessCaptures, parseProcessCapture, } from "../domain/processCapture.js";
 import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
 import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./processCaptureExample.js";
-const comparison = compareFunctions(FUNCTION_COMPARISON_EXAMPLE.left, FUNCTION_COMPARISON_EXAMPLE.right, 0, 100);
+const comparison = compareFunctions(FUNCTION_COMPARISON_EXAMPLE.left, FUNCTION_COMPARISON_EXAMPLE.right);
 export const FUNCTION_COMPARISON_EVIDENCE = createEvidence(undefined, {
     id: "rea-function-comparison",
     name: "REA function comparison",
     version: "1",
 }, {
-    predicateType: "rea.function-comparison/v1",
+    predicateType: "rea.function-comparison",
     operation: "compare_functions",
     parameters: {
-        left_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.left.evidence_id],
-        right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],
-        offset: 0,
-        limit: 100,
+        left_evidence_id: FUNCTION_COMPARISON_EXAMPLE.left.evidence_id,
+        right_evidence_id: FUNCTION_COMPARISON_EXAMPLE.right.evidence_id,
     },
     result: jsonValueSchema.parse(comparison),
     confidence: "derived",
@@ -31,9 +29,9 @@ const PROCESS_PROVIDER = {
     name: "REA deterministic process harness",
     version: "3",
 };
-const capture = processCaptureSchema.parse(EMPTY_PROCESS_CAPTURE_EXAMPLE);
+const capture = parseProcessCapture(EMPTY_PROCESS_CAPTURE_EXAMPLE);
 const captureEvidence = (scenario) => createEvidence(undefined, PROCESS_PROVIDER, {
-    predicateType: "rea.process-capture/v4",
+    predicateType: "rea.process-capture",
     operation: "capture_process_scenario",
     parameters: { scenario },
     result: jsonValueSchema.parse(capture),
@@ -49,7 +47,7 @@ const captureEvidence = (scenario) => createEvidence(undefined, PROCESS_PROVIDER
 export const PROCESS_CAPTURE_REFERENCE = captureEvidence("reference");
 export const PROCESS_CAPTURE_RECONSTRUCTION = captureEvidence("reconstruction");
 export const PROCESS_COMPARISON_EVIDENCE = createEvidence(undefined, PROCESS_PROVIDER, {
-    predicateType: "rea.process-comparison/v3",
+    predicateType: "rea.process-comparison",
     operation: "compare_process_captures",
     parameters: {
         left_evidence_id: PROCESS_CAPTURE_REFERENCE.evidence_id,
@@ -67,6 +65,12 @@ export const PROCESS_COMPARISON_EVIDENCE = createEvidence(undefined, PROCESS_PRO
 });
 /** Canonical inputs for comparison-composed investigation contracts. */
 export const INVESTIGATION_EXAMPLES = {
+    compare_process_captures: {
+        input: {
+            left: PROCESS_CAPTURE_REFERENCE,
+            right: PROCESS_CAPTURE_RECONSTRUCTION,
+        },
+    },
     find_changed_behavior: { comparisons: [FUNCTION_COMPARISON_EVIDENCE] },
     build_call_path: {
         functions: [FUNCTION_COMPARISON_EXAMPLE.left],
@@ -96,7 +100,6 @@ export const INVESTIGATION_EXAMPLES = {
     },
     verify_reconstruction: {
         specification: {
-            schema_version: 1,
             name: "Terminal compatibility",
             claims: [
                 {

package/dist/contracts/javascriptApplicationWorkflowExamples.js

@@ -8,7 +8,7 @@ const reconciliationEvidence = createEvidence(undefined, {
     name: "REA JavaScript runtime reconciliation",
     version: "1",
 }, {
-    predicateType: "rea.javascript-runtime-reconciliation/v1",
+    predicateType: "rea.javascript-runtime-reconciliation",
     operation: "reconcile_javascript_runtime",
     parameters: {
         static_layers: JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers.map(({ role, analysis }) => ({
@@ -17,11 +17,6 @@ const reconciliationEvidence = createEvidence(undefined, {
             runtime_mappings: [],
         })),
         runtime_evidence_ids: JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.runtime_observations.map(({ evidence_id: id }) => id),
-        limits: {
-            max_runtime_entities: 10_000,
-            max_reconciliation_items: 20_000,
-            max_static_load_states: 20_000,
-        },
     },
     result: reconciliation,
     confidence: "inferred",
@@ -29,29 +24,27 @@ const reconciliationEvidence = createEvidence(undefined, {
     limitations: reconciliation.limitations,
     evidenceLinks: reconciliation.evidence_links,
 });
-const EXAMPLE_EVIDENCE_ID = `ev_${"0".repeat(64)}`;
-const SECOND_EXAMPLE_EVIDENCE_ID = `ev_${"1".repeat(64)}`;
 const TRACE_SEED = {
     kind: "module",
     value: "renderer.js",
     match: "exact",
     case_sensitive: false,
 };
-/** Natural trace request using the Evidence ID returned by its producer. */
+/** Natural trace request with the producer's complete Evidence inline. */
 export const JAVASCRIPT_FEATURE_TRACE_EXAMPLE = {
-    application_evidence_id: EXAMPLE_EVIDENCE_ID,
+    application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
     seed: TRACE_SEED,
     direction: "both",
 };
-/** Natural version comparison using two producer-returned Evidence IDs. */
+/** Natural version comparison with both Evidence records inline. */
 export const JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE = {
-    left_evidence_id: EXAMPLE_EVIDENCE_ID,
-    right_evidence_id: SECOND_EXAMPLE_EVIDENCE_ID,
+    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
+    right: reconciliationEvidence,
 };
-/** Historical source inventory compared with one producer-returned graph ID. */
+/** Historical source inventory compared with inline application Evidence. */
 export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
     reference: createHistoricalSourceGraph({
-        schema: "HistoricalSourceGraph/v1",
+        schema: "HistoricalSourceGraph",
         authority: "historical-reference",
         root_alias: "$REFERENCE_ROOT",
         inventory_state: "complete",
@@ -87,12 +80,12 @@ export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
         },
         limitations: [],
     }),
-    application_evidence_id: EXAMPLE_EVIDENCE_ID,
+    application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
 };
-/** Exact static return-shape comparison using producer-returned Evidence IDs. */
+/** Exact static return-shape comparison with both Evidence records inline. */
 export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
-    left_evidence_id: EXAMPLE_EVIDENCE_ID,
-    right_evidence_id: SECOND_EXAMPLE_EVIDENCE_ID,
+    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
+    right: reconciliationEvidence,
     left_module_path: "parser.mjs",
     left_export_name: "default",
     right_module_path: "parser.mjs",

package/dist/contracts/javascriptRuntimeObservationToolContracts.js

@@ -1,14 +1,13 @@
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeTargetListSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeObservation.js";
-const root = "/opt/example-app";
 const endpoint = "http://127.0.0.1:9229";
 /** Passive Node/Electron V8 Inspector discovery and observation contracts. */
 export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
     {
         name: "list_javascript_runtime_targets",
         ...toolContractMetadata("list_javascript_runtime_targets"),
-        description: "List attachable Node/Electron V8 Inspector targets from one approved literal-loopback endpoint. Only targets inside exact canonical file roots or exact HTTP(S) origins are retained; excluded target locations never enter Evidence.",
+        description: "List every attachable Node/Electron V8 Inspector target from an explicit literal-loopback endpoint. Every returned target and script location exposed by that Inspector endpoint is eligible for Evidence.",
         kind: "runtime-provider",
         inputSchema: listJavaScriptRuntimeTargetsInputSchema,
         outputSchema: evidenceResultOf(javascriptRuntimeTargetListSchema),
@@ -17,11 +16,6 @@ export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
                 title: "List approved Node Inspector targets",
                 input: {
                     inspector_endpoint: endpoint,
-                    allowed_file_roots: [root],
-                    allowed_origins: [],
-                    approved: true,
-                    offset: 0,
-                    limit: 100,
                 },
             },
         ],
@@ -29,7 +23,7 @@ export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
     {
         name: "observe_javascript_runtime",
         ...toolContractMetadata("observe_javascript_runtime"),
-        description: "Attach passively to one exact approved Node/Electron V8 Inspector target and capture bounded Debugger.scriptParsed plus Runtime execution-context events. REA sends only Runtime.enable and Debugger.enable: it never evaluates, pauses, resumes, reads source, or instruments the target. require/import edges, EventEmitter activity, and Electron IPC remain explicit unknowns; reconcile the returned Evidence with static Application Graph Evidence using reconcile_javascript_runtime.",
+        description: "Attach passively to one Node/Electron V8 Inspector target by supplying its loopback Inspector endpoint and target ID. The provider rechecks that the target currently exists at that endpoint and is an attachable file or URL target. Captures Debugger.scriptParsed and Runtime execution-context events. REA never evaluates, pauses, resumes, reads source, or instruments the target; require/import edges, EventEmitter activity, and Electron IPC remain explicit unknowns. Reconcile the result with static Application Graph Evidence using reconcile_javascript_runtime. The selected endpoint exposes every target it serves to this tool.",
         kind: "runtime-provider",
         inputSchema: observeJavaScriptRuntimeInputSchema,
         outputSchema: evidenceResultOf(javascriptRuntimeObservationSchema),
@@ -38,19 +32,7 @@ export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
                 title: "Observe one approved Node runtime",
                 input: {
                     inspector_endpoint: endpoint,
-                    allowed_file_roots: [root],
-                    allowed_origins: [],
                     target_id: "TARGET_ID_FROM_LIST_JAVASCRIPT_RUNTIME_TARGETS",
-                    runtime_kind: "node",
-                    approved: true,
-                    observation_ms: 100,
-                    limits: {
-                        max_events: 10_000,
-                        max_scripts: 2_000,
-                        max_execution_contexts: 1_000,
-                        max_location_bytes: 16_384,
-                        max_total_metadata_bytes: 4_194_304,
-                    },
                 },
             },
         ],