rea-agents 2.4.0 → 3.0.0

package/dist/contracts/browserScenarioToolContracts.js

@@ -0,0 +1,81 @@
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { browserScenarioSchema } from "../domain/browserScenario.js";
+import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
+const example = {
+    schema_version: 1,
+    browser: {
+        mode: "launch",
+        executable_path: "/opt/chromium/chrome",
+        headless: true,
+        user_data: "temporary-owned",
+        cleanup: "close-and-delete-profile",
+    },
+    start_url: { url: "https://app.example.test/", query: [] },
+    allowed_origins: ["https://app.example.test"],
+    environment: {
+        viewport: { width: 1_280, height: 720, device_scale_factor: 1 },
+        locale: "en-US",
+        timezone: "UTC",
+        color_scheme: "light",
+        reduced_motion: "reduce",
+        service_workers: "block",
+    },
+    actions: [
+        {
+            step_id: "ready",
+            action: "wait_for",
+            locator: { kind: "test_id", value: "application-ready" },
+            state: "visible",
+        },
+    ],
+    storage: { cookies: [], local_storage: [], session_storage: [] },
+    request_replay: { mode: "disabled" },
+    secrets: [],
+    redaction: {
+        secret_values: "replace-with-secret-reference",
+        query_parameter_names: [],
+        header_names: [
+            "authorization",
+            "cookie",
+            "proxy-authorization",
+            "set-cookie",
+        ],
+    },
+    capture: {
+        after_each_step: ["screenshot", "url", "accessibility"],
+        at_end: ["dom", "history", "storage"],
+        events: ["console", "page-errors", "network", "websockets"],
+    },
+    limits: {
+        max_duration_ms: 60_000,
+        action_timeout_ms: 5_000,
+        navigation_timeout_ms: 10_000,
+        max_events: 2_000,
+        max_frames: 100,
+        max_workers: 20,
+        max_popups: 10,
+        max_websockets: 100,
+        max_dom_nodes: 10_000,
+        max_accessibility_nodes: 10_000,
+        max_screenshots: 16,
+        max_screenshot_bytes: 4_194_304,
+        max_storage_entries: 256,
+        max_total_metadata_bytes: 4_194_304,
+    },
+    approved: true,
+};
+/** Controlled browser scenario contract shared by MCP and catalog generation. */
+export const BROWSER_SCENARIO_TOOL_CONTRACTS = [
+    {
+        name: "capture_browser_scenario",
+        ...toolContractMetadata("capture_browser_scenario"),
+        description: "Run one approved, bounded browser scenario through Playwright. Launch mode owns and terminates a temporary browser profile; connect mode attaches to one exact loopback CDP target and disconnects without terminating the external browser. Only the fixed action vocabulary is accepted. Navigation, storage, requests, redirects, secrets, redaction, captures, and limits must be declared before execution. Returns step-indexed Evidence with screenshots, DOM, accessibility, URL/history/storage state, runtime events, explicit missing/truncated sections, and equality eligibility.",
+        kind: "browser-provider",
+        inputSchema: browserScenarioSchema,
+        outputSchema: evidenceResultOf(browserScenarioCaptureSchema),
+        examples: [
+            { title: "Capture a deterministic browser scenario", input: example },
+        ],
+    },
+];

package/dist/contracts/browserToolContracts.js

@@ -2,7 +2,7 @@ import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsI
 import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { compareWebCapturesInputSchema, webCaptureDiffSchema, } from "../domain/webCaptureDiff.js";
+import { browserCaptureComparisonWireSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
@@ -12,11 +12,81 @@ const inspectionOutputSchema = evidenceResult(webPageInspectionSchema);
 const bundleOutputSchema = evidenceResult(webBundleAnalysisSchema);
 const observationSessionOutputSchema = evidenceResult(webObservationSessionSchema);
 const webMcpOutputSchema = evidenceResult(webMcpDiscoverySchema);
-const captureDiffOutputSchema = evidenceResult(webCaptureDiffSchema);
+const captureDiffOutputSchema = evidenceResult(browserCaptureComparisonSchema);
 const screenshotOutputSchema = evidenceResult(webScreenshotSchema);
 const screenshotDiffOutputSchema = evidenceResult(webScreenshotDiffSchema);
 const endpoint = "http://127.0.0.1:9222";
 const origin = "https://app.example.test";
+const scenarioUrl = {
+    url: `${origin}/`,
+    origin,
+    query_parameter_names: [],
+    redacted: false,
+};
+const scenarioCompleteness = {
+    status: "complete",
+    equality_eligible: true,
+    missing_sections: [],
+    truncated_sections: [],
+};
+const scenarioArtifacts = {
+    screenshot: { state: "not_requested" },
+    dom: { state: "not_requested" },
+    accessibility: { state: "not_requested" },
+    url: { state: "not_requested" },
+    history: { state: "not_requested" },
+    storage: { state: "not_requested" },
+};
+const exampleScenarioCapture = () => ({
+    schema_version: 1,
+    browser: {
+        mode: "connect",
+        process_ownership: "external",
+        cleanup: "disconnected-external",
+        product: "Chromium",
+        version: "149",
+    },
+    scenario: {
+        start_origin: origin,
+        allowed_origins: [origin],
+        action_count: 1,
+        secret_references: [],
+    },
+    duration_ms: 10,
+    steps: [
+        {
+            step_index: 0,
+            step_id: "scenario_start",
+            action: "scenario_start",
+            status: "completed",
+            elapsed_ms: 0,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+        {
+            step_index: 1,
+            step_id: "open-settings",
+            action: "click",
+            status: "completed",
+            elapsed_ms: 10,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+    ],
+    events: { retained: 0, dropped: 0, items: [] },
+    completeness: scenarioCompleteness,
+    limitations: [],
+});
 /** Origin-scoped, passive browser reverse-engineering contracts. */
 export const BROWSER_TOOL_CONTRACTS = [
     {
@@ -64,6 +134,7 @@ export const BROWSER_TOOL_CONTRACTS = [
                     websocket_shape_approved: false,
                     include_script_sources: false,
                     include_storage_keys: false,
+                    include_storage_fingerprints: false,
                     limits: {
                         max_frames: 200,
                         max_dom_nodes: 2_000,
@@ -175,16 +246,26 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare two normalized web captures across DOM, scripts, resources, network, safe metadata, and optional WebMCP inventories. Stable observed changes are distinguished from unknown absence caused by incomplete capture coverage.",
+        description: "Compare either passive web captures or step-indexed browser scenarios. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and exposes bounded artifact-level changes plus alignment failures. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
-        inputSchema: compareWebCapturesInputSchema,
+        inputSchema: browserCaptureComparisonWireSchema,
         outputSchema: captureDiffOutputSchema,
         examples: [
             {
-                title: "Compare two normalized captures",
+                title: "Compare two recorded browser scenarios",
                 input: {
-                    before: { inspection: exampleInspection() },
-                    after: { inspection: exampleInspection() },
+                    before_scenario: exampleScenarioCapture(),
+                    after_scenario: exampleScenarioCapture(),
+                    normalization: {
+                        rules: [
+                            {
+                                rule_id: "volatile-build-id",
+                                artifacts: ["dom", "accessibility"],
+                                match: "build-123",
+                                replacement: "[BUILD_ID]",
+                            },
+                        ],
+                    },
                     max_changes: 2_000,
                 },
             },
@@ -231,97 +312,6 @@ export const BROWSER_TOOL_CONTRACTS = [
         ],
     },
 ];
-function exampleCompleteness() {
-    return {
-        status: "complete_within_window",
-        conditions: ["complete_within_window"],
-        policy_filtered_sections: [],
-        attach_limited_sections: [],
-        truncated_sections: [],
-        unavailable_sections: [],
-        excluded: [],
-        dropped_events: {
-            scripts: 0,
-            network_requests: 0,
-            console_events: 0,
-            websocket_connections: 0,
-            websocket_frames: 0,
-            webmcp_tools: 0,
-            timeline_events: 0,
-            total: 0,
-        },
-    };
-}
-function exampleInspection() {
-    return {
-        schema_version: 2,
-        browser: {
-            product: "Chrome/1",
-            protocol_version: "1.3",
-            revision: "example",
-            user_agent: "Chrome",
-            js_version: "1",
-        },
-        target: {
-            target_id: "page-1",
-            type: "page",
-            title: "Example",
-            url: `${origin}/`,
-            origin,
-            attached: false,
-        },
-        capture_window: {
-            started_at: "2026-07-14T00:00:00.000Z",
-            ended_at: "2026-07-14T00:00:01.000Z",
-            observation_ms: 1_000,
-        },
-        completeness: exampleCompleteness(),
-        frames: [],
-        dom: { total_nodes: 0, nodes: [] },
-        accessibility: {
-            total_nodes: 0,
-            text_capture: {
-                status: "not_approved",
-                retained_bytes: 0,
-                excluded_fields: 0,
-                truncated_fields: 0,
-            },
-            nodes: [],
-        },
-        scripts: { total: 0, items: [] },
-        resources: [],
-        network: {
-            requests: [],
-            websocket_events: [],
-            coverage_started_at: "2026-07-14T00:00:00.000Z",
-            prior_activity_available: false,
-        },
-        console: {
-            events: [],
-            coverage_started_at: "2026-07-14T00:00:00.000Z",
-            prior_activity_available: false,
-        },
-        workers: [],
-        metadata: {
-            responses: [],
-            dom_urls: [],
-            agent_hints: [],
-            excluded_dom_urls: 0,
-            headers_allowlisted: true,
-        },
-        storage: {
-            origin,
-            usage_bytes: null,
-            quota_bytes: null,
-            local_storage_keys: [],
-            session_storage_keys: [],
-            indexed_db_names: [],
-            cache_names: [],
-            values_redacted: true,
-        },
-        limitations: [],
-    };
-}
 function exampleScreenshot() {
     return {
         uri: "rea://web-screenshot/sha256/153cf6c9a526a63053a37b10234c2fd85df38887c2dc0a800d90abfa6631d01c",

package/dist/contracts/enhancedInputs.js

@@ -1,4 +1,14 @@
 import { z } from "zod";
+const traceLiteralInputSchema = z.object({
+    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("") }),
@@ -51,18 +61,34 @@ export const enhancedInputSchemas = {
             basic_blocks: 0,
         }),
     }),
-    trace_feature: z.object({
-        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),
+    inspect_native_api: z.object({
+        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({
+        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"),
     }),
 };
-/** Runtime parser for dispatching only the eight closed enhanced names. */
+/** Runtime parser for dispatching only the closed enhanced names. */
 export const enhancedToolNameSchema = z.enum([
     "swift_classes",
     "get_objc_classes",
@@ -73,5 +99,8 @@ export const enhancedToolNameSchema = z.enum([
     "find_xrefs_to_name",
     "binary_overview",
     "analyze_function",
+    "inspect_native_api",
     "trace_feature",
+    "find_code_for_string",
+    "trace_call_path",
 ]);

package/dist/contracts/functionInstructionContract.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/** Provider-neutral input for one bounded raw function-instruction window. */
+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

@@ -0,0 +1,30 @@
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { enhancedInputSchemas } from "./enhancedInputs.js";
+import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemas.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}`);
+    return {
+        name,
+        ...toolContractMetadata(name),
+        description,
+        kind: "enhanced",
+        inputSchema,
+        outputSchema,
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: jsonObjectSchema.parse(inputSchema.parse(TOOL_EXAMPLE_OVERRIDES[name] ?? {})),
+            },
+        ],
+    };
+};
+/** 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."),
+];

package/dist/contracts/hopperMemoryContracts.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+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. */
+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.",
+        inputSchema: z.object({
+            address,
+            length: z.number().int().min(1).max(4_096).default(256),
+            document,
+        }),
+    },
+    {
+        name: "address_to_file_offset",
+        description: "Map one provider-normalized virtual address to its original nonnegative file offset. Unmapped addresses fail explicitly, and providers without an authoritative mapping API return typed capability unavailability.",
+        inputSchema: z.object({ address, document }),
+    },
+];

package/dist/contracts/javascriptApplicationWorkflowExamples.js

@@ -1,6 +1,7 @@
 import { createEvidence } from "../domain/evidence.js";
 import { reconcileJavaScriptRuntime } from "../domain/javascriptRuntimeReconciliation.js";
 import { JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE, JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE, } from "./javascriptRuntimeReconciliationExample.js";
+import { createHistoricalSourceGraph } from "../domain/referenceSourceGraph.js";
 const reconciliation = reconcileJavaScriptRuntime(JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE);
 const reconciliationEvidence = createEvidence(undefined, {
     id: "rea-javascript-runtime-reconciliation",
@@ -47,6 +48,47 @@ export const JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE = {
     left_evidence_id: EXAMPLE_EVIDENCE_ID,
     right_evidence_id: SECOND_EXAMPLE_EVIDENCE_ID,
 };
+/** Historical source inventory compared with one producer-returned graph ID. */
+export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
+    reference: createHistoricalSourceGraph({
+        schema: "HistoricalSourceGraph/v1",
+        authority: "historical-reference",
+        root_alias: "$REFERENCE_ROOT",
+        inventory_state: "complete",
+        entries: [
+            {
+                path: "src",
+                kind: "directory",
+                classifications: ["source"],
+                tree_state: "enumerated",
+                limitations: [],
+            },
+            {
+                path: "src/main.ts",
+                kind: "file",
+                sha256: "2".repeat(64),
+                size: 128,
+                language: "TypeScript",
+                classifications: ["source"],
+                content_state: "hashed",
+                limitations: [],
+            },
+        ],
+        relationships: [],
+        parse_failures: [],
+        exclusions: [],
+        languages: ["TypeScript"],
+        manifests: [],
+        vcs: { kind: "none", head: null, dirty: null },
+        provenance: {
+            importer: "rea",
+            importer_version: "1",
+            caller: "contract-example",
+        },
+        limitations: [],
+    }),
+    application_evidence_id: EXAMPLE_EVIDENCE_ID,
+};
 /** Exact static return-shape comparison using producer-returned Evidence IDs. */
 export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
     left_evidence_id: EXAMPLE_EVIDENCE_ID,

package/dist/contracts/javascriptRuntimeObservationToolContracts.js

@@ -0,0 +1,58 @@
+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.",
+        kind: "runtime-provider",
+        inputSchema: listJavaScriptRuntimeTargetsInputSchema,
+        outputSchema: evidenceResultOf(javascriptRuntimeTargetListSchema),
+        examples: [
+            {
+                title: "List approved Node Inspector targets",
+                input: {
+                    inspector_endpoint: endpoint,
+                    allowed_file_roots: [root],
+                    allowed_origins: [],
+                    approved: true,
+                    offset: 0,
+                    limit: 100,
+                },
+            },
+        ],
+    },
+    {
+        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.",
+        kind: "runtime-provider",
+        inputSchema: observeJavaScriptRuntimeInputSchema,
+        outputSchema: evidenceResultOf(javascriptRuntimeObservationSchema),
+        examples: [
+            {
+                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,
+                    },
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/promptContracts.js

@@ -1,4 +1,3 @@
-import { TOOL_CONTRACTS } from "./toolContracts.js";
 const optional = (description, completion) => ({
     description,
     required: false,
@@ -81,8 +80,8 @@ export const PROMPT_CONTRACTS = [
                 instruction: "Build function dossiers and corroborate references and call relationships. Keep indirect or truncated paths unknown.",
             },
             {
-                tools: ["export_evidence_bundle", "record_unknown"],
-                instruction: "Cite retained Evidence IDs. Record residual unknowns only after separate explicit approval for registry mutation.",
+                tools: ["snapshot_evidence_bundle", "record_unknown"],
+                instruction: "Snapshot the canonical bundle, copy its opaque URI unchanged, and read that resource before citing retained Evidence IDs. Record residual unknowns only after separate explicit approval for registry mutation.",
             },
         ],
     },
@@ -100,8 +99,8 @@ export const PROMPT_CONTRACTS = [
         },
         steps: [
             {
-                tools: ["inventory_artifact"],
-                instruction: "Inventory each target independently before extraction. Follow nodes, occurrences, and edges to completion and retain every Evidence page for each manifest.",
+                tools: ["open_binary", "inventory_artifact"],
+                instruction: "For each supplied target path, open that target before inventory because inventory_artifact uses the active target and accepts no path. Follow nodes, occurrences, and edges to completion and retain every Evidence page for each manifest.",
             },
             {
                 tools: [
@@ -112,8 +111,8 @@ export const PROMPT_CONTRACTS = [
                 instruction: "For JavaScript/Electron versions, reconstruct each approved artifact independently, optionally reconcile separately retained passive runtime Evidence, then compare authenticated graphs with unique-only identity tiers. Keep ambiguous and incomplete matches unknown.",
             },
             {
-                tools: ["export_evidence_bundle", "compare_artifacts"],
-                instruction: "Resolve any supplied manifest IDs to retained inventory Evidence, validate graph commitments, then compare the complete left and right Evidence page sets.",
+                tools: ["snapshot_evidence_bundle", "compare_artifacts"],
+                instruction: "Snapshot and read the canonical bundle through its exact resource URI, resolve any supplied manifest IDs to retained inventory Evidence, validate graph commitments, then compare the complete left and right Evidence page sets.",
             },
             {
                 tools: ["open_binary", "analyze_function", "compare_functions"],
@@ -141,8 +140,8 @@ export const PROMPT_CONTRACTS = [
         },
         steps: [
             {
-                tools: ["export_evidence_bundle"],
-                instruction: "Load the current canonical bundle and verify that every selected comparison Evidence ID is present and compatible with the intended claim.",
+                tools: ["snapshot_evidence_bundle"],
+                instruction: "Snapshot the current canonical bundle, copy its opaque URI unchanged, read the resource, and verify that every selected comparison Evidence ID is present and compatible with the intended claim.",
             },
             {
                 tools: [
@@ -194,11 +193,11 @@ export const PROMPT_CONTRACTS = [
             },
             {
                 tools: [
-                    "export_evidence_bundle",
+                    "snapshot_evidence_bundle",
                     "capture_process_scenario",
                     "correlate_static_and_runtime",
                 ],
-                instruction: "Reuse a retained capture when supplied. Otherwise capture only after operator policy and per-call approval, then correlate through explicit hypotheses rather than timing or name coincidence.",
+                instruction: "Snapshot and read retained Evidence through the exact resource URI. Reuse a retained capture when supplied. Otherwise capture only after operator policy and per-call approval, then correlate through explicit hypotheses rather than timing or name coincidence.",
             },
             {
                 tools: ["record_unknown"],
@@ -222,8 +221,8 @@ export const PROMPT_CONTRACTS = [
                 instruction: "List current heads first and select only active, session-owned unknown IDs. Preserve their exact revision and requirements.",
             },
             {
-                tools: ["export_evidence_bundle", "verify_unknown_resolution"],
-                instruction: "Inspect cited supporting, contradicting, and mutation Evidence, then validate any resolved head against bundle integrity and authority requirements.",
+                tools: ["snapshot_evidence_bundle", "verify_unknown_resolution"],
+                instruction: "Snapshot and read the canonical bundle through its exact resource URI, inspect cited supporting, contradicting, and mutation Evidence, then validate any resolved head against bundle integrity and authority requirements.",
             },
             {
                 tools: ["update_unknown"],
@@ -252,8 +251,8 @@ export const PROMPT_CONTRACTS = [
                 instruction: "Inspect capture capability, declared effects, and limits before proposing execution. An unavailable capability is not permission to widen policy.",
             },
             {
-                tools: ["export_evidence_bundle"],
-                instruction: "Review any prior capture for unanswered dimensions, truncation, scenario commitments, and descendant settlement before designing a repeat.",
+                tools: ["snapshot_evidence_bundle"],
+                instruction: "Snapshot and read the canonical bundle through its exact resource URI, then review any prior capture for unanswered dimensions, truncation, scenario commitments, and descendant settlement before designing a repeat.",
             },
             {
                 tools: ["capture_process_scenario"],