rea-agents 2.3.0 → 2.5.0

package/dist/contracts/reconstructionReadinessExample.js

@@ -0,0 +1,436 @@
+import { createEvidence } from "../domain/evidence.js";
+import { createEvidenceBundle } from "../domain/evidenceBundle.js";
+import { READINESS_REQUIRED_CHECKS, READINESS_STAGE_IDS, } from "../domain/reconstructionReadinessJourneyFindings.js";
+const HASH = "a".repeat(64);
+const sourceEvidence = (variant) => createEvidence(undefined, {
+    id: "rea-readiness-fixture",
+    name: "REA readiness fixture",
+    version: "1",
+}, {
+    predicateType: "rea.reconstruction-readiness-fixture/v1",
+    operation: "run_reconstruction_readiness_fixture",
+    parameters: { variant },
+    result: { passed: true, variant },
+    confidence: "observed",
+    authority: "controlled-replay",
+});
+const SOURCE = sourceEvidence("authority");
+const CONTRADICTING_SOURCE = sourceEvidence("contradiction");
+const EVIDENCE_ID = SOURCE.evidence_id;
+const CASES = [
+    "positive",
+    "negative",
+    "malformed",
+    "cancellation",
+    "teardown",
+];
+const FIXTURES = [
+    "native",
+    "javascript-cli",
+    "electron",
+    "incomplete-reconstruction",
+    "broken-runtime",
+];
+const STATUSES = [
+    "unowned",
+    "characterized",
+    "implemented",
+    "verified",
+    "contradicted",
+    "blocked",
+    "out-of-scope",
+    "unknown",
+];
+const LAYERS = [
+    "cli",
+    "protocol",
+    "electron",
+    "persistence",
+    "process",
+    "runtime",
+    "packaging",
+    "native-abi",
+    "application",
+    "other",
+];
+const EVIDENCE_STATES = [
+    "candidate",
+    "observed",
+    "reviewed",
+    "unknown",
+];
+/** Complete synthetic input shared by docs, tests, CLI, MCP, and verifier. */
+export const RECONSTRUCTION_READINESS_EXAMPLE = {
+    schema_version: 1,
+    identity: {
+        cli_version: "2.4.0",
+        server_version: "2.4.0",
+        catalog_digest: HASH,
+        skill_digest: HASH,
+        versions: [
+            {
+                component: "rea-cli",
+                version: "2.4.0",
+                digest: HASH,
+                state: "current",
+                remediation: null,
+            },
+            {
+                component: "rea-server",
+                version: "2.3.0",
+                digest: "b".repeat(64),
+                state: "stale",
+                remediation: "Restart the connected MCP server.",
+            },
+            {
+                component: "rea-server",
+                version: "2.4.0",
+                digest: HASH,
+                state: "current",
+                remediation: null,
+            },
+        ],
+        providers: [
+            {
+                provider_id: "javascript-application",
+                version: "1",
+                digest: HASH,
+                state: "available",
+                reason_code: null,
+            },
+            {
+                provider_id: "broken-runtime-probe",
+                version: null,
+                digest: null,
+                state: "broken-host",
+                reason_code: "host-runtime-linker-failure",
+            },
+        ],
+    },
+    client: {
+        name: "synthetic-mcp-client",
+        version: "1",
+        negotiated_capabilities: ["elicitation", "progress", "resources"],
+    },
+    capabilities: [
+        {
+            capability_id: "analyze-javascript-application",
+            available: true,
+            bounded: true,
+            side_effect: "reads-target",
+            authority_scopes: ["investigation-input"],
+            limits: [{ name: "max-ast-nodes", value: 2_000_000, unit: "count" }],
+            unavailable_reason: null,
+        },
+    ],
+    fixtures: FIXTURES.map((kind) => ({
+        fixture_id: `fixture.${kind}`,
+        kind,
+        artifact_sha256: HASH,
+        environment_id: "environment.synthetic",
+        deliberate_faults: [`fault.${kind}`],
+    })),
+    workflow_candidates: FIXTURES.map((kind) => ({
+        fixture_id: `fixture.${kind}`,
+        workflow_id: `workflow.${kind}`,
+        provider_id: kind === "broken-runtime" ? null : `provider.${kind}`,
+        selected: true,
+        invoked: true,
+        compatibility: "compatible",
+        reason_code: "compatible-artifact-family",
+    })),
+    grants: [
+        {
+            grant_id: "grant.denied",
+            scope: "process-capture",
+            decision: "denied",
+            launched_process: false,
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            grant_id: "grant.session",
+            scope: "process-capture",
+            decision: "granted",
+            launched_process: true,
+            evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    evidence_bundle: createEvidenceBundle([SOURCE, CONTRADICTING_SOURCE]),
+    comparisons: [
+        {
+            comparison_id: "comparison.concurrent",
+            verdict: "equivalent",
+            schedule_semantics: "partial-order",
+            concurrent: true,
+            truncated: false,
+            unavailable_authority: false,
+            unstable: false,
+            deliberate_divergence_ref: null,
+            divergence_refs: [],
+            contradiction_ids: [],
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            comparison_id: "comparison.divergence",
+            verdict: "different",
+            schedule_semantics: "finite-traces",
+            concurrent: true,
+            truncated: false,
+            unavailable_authority: false,
+            unstable: false,
+            deliberate_divergence_ref: "/events/primary",
+            divergence_refs: ["/events/primary"],
+            contradiction_ids: [],
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            comparison_id: "comparison.contradicted",
+            verdict: "unknown",
+            schedule_semantics: "finite-traces",
+            concurrent: false,
+            truncated: false,
+            unavailable_authority: false,
+            unstable: false,
+            deliberate_divergence_ref: null,
+            divergence_refs: [],
+            contradiction_ids: ["contradiction.artifact"],
+            evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    contradictions: [
+        {
+            contradiction_id: "contradiction.artifact",
+            declared_sha256: HASH,
+            observed_sha256: "b".repeat(64),
+            policy: "record-and-continue",
+            affected_comparison_ids: ["comparison.contradicted"],
+            evidence_ids: [EVIDENCE_ID, CONTRADICTING_SOURCE.evidence_id],
+        },
+    ],
+    obligation_ledger: {
+        schema: "ReconstructionObligationLedger",
+        schema_version: 1,
+        ledger_id: `rol_${HASH}`,
+        closure_digest: HASH,
+        status: "ready",
+        coverage: {
+            status: "complete",
+            truncated: false,
+            omitted_count: 0,
+            max_obligations: 100,
+        },
+        summary: {
+            total: 1,
+            required: 1,
+            verified: 1,
+            required_open: 0,
+            by_status: STATUSES.map((key) => ({
+                key,
+                count: key === "verified" ? 1 : 0,
+            })),
+            by_application_layer: LAYERS.map((key) => ({
+                key,
+                count: key === "process" ? 1 : 0,
+            })),
+            by_evidence_authority: EVIDENCE_STATES.map((key) => ({
+                key,
+                count: key === "observed" ? 1 : 0,
+            })),
+        },
+        reports: {
+            missing_owner_obligation_ids: [],
+            missing_verifier_obligation_ids: [],
+            contradicted_obligation_ids: [],
+            residual_unknown_ids: [],
+        },
+        ownership_graph: [
+            {
+                obligation_id: "obl.readiness",
+                module_path: "src/readiness.ts",
+                symbol: "runReadiness",
+            },
+        ],
+        dependency_graph: [],
+        obligations: [
+            {
+                obligation_id: "obl.readiness",
+                obligation_version: 1,
+                title: "Preserve the packaged readiness fixture lifecycle",
+                origin: "reviewed",
+                application_layer: "process",
+                family: "packaged-process-lifecycle",
+                target: {
+                    artifact_sha256: HASH,
+                    application_node_id: null,
+                    semantic_node_id: null,
+                    location: "/fixture",
+                },
+                authority_references: [
+                    {
+                        evidence_id: EVIDENCE_ID,
+                        authority: "controlled-replay",
+                        state: "observed",
+                        location: "/fixture",
+                    },
+                ],
+                source_state: "observed",
+                observed_cases: CASES.map((kind) => ({
+                    kind,
+                    evidence_id: EVIDENCE_ID,
+                    location: `/original/${kind}`,
+                })),
+                required: true,
+                required_case_kinds: [...CASES],
+                required_original_authority: "process",
+                required_fixture_authority: "packaged-process",
+                required_verifier_authority: "packaged-process",
+                requires_parser_type: false,
+                dependency_obligation_ids: [],
+                residual_unknown_ids: [],
+                unavailable_authority: [],
+                required_next_evidence: [],
+                binding: {
+                    obligation_id: "obl.readiness",
+                    owner: {
+                        module_path: "src/readiness.ts",
+                        symbol: "runReadiness",
+                        owner_sha256: HASH,
+                    },
+                    parser_type: null,
+                    original_cases: CASES.map((kind) => ({
+                        kind,
+                        evidence_id: EVIDENCE_ID,
+                        location: `/original/${kind}`,
+                    })),
+                    fixtures: CASES.map((kind) => ({
+                        fixture_id: `fixture.${kind}`,
+                        case_kind: kind,
+                        authority: "packaged-process",
+                        evidence_ids: [EVIDENCE_ID],
+                    })),
+                    verifier: {
+                        verifier_id: "verifier.readiness",
+                        claim_id: "claim.readiness",
+                        command: "npm run verify:readiness",
+                        authority: "packaged-process",
+                        status: "pass",
+                        result_evidence_id: EVIDENCE_ID,
+                        enumerated_obligation_ids: ["obl.readiness"],
+                        nondeterminism: {
+                            mode: "partial-order",
+                            specification: "Startup precedes teardown.",
+                        },
+                    },
+                },
+                status: "verified",
+                diagnostics: [],
+            },
+        ],
+        evidence_links: [EVIDENCE_ID],
+        limitations: [],
+    },
+    operation_outcomes: [
+        {
+            sequence: 0,
+            operation: "inspect-artifact",
+            surface: "cli",
+            call_kind: "valid",
+            expected_success: true,
+            cli_exit_code: 0,
+            mcp_status: null,
+            error_code: null,
+            recovered: false,
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            sequence: 1,
+            operation: "inspect-artifact",
+            surface: "mcp",
+            call_kind: "valid",
+            expected_success: true,
+            cli_exit_code: null,
+            mcp_status: "success",
+            error_code: null,
+            recovered: false,
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            sequence: 2,
+            operation: "capture-process",
+            surface: "cli",
+            call_kind: "permission",
+            expected_success: false,
+            cli_exit_code: 2,
+            mcp_status: null,
+            error_code: "permission-required",
+            recovered: true,
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            sequence: 3,
+            operation: "capture-process",
+            surface: "mcp",
+            call_kind: "permission",
+            expected_success: false,
+            cli_exit_code: null,
+            mcp_status: "non-success",
+            error_code: "permission-required",
+            recovered: true,
+            evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    cleanup: [
+        {
+            run_id: "run.cancelled",
+            cancelled: true,
+            owned_resources_remaining: 0,
+            diagnostic_evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    closure_history: [
+        {
+            sequence: 0,
+            ledger_digest: "b".repeat(64),
+            status: "open",
+            required_open: 1,
+            newly_verified_obligation_ids: [],
+            evidence_ids: [EVIDENCE_ID],
+        },
+        {
+            sequence: 1,
+            ledger_digest: HASH,
+            status: "ready",
+            required_open: 0,
+            newly_verified_obligation_ids: ["obl.readiness"],
+            evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    delegation_checks: [
+        {
+            candidate_id: "candidate.reconstructed",
+            delegates_to_authority: false,
+            evidence_ids: [EVIDENCE_ID],
+        },
+    ],
+    replay: {
+        expected_source_digest: null,
+        deterministic: true,
+        tamper_detected: true,
+        stale_input_detected: true,
+        evidence_ids: [EVIDENCE_ID],
+    },
+    stages: READINESS_STAGE_IDS.map((stageId) => ({
+        stage_id: stageId,
+        required: true,
+        status: "pass",
+        capability_issue: null,
+        next_action: null,
+        evidence_ids: [EVIDENCE_ID],
+        checks: READINESS_REQUIRED_CHECKS[stageId].map((checkId) => ({
+            check_id: checkId,
+            status: "pass",
+            detail: `Synthetic conformance proved ${checkId}.`,
+            evidence_ids: [EVIDENCE_ID],
+        })),
+    })),
+};

package/dist/contracts/toolContractExamples.js

@@ -13,6 +13,9 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     procedure_callees: { procedure: "main" },
     procedure_callers: { procedure: "main" },
     procedure_info: { procedure: "main" },
+    read_function_instructions: { procedure: "main" },
+    read_bytes: { address: "0x1000", length: 16 },
+    address_to_file_offset: { address: "0x1000" },
     procedure_references: { procedure: "main" },
     procedure_pseudo_code: { procedure: "main" },
     resolve_containing_procedure: { address: "0x1000" },
@@ -29,6 +32,8 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     find_xrefs_to_name: { name: "malloc" },
     analyze_function: { procedure: "main" },
     trace_feature: { query: "license" },
+    find_code_for_string: { query: "authorization failed" },
+    trace_call_path: { start: "0x1000", goal: "0x1100" },
     open_binary: { path: "/tmp/fixture" },
     import_evidence_bundle: { path: "evidence.json" },
     capture_process_scenario: {

package/dist/contracts/toolContractTypes.js

@@ -7,6 +7,7 @@ export const TOOL_KINDS = [
     "managed-provider",
     "browser-provider",
     "electron-provider",
+    "runtime-provider",
     "application",
     "session",
 ];

package/dist/contracts/toolContracts.js

@@ -18,12 +18,16 @@ import { NATIVE_TOOL_CONTRACTS } from "./nativeToolContracts.js";
 import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
 import { MANAGED_TOOL_CONTRACTS } from "./managedToolContracts.js";
 import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "./managedWorkflowToolContracts.js";
-import { BROWSER_TOOL_CONTRACTS } from "./browserToolContracts.js";
+import { BROWSER_PROVIDER_TOOL_CONTRACTS } from "./browserProviderToolContracts.js";
 import { ELECTRON_TOOL_CONTRACTS } from "./electronToolContracts.js";
+import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "./javascriptRuntimeObservationToolContracts.js";
 import { APPLICATION_TOOL_CONTRACTS } from "./applicationToolContracts.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "./sessionLifecycleInputs.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { binarySessionInputSchema } from "./sessionStatusContract.js";
+import { functionInstructionInputSchema } from "./functionInstructionContract.js";
+import { HOPPER_MEMORY_TOOL_DEFINITIONS } from "./hopperMemoryContracts.js";
+import { analysisSearchInput } from "./analysisSearchContract.js";
 export { binarySessionInputSchema } from "./sessionStatusContract.js";
 const document = z.string().optional().describe("The document name");
 const address = z
@@ -31,27 +35,10 @@ const address = z
     .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");
 const optionalAddress = address.optional();
 const procedure = z.string().describe("The procedure name or address");
-const searchPattern = z
-    .string()
-    .min(1)
-    .max(256)
-    .describe("The literal text or bounded regex pattern to search for");
-const caseSensitive = z
-    .boolean()
-    .default(false)
-    .describe("Whether to match case");
 const pagination = {
     offset: z.number().int().min(0).default(0),
     limit: z.number().int().min(1).max(500).default(100),
 };
-const searchInput = {
-    pattern: searchPattern,
-    mode: z.enum(["literal", "regex"]).default("literal"),
-    case_sensitive: caseSensitive,
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
-    document,
-};
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
 const examplesFor = (name, inputSchema) => {
     const parsed = inputSchema.parse(TOOL_EXAMPLE_OVERRIDES[name] ?? {});
@@ -119,6 +106,8 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     official("procedure_callees", "Return the provider's resolved direct callees for one procedure identified by symbol or address. Unresolved indirect calls may be absent; use analyze_function and typed references to preserve available edge uncertainty.", z.object({ procedure, document })),
     official("procedure_callers", "Return the provider's resolved direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit unresolved indirect references.", z.object({ procedure, document })),
     official("procedure_info", "Return bounded metadata for one procedure identified by symbol or address: entrypoint, signature, locals, size, and block count. Follow with decompilation or assembly for behavior.", z.object({ procedure, document })),
+    official("read_function_instructions", "Read one offset-paginated window of raw instructions for an analyzed procedure without decompilation, caller discovery, or whole-program string/name scans. Use this fast path for instruction-level orientation; follow next_offset when truncated.", functionInstructionInputSchema),
+    ...HOPPER_MEMORY_TOOL_DEFINITIONS.map(({ name, description, inputSchema }) => official(name, description, inputSchema)),
     official("procedure_references", "Return a bounded set of raw incoming or outgoing reference edges for one procedure. Endpoint procedures are resolved only from provider containment; Ghidra preserves observed reference kinds while providers without kind authority mark them unavailable.", z.object({
         procedure,
         direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
@@ -129,8 +118,8 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     })),
     official("procedure_pseudo_code", "Decompile one analyzed procedure by symbol name or provider-normalized address. Returns provider-specific pseudocode, never original source or cross-provider text equivalence, and may return null; request procedure_assembly when instruction precision matters.", z.object({ procedure, document })),
     official("resolve_containing_procedure", "Resolve an arbitrary address, including an interior instruction or exact external entry, to its provider-analyzed containing procedure. A negative result distinguishes outside segments from not in a procedure and is never guessed from nearby symbols.", z.object({ address, document })),
-    official("search_procedures", "Search analyzed procedure names using literal matching by default or regex opt-in. Providers bound search work and reject regex constructs, paths, candidates, or cumulative work outside their finite budgets. Results are deterministic and offset-paginated.", z.object(searchInput)),
-    official("search_strings", "Search analyzed strings using literal matching by default or regex opt-in. Providers bound search work and reject regex constructs, paths, candidates, or cumulative work outside their finite budgets. Results are deterministic, offset-paginated, and explicitly truncated.", z.object(searchInput)),
+    official("search_procedures", "Search analyzed procedure names using literal matching by default or regex opt-in. Providers bound search work and reject regex constructs, paths, candidates, or cumulative work outside their finite budgets. Results are deterministic and offset-paginated.", z.object(analysisSearchInput)),
+    official("search_strings", "Search analyzed strings using literal matching by default or regex opt-in. Providers bound search work and reject regex constructs, paths, candidates, or cumulative work outside their finite budgets. Results are deterministic, offset-paginated, and explicitly truncated.", z.object(analysisSearchInput)),
     official("set_address_name", "Assign an analyst name to one hexadecimal address and report Hopper's boolean result. This mutates analysis metadata; read it back with address_name before relying on it.", z.object({ address, name: z.string(), document })),
     official("set_addresses_names", "Assign analyst names to an address/name map and return per-address success booleans. This mutates analysis metadata; use for bounded batches and verify failures individually.", z.object({ names: z.record(z.string(), z.string()), document })),
     official("set_bookmark", "Create or replace a bookmark at a hexadecimal address. This mutates navigation metadata; verify with list_bookmarks and do not treat bookmarks as binary evidence.", z.object({ address, name: z.string().optional(), document })),
@@ -152,6 +141,8 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("binary_overview", "Use immediately after opening a target to summarize document, exhaustive procedure/string counts, and a bounded segment sample. detail controls segment fields and limit controls only the returned segment sample.", enhancedInputSchemas.binary_overview),
     enhanced("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.", enhancedInputSchemas.analyze_function),
     enhanced("trace_feature", "Trace a bounded literal feature query through matching strings and procedures, xrefs, and truthful containing-procedure resolution. Returns the operation budget, truncation, and residual unknowns; unknown_registry_approved: true records them durably without inferring reference kinds.", enhancedInputSchemas.trace_feature),
+    enhanced("find_code_for_string", "Resolve one literal string query to bounded analyzed string entries, xrefs, and truthful containing-procedure candidates. Returns an Evidence ID, exact operation budget, truncation, and residual unknowns; it never infers reference kinds or runtime reachability.", enhancedInputSchemas.find_code_for_string),
+    enhanced("trace_call_path", "Trace a deterministic bounded caller or callee path from one exact procedure address, optionally stopping at a goal. Returns visited nodes, direct-call edges, one shortest traversal path, failures, frontier, consumed limits, an Evidence ID, and explicit residual unknowns without claiming unresolved indirect calls are absent.", enhancedInputSchemas.trace_call_path),
 ];
 /** Session-owned Evidence bundle export options. */
 export const exportEvidenceBundleInputSchema = z.strictObject({
@@ -215,8 +206,9 @@ export const TOOL_CONTRACTS = [
     ...ARTIFACT_TOOL_CONTRACTS,
     ...MANAGED_TOOL_CONTRACTS,
     ...MANAGED_WORKFLOW_TOOL_CONTRACTS,
-    ...BROWSER_TOOL_CONTRACTS,
+    ...BROWSER_PROVIDER_TOOL_CONTRACTS,
     ...ELECTRON_TOOL_CONTRACTS,
+    ...JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS,
     ...APPLICATION_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
 ];

package/dist/contracts/toolEffects.js

@@ -38,6 +38,9 @@ export const TOOL_EFFECTS = {
     procedure_callees: evidence,
     procedure_callers: evidence,
     procedure_info: evidence,
+    read_function_instructions: evidence,
+    read_bytes: evidence,
+    address_to_file_offset: evidence,
     procedure_references: evidence,
     procedure_pseudo_code: evidence,
     resolve_containing_procedure: evidence,
@@ -65,12 +68,15 @@ export const TOOL_EFFECTS = {
     binary_overview: evidence,
     analyze_function: evidence,
     trace_feature: effects({ mutatesSession: true, idempotent: false }),
+    find_code_for_string: effects({ mutatesSession: true, idempotent: false }),
+    trace_call_path: effects({ mutatesSession: true, idempotent: false }),
     inspect_macho: nativeEvidence,
     inspect_signature: nativeEvidence,
     inspect_plist: nativeEvidence,
     list_architectures: nativeEvidence,
     demangle_swift: nativeEvidence,
     inventory_artifact: evidence,
+    inspect_artifact: evidence,
     extract_artifact: effects({ mutatesSession: true, writesFilesystem: true }),
     inspect_managed_artifact: evidence,
     inspect_managed_members: evidence,
@@ -88,14 +94,29 @@ export const TOOL_EFFECTS = {
     compare_web_captures: browserEvidence,
     capture_web_screenshot: browserEvidence,
     compare_web_screenshots: browserEvidence,
+    capture_browser_scenario: effects({
+        mutatesTarget: true,
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+        accessesNetwork: true,
+        changesUiState: true,
+        mayDiscardData: true,
+        idempotent: false,
+    }),
     list_electron_targets: browserEvidence,
     inspect_electron_page: browserEvidence,
+    list_javascript_runtime_targets: browserEvidence,
+    observe_javascript_runtime: browserEvidence,
     analyze_javascript_application: evidence,
     reconcile_javascript_runtime: evidence,
     trace_application_feature: evidence,
     trace_javascript_semantics: evidence,
     compare_application_versions: evidence,
+    compare_source_to_bundle: evidence,
     compare_javascript_export_shapes: evidence,
+    build_reconstruction_obligation_ledger: evidence,
+    evaluate_reconstruction_readiness: evidence,
     run_replay_machine: effects(),
     run_controlled_replay: effects({
         mutatesSession: true,