rea-agents 3.0.0 → 3.2.0

package/dist/contracts/applicationToolContracts.js

@@ -1,5 +1,4 @@
 import { applicationVersionComparisonResultSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { z } from "zod";
 import { applicationFeatureTraceResultSchema } from "../domain/javascriptFeatureTraceSchemas.js";
 import { javaScriptSemanticTraceResultSchema } from "../domain/javascriptSemanticTraceSchemas.js";
 import { javaScriptExportShapeComparisonResultSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
@@ -7,44 +6,25 @@ import { sourceToBundleComparisonResultSchema } from "../domain/sourceToBundleCo
 import { compareApplicationVersionsRequestSchema, compareJavaScriptExportShapesRequestSchema, compareSourceToBundleRequestSchema, traceApplicationFeatureRequestSchema, traceJavaScriptSemanticsRequestSchema, } from "./applicationWorkflowInputContracts.js";
 import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../domain/javascriptReplay.js";
 import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../domain/nodeRuntimeCharacterization.js";
-import { reconstructionCoverageCommitInputSchema, reconstructionCoverageCommitOutputSchema, reconstructionCoverageQueryInputSchema, } from "../application/ReconstructionCoverageService.js";
+import { reconstructionCoverageEvaluationInputSchema } from "../application/ReconstructionCoverageService.js";
 import { reconstructionClosureResultSchema } from "../domain/reconstructionCoverage.js";
-import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerPageSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
-import { reconstructionReadinessInputSchema, reconstructionReadinessReportSchema, } from "../domain/reconstructionReadinessSchemas.js";
+import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
 import { JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE, JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE, JAVASCRIPT_FEATURE_TRACE_EXAMPLE, SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE, } from "./javascriptApplicationWorkflowExamples.js";
-import { RECONSTRUCTION_READINESS_EXAMPLE } from "./reconstructionReadinessExample.js";
 const traceOutputSchema = evidenceResultOf(applicationFeatureTraceResultSchema);
 const semanticTraceOutputSchema = evidenceResultOf(javaScriptSemanticTraceResultSchema);
 const comparisonOutputSchema = evidenceResultOf(applicationVersionComparisonResultSchema);
 const sourceToBundleOutputSchema = evidenceResultOf(sourceToBundleComparisonResultSchema);
 const exportShapeComparisonOutputSchema = evidenceResultOf(javaScriptExportShapeComparisonResultSchema);
-const reconstructionObligationLedgerOutputSchema = evidenceResultOf(reconstructionObligationLedgerPageSchema);
-const reconstructionReadinessOutputSchema = evidenceResultOf(reconstructionReadinessReportSchema
-    .pick({
-    schema: true,
-    schema_version: true,
-    report_id: true,
-    source_digest: true,
-    report_digest: true,
-    status: true,
-    summary: true,
-    metrics: true,
-})
-    .extend({
-    report_resource_uri: z
-        .string()
-        .regex(/^rea:\/\/evidence\/ev_[a-f0-9]{64}\/reconstruction-readiness-report$/u),
-}));
+const reconstructionObligationLedgerOutputSchema = evidenceResultOf(reconstructionObligationLedgerSchema);
 const HASH = "0".repeat(64);
 const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
-    preparation_approved: true,
     selected_alias: "bundle",
     expected_effect: "pure",
     instrumentation: {
-        artifact_path: "/approved/bundle.js",
+        artifact_path: "/tmp/example/bundle.js",
         artifact_sha256: HASH,
         selection: {
             byte_start: 100,
@@ -59,7 +39,7 @@ const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
             modules: [
                 {
                     alias: "bundle",
-                    path: "/approved/bundle.js",
+                    path: "/tmp/example/bundle.js",
                     format: "commonjs-factory",
                     role: "module",
                     dependencies: {},
@@ -69,43 +49,14 @@ const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
             entry_export: "selected",
         },
         cases: [{ case_id: "empty", arguments: [""] }],
-        approved: false,
     },
 });
-const COVERAGE_WORKSPACE_EXAMPLE = jsonObjectSchema.parse({
-    schema_version: 1,
-    workspace_id: `rcw_${HASH}`,
-    name: "replacement",
-    revision: 1,
-    previous_revision_sha256: null,
-    revision_sha256: HASH,
-    evidence_bundle: {
-        bundle_version: 2,
-        artifacts: [],
-        providers: [],
-        environments: [],
-        scenarios: [],
-        captures: [],
-        unknowns: [],
-        records: [],
-    },
-    artifacts: [],
-    surfaces: [],
-    owners: [],
-    claims: [],
-    verifier_contracts: [],
-    verifier_results: [],
-    residual_unknown_ids: [],
-    contradictions: [],
-    package_proofs: [],
-    boundaries: [],
-});
 /** Provider-neutral graph workflow contracts shared by MCP and CLI adapters. */
 export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "trace_application_feature",
         ...toolContractMetadata("trace_application_feature"),
-        description: "Trace a typed literal seed through an authenticated JavaScript Application Graph supplied as full Evidence or an Evidence ID returned earlier in this session. Explicit direction, depth, node, edge, and path bounds apply. Original static, native, passive-runtime, inferred, and unknown authorities remain distinct; native addon handoffs never open a provider or execute the application.",
+        description: "Trace a typed literal seed through every reachable part of an authenticated JavaScript Application Graph supplied as inline Evidence. Original static, native, passive-runtime, inferred, and unknown authorities remain distinct; native addon handoffs never open a provider or execute the application.",
         kind: "application",
         inputSchema: traceApplicationFeatureRequestSchema,
         outputSchema: traceOutputSchema,
@@ -119,7 +70,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "trace_javascript_semantics",
         ...toolContractMetadata("trace_javascript_semantics"),
-        description: "Trace bounded static JavaScript data-flow, direct call/return, and closure relations from authenticated analyze_javascript_application v2 Evidence. Queries declare direction and exact node, relation, depth, function, module, and page limits. Dynamic or unsupported semantics remain explicit unknowns; static reachability never claims runtime execution.",
+        description: "Trace static JavaScript data-flow, direct call/return, and closure relations from inline application Evidence. Dynamic or unsupported semantics remain explicit unknowns; static reachability never claims runtime execution.",
         kind: "application",
         inputSchema: traceJavaScriptSemanticsRequestSchema,
         outputSchema: semanticTraceOutputSchema,
@@ -127,7 +78,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
             {
                 title: "Trace backward provenance from one semantic node",
                 input: {
-                    application_evidence_id: `ev_${HASH}`,
+                    application: JAVASCRIPT_FEATURE_TRACE_EXAMPLE.application,
                     query: {
                         seed: { kind: "semantic-node", node_id: `jsrg_node_${HASH}` },
                         direction: "backward-provenance",
@@ -140,7 +91,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "compare_application_versions",
         ...toolContractMetadata("compare_application_versions"),
-        description: "Compare two authenticated JavaScript Application Graph versions supplied as full Evidence or Evidence IDs returned earlier in this session. Uses unique-only exact digest, module source digest, source-map identity, structural fingerprint, and non-module semantic-key tiers. Reports added, removed, changed, ambiguous, and unknown entities plus a bounded changed_from graph without fuzzy or module-ordinal pairing.",
+        description: "Compare two authenticated JavaScript Application Graph versions supplied as inline Evidence. Uses unique-only exact digest, module source digest, source-map identity, structural fingerprint, and non-module semantic-key tiers. Reports added, removed, changed, ambiguous, and unknown entities plus the complete matching changed_from graph without fuzzy or module-ordinal pairing.",
         kind: "application",
         inputSchema: compareApplicationVersionsRequestSchema,
         outputSchema: comparisonOutputSchema,
@@ -154,7 +105,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "compare_source_to_bundle",
         ...toolContractMetadata("compare_source_to_bundle"),
-        description: "Compare a cryptographically committed HistoricalSourceGraph/v1 with authenticated JavaScript Application Graph Evidence supplied directly or by session Evidence ID. Uses explicit exact-digest, source-map path, current-path, suffix, and basename signals with stable weights. Classifies unchanged, modified, removed, split, merged, duplicated, and unknown; incomplete coverage and ambiguous weak signals never become absence or forced matches.",
+        description: "Compare a cryptographically committed HistoricalSourceGraph with inline authenticated JavaScript Application Graph Evidence. Uses explicit exact-digest, source-map path, current-path, suffix, and basename signals with stable weights. Classifies unchanged, modified, removed, split, merged, duplicated, and unknown; incomplete coverage and ambiguous weak signals never become absence or forced matches.",
         kind: "application",
         inputSchema: compareSourceToBundleRequestSchema,
         outputSchema: sourceToBundleOutputSchema,
@@ -168,7 +119,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "compare_javascript_export_shapes",
         ...toolContractMetadata("compare_javascript_export_shapes"),
-        description: "Compare bounded static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph, supplied as full Evidence or session Evidence IDs. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes and recommends controlled replay separately without executing JavaScript.",
+        description: "Compare static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph supplied as inline Evidence. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes and recommends controlled replay separately without executing JavaScript.",
         kind: "application",
         inputSchema: compareJavaScriptExportShapesRequestSchema,
         outputSchema: exportShapeComparisonOutputSchema,
@@ -182,7 +133,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "run_controlled_replay",
         ...toolContractMetadata("run_controlled_replay"),
-        description: "Plan or execute a content-bound extracted-module JavaScript replay inside the Linux Bubblewrap, seccomp, and cgroup boundary. Execution requires approved: true and the exact plan digest. Supports deterministic boundary cases and optional left/right differential comparison; observations have controlled-replay authority and do not claim real application runtime behavior.",
+        description: "Plan or execute a content-bound extracted-module JavaScript replay inside the Linux Bubblewrap, seccomp, and cgroup boundary. Execution requires the exact plan digest. Supports deterministic boundary cases and optional left/right differential comparison; observations have controlled-replay authority and do not claim real application runtime behavior.",
         kind: "application",
         inputSchema: controlledReplayInputSchema,
         outputSchema: controlledReplayOutputSchema,
@@ -195,7 +146,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
                         modules: [
                             {
                                 alias: "parser",
-                                path: "/approved/parser.mjs",
+                                path: "/tmp/example/parser.mjs",
                                 format: "esm",
                                 role: "module",
                                 dependencies: {},
@@ -226,7 +177,6 @@ export const APPLICATION_TOOL_CONTRACTS = [
                         result_depth: 16,
                         result_nodes: 10000,
                     },
-                    approved: false,
                 },
             },
         ],
@@ -234,7 +184,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "prepare_node_characterization",
         ...toolContractMetadata("prepare_node_characterization"),
-        description: "Prepare a hash-bound Node/JavaScript characterization plan and deterministic reversible export transformation without executing target code. The exact source, selected byte range, runtime closure, sandbox profile, cases, and limits are committed for separate execution approval.",
+        description: "Prepare a hash-bound Node/JavaScript characterization plan and deterministic reversible export transformation without executing target code. The exact source, selected byte range, runtime closure, sandbox profile, cases, and limits are committed for later execution.",
         kind: "application",
         inputSchema: nodeCharacterizationPreparationInputSchema,
         outputSchema: nodeCharacterizationPreparationOutputSchema,
@@ -248,15 +198,14 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "execute_node_characterization",
         ...toolContractMetadata("execute_node_characterization"),
-        description: "Recompute and execute one separately approved exact Node characterization plan in the owned controlled-replay boundary. Returns transformation, replay, cleanup, and provider-neutral characterization Evidence v2; stale plans fail before execution.",
+        description: "Recompute and execute one exact Node characterization plan in the owned controlled-replay boundary. Returns transformation, replay, cleanup, and provider-neutral characterization Evidence; stale plans fail before execution.",
         kind: "application",
         inputSchema: nodeCharacterizationExecutionInputSchema,
         outputSchema: nodeCharacterizationExecutionOutputSchema,
         examples: [
             {
-                title: "Execute one approved exact characterization plan",
+                title: "Execute one exact characterization plan",
                 input: {
-                    execution_approved: true,
                     approved_plan_sha256: HASH,
                     preparation: NODE_PREPARATION_EXAMPLE,
                 },
@@ -266,16 +215,15 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "build_reconstruction_obligation_ledger",
         ...toolContractMetadata("build_reconstruction_obligation_ledger"),
-        description: "Generate one deterministic page of a ReconstructionObligationLedger/v1 from an authenticated Evidence v2 bundle, reviewed obligations, and an explicit reconstruction manifest. Static candidates remain candidates; duplicate ownership, missing original or reconstruction cases, missing parser/type, weak verifier authority, unenumerated claims, contradictions, dependencies, and residual unknowns fail closed. Every page carries the same full-ledger closure digest and typed per-obligation diagnostics.",
+        description: "Generate the complete deterministic ReconstructionObligationLedger from an authenticated Evidence bundle, reviewed obligations, and an explicit reconstruction manifest. Static candidates remain candidates; duplicate ownership, missing original or reconstruction cases, missing parser/type, weak verifier authority, unenumerated claims, contradictions, dependencies, and residual unknowns fail closed. The inline result carries the full-ledger closure digest and typed per-obligation diagnostics.",
         kind: "application",
         inputSchema: reconstructionObligationLedgerInputSchema,
         outputSchema: reconstructionObligationLedgerOutputSchema,
         examples: [
             {
-                title: "Generate the first obligation-ledger page",
+                title: "Generate the complete obligation ledger",
                 input: {
                     evidence_bundle: {
-                        bundle_version: 2,
                         artifacts: [],
                         providers: [],
                         environments: [],
@@ -286,71 +234,67 @@ export const APPLICATION_TOOL_CONTRACTS = [
                     },
                     reviewed_obligations: [],
                     manifest: {
-                        schema_version: 1,
                         bindings: [],
                         contradictions: [],
                     },
-                    limits: { max_obligations: 1_000 },
-                    page: { offset: 0, limit: 50 },
-                },
-            },
-        ],
-    },
-    {
-        name: "evaluate_reconstruction_readiness",
-        ...toolContractMetadata("evaluate_reconstruction_readiness"),
-        description: "Evaluate the fixed nine-stage public reconstruction journey into a deterministic ReconstructionReadinessReport/v1. Exact capability limits, provider routing, CLI/MCP status parity, bounded authority, partial-order comparison, contradictions, obligation closure, cleanup, and replay digests fail closed. Aggregate pass is emitted only when every required stage and check passes with attributable Evidence.",
-        kind: "application",
-        inputSchema: reconstructionReadinessInputSchema,
-        outputSchema: reconstructionReadinessOutputSchema,
-        examples: [
-            {
-                title: "Evaluate the complete synthetic reconstruction journey",
-                input: RECONSTRUCTION_READINESS_EXAMPLE,
-            },
-        ],
-    },
-    {
-        name: "commit_reconstruction_coverage",
-        ...toolContractMetadata("commit_reconstruction_coverage"),
-        description: "Atomically commit one canonical evidence-backed reconstruction coverage workspace revision under an approved root. CAS revisions reject lost updates; every Evidence and residual-unknown reference must resolve in the embedded canonical bundle.",
-        kind: "application",
-        inputSchema: reconstructionCoverageCommitInputSchema,
-        outputSchema: reconstructionCoverageCommitOutputSchema,
-        examples: [
-            {
-                title: "Commit the first canonical coverage revision",
-                input: {
-                    approved: true,
-                    workspace_path: "/approved/coverage.json",
-                    expected_revision: null,
-                    workspace: COVERAGE_WORKSPACE_EXAMPLE,
                 },
             },
         ],
     },
     {
-        name: "query_reconstruction_coverage",
-        ...toolContractMetadata("query_reconstruction_coverage"),
-        description: "Evaluate one named reconstruction boundary from a canonical coverage workspace. Missing ownership or inventory is partial; stale, weak, truncated, skipped, or unresolved proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.",
+        name: "evaluate_reconstruction_coverage",
+        ...toolContractMetadata("evaluate_reconstruction_coverage"),
+        description: "Evaluate inline evidence-backed reconstruction coverage against one named boundary. Missing ownership or inventory is partial; stale, weak, truncated, skipped, or unresolved proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.",
         kind: "application",
-        inputSchema: reconstructionCoverageQueryInputSchema,
+        inputSchema: reconstructionCoverageEvaluationInputSchema,
         outputSchema: reconstructionClosureResultSchema,
         examples: [
             {
                 title: "Evaluate one replacement boundary",
                 input: {
-                    workspace_path: "/approved/coverage.json",
+                    coverage: {
+                        evidence_bundle: {
+                            artifacts: [],
+                            providers: [],
+                            environments: [],
+                            scenarios: [],
+                            captures: [],
+                            unknowns: [],
+                            records: [],
+                        },
+                        artifacts: [],
+                        surfaces: [],
+                        owners: [],
+                        claims: [],
+                        verifier_contracts: [],
+                        verifier_results: [],
+                        residual_unknown_ids: [],
+                        contradictions: [],
+                        package_proofs: [],
+                        boundaries: [
+                            {
+                                boundary_id: "replacement.cli",
+                                title: "CLI replacement",
+                                required_surface_ids: ["cli.help"],
+                                required_claim_ids: ["claim.cli.help"],
+                                required_package_proof_kinds: [
+                                    "clean-install",
+                                    "authority-independence",
+                                ],
+                                allowed_dispositions: [],
+                                allowed_unknown_ids: [],
+                            },
+                        ],
+                    },
                     boundary_id: "replacement.cli",
                 },
             },
         ],
     },
 ];
-/** Resolve one named application contract without relying on array position. */
-export const applicationToolContract = (name) => {
+export function applicationToolContract(name) {
     const contract = APPLICATION_TOOL_CONTRACTS.find(({ name: candidate }) => candidate === name);
     if (contract === undefined)
         throw new Error(`Missing application tool contract: ${name}`);
     return contract;
-};
+}

package/dist/contracts/applicationWorkflowInputContracts.js

@@ -5,133 +5,48 @@ import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptEx
 import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
 import { javaScriptSemanticQueryInputSchema } from "../domain/javascriptSemanticQuerySchemas.js";
 import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
-const evidenceIdSchema = z
-    .string()
-    .regex(/^ev_[a-f0-9]{64}$/u)
-    .describe("Evidence ID returned earlier in this session");
-const requireExactlyOne = (context, fields) => {
-    const [leftName, left, rightName, right] = fields;
-    if ((left === undefined) !== (right === undefined))
-        return;
-    context.addIssue({
-        code: "custom",
-        path: [left === undefined ? leftName : rightName],
-        message: `Supply exactly one of ${leftName} or ${rightName}`,
-    });
-};
-/** MCP/CLI trace request accepting full Evidence or a ledger reference. */
-export const traceApplicationFeatureRequestSchema = z
-    .strictObject({
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
+const traceApplicationFeatureFacts = {
     native_observations: traceApplicationFeatureInputSchema.shape.native_observations,
-    native_observation_evidence_ids: z
-        .array(evidenceIdSchema)
-        .max(64)
-        .default([]),
     seed: traceApplicationFeatureInputSchema.shape.seed,
     direction: traceApplicationFeatureInputSchema.shape.direction,
-    limits: traceApplicationFeatureInputSchema.shape.limits,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
+};
+/** MCP/CLI trace request carrying all Evidence inline. */
+export const traceApplicationFeatureRequestSchema = z.strictObject({
+    ...traceApplicationFeatureFacts,
+    application: evidenceSchema,
 });
-/** MCP/CLI semantic trace request accepting full Evidence or a ledger reference. */
-export const traceJavaScriptSemanticsRequestSchema = z
-    .strictObject({
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
+/** MCP/CLI semantic trace request carrying Evidence inline. */
+export const traceJavaScriptSemanticsRequestSchema = z.strictObject({
+    application: evidenceSchema,
     query: javaScriptSemanticQueryInputSchema,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
 });
-/** MCP/CLI comparison request accepting full Evidence or ledger references. */
-export const compareApplicationVersionsRequestSchema = z
-    .strictObject({
-    left: evidenceSchema.optional(),
-    left_evidence_id: evidenceIdSchema.optional(),
-    right: evidenceSchema.optional(),
-    right_evidence_id: evidenceIdSchema.optional(),
+const compareApplicationVersionsFacts = {
     left_native_observations: compareApplicationVersionsInputSchema.shape.left_native_observations,
-    left_native_observation_evidence_ids: z
-        .array(evidenceIdSchema)
-        .max(64)
-        .default([]),
     right_native_observations: compareApplicationVersionsInputSchema.shape.right_native_observations,
-    right_native_observation_evidence_ids: z
-        .array(evidenceIdSchema)
-        .max(64)
-        .default([]),
-    limits: compareApplicationVersionsInputSchema.shape.limits,
-    unknown_registry_approved: compareApplicationVersionsInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "left",
-        input.left,
-        "left_evidence_id",
-        input.left_evidence_id,
-    ]);
-    requireExactlyOne(context, [
-        "right",
-        input.right,
-        "right_evidence_id",
-        input.right_evidence_id,
-    ]);
+};
+/** MCP/CLI comparison request carrying all Evidence inline. */
+export const compareApplicationVersionsRequestSchema = z.strictObject({
+    ...compareApplicationVersionsFacts,
+    left: evidenceSchema,
+    right: evidenceSchema,
 });
-/** Historical-source comparison accepting full application Evidence or a ledger reference. */
-export const compareSourceToBundleRequestSchema = z
-    .strictObject({
+const compareSourceToBundleFacts = {
     reference: compareSourceToBundleInputSchema.shape.reference,
-    application: evidenceSchema.optional(),
-    application_evidence_id: evidenceIdSchema.optional(),
-    limits: compareSourceToBundleInputSchema.shape.limits,
-    unknown_registry_approved: compareSourceToBundleInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "application",
-        input.application,
-        "application_evidence_id",
-        input.application_evidence_id,
-    ]);
+};
+/** Historical-source comparison carrying application Evidence inline. */
+export const compareSourceToBundleRequestSchema = z.strictObject({
+    ...compareSourceToBundleFacts,
+    application: evidenceSchema,
 });
-/** MCP/CLI export-shape request accepting full Evidence or ledger references. */
-export const compareJavaScriptExportShapesRequestSchema = z
-    .strictObject({
-    left: evidenceSchema.optional(),
-    left_evidence_id: evidenceIdSchema.optional(),
-    right: evidenceSchema.optional(),
-    right_evidence_id: evidenceIdSchema.optional(),
+const compareJavaScriptExportShapesFacts = {
     left_module_path: compareJavaScriptExportShapesInputSchema.shape.left_module_path,
     left_export_name: compareJavaScriptExportShapesInputSchema.shape.left_export_name,
     right_module_path: compareJavaScriptExportShapesInputSchema.shape.right_module_path,
     right_export_name: compareJavaScriptExportShapesInputSchema.shape.right_export_name,
-    limits: compareJavaScriptExportShapesInputSchema.shape.limits,
-    unknown_registry_approved: compareJavaScriptExportShapesInputSchema.shape.unknown_registry_approved,
-})
-    .superRefine((input, context) => {
-    requireExactlyOne(context, [
-        "left",
-        input.left,
-        "left_evidence_id",
-        input.left_evidence_id,
-    ]);
-    requireExactlyOne(context, [
-        "right",
-        input.right,
-        "right_evidence_id",
-        input.right_evidence_id,
-    ]);
+};
+/** MCP/CLI export-shape request carrying application Evidence inline. */
+export const compareJavaScriptExportShapesRequestSchema = z.strictObject({
+    ...compareJavaScriptExportShapesFacts,
+    left: evidenceSchema,
+    right: evidenceSchema,
 });

package/dist/contracts/artifactComparisonExample.js

@@ -1,76 +1,74 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const inventory = (digit) => {
     const sha = digit.repeat(64);
-    const artifactId = `art_${sha}`;
-    const occurrenceId = `occ_${sha}`;
+    const artifactId = `art_${digestCanonical({ sha256: sha })}`;
+    const occurrenceId = `occ_${digestCanonical({ root: artifactId })}`;
+    const nodes = [
+        {
+            artifact_id: artifactId,
+            kind: "resource",
+            format: "file",
+            sha256: sha,
+            size: 1,
+            media_type: null,
+            architecture: null,
+            executable: false,
+            content_state: "materialized",
+            limitations: [],
+        },
+    ];
+    const occurrences = [
+        {
+            occurrence_id: occurrenceId,
+            artifact_id: artifactId,
+            parent_occurrence_id: null,
+            logical_path: ".",
+            entry_kind: "file",
+            declared_size: 1,
+            compressed_size: null,
+            executable: false,
+            encrypted: false,
+            hash_status: "verified",
+            source_location: null,
+            limitations: [],
+        },
+    ];
+    const graphSha256 = digestCanonical({
+        nodes,
+        occurrences,
+        edges: [],
+        integrity_contradictions: [],
+    });
     return jsonValueSchema.parse({
         manifest: {
-            schema_version: 1,
-            manifest_id: `agm_${sha}`,
+            manifest_id: `agm_${digestCanonical({
+                root_artifact_id: artifactId,
+                graph_sha256: graphSha256,
+            })}`,
             root_artifact_id: artifactId,
             root_sha256: sha,
             root_format: "file",
-            graph_sha256: sha,
-            node_count: 1,
-            occurrence_count: 1,
+            graph_sha256: graphSha256,
+            node_count: nodes.length,
+            occurrence_count: occurrences.length,
             edge_count: 0,
         },
-        nodes: {
-            items: [
-                {
-                    artifact_id: artifactId,
-                    kind: "resource",
-                    format: "file",
-                    sha256: sha,
-                    size: 1,
-                    media_type: null,
-                    architecture: null,
-                    executable: false,
-                    content_state: "materialized",
-                    limitations: [],
-                },
-            ],
-            offset: 0,
-            limit: 100,
-            total: 1,
-            next_offset: null,
-        },
-        occurrences: {
-            items: [
-                {
-                    occurrence_id: occurrenceId,
-                    artifact_id: artifactId,
-                    parent_occurrence_id: null,
-                    logical_path: ".",
-                    entry_kind: "file",
-                    declared_size: 1,
-                    compressed_size: null,
-                    executable: false,
-                    encrypted: false,
-                    hash_status: "verified",
-                    source_location: null,
-                    limitations: [],
-                },
-            ],
-            offset: 0,
-            limit: 100,
-            total: 1,
-            next_offset: null,
-        },
-        edges: { items: [], offset: 0, limit: 100, total: 0, next_offset: null },
-        limits: {
-            max_entries: 100,
-            max_total_bytes: 1024,
-            max_entry_bytes: 1024,
-            max_compression_ratio: 10,
-            max_depth: 10,
-            max_path_bytes: 256,
-        },
+        nodes,
+        occurrences,
+        edges: [],
         provenance: [],
         limitations: [],
     });
 };
+const digestCanonical = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Artifact example is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};
 const provider = {
     id: "rea-artifact",
     name: "REA artifact graph",
@@ -78,14 +76,14 @@ const provider = {
 };
 /** Canonical complete inputs used to advertise artifact comparison. */
 export const ARTIFACT_COMPARISON_EXAMPLE = {
-    left: createEvidence(undefined, provider, {
+    left: createEvidence({ path: "fixture-left", sha256: "0".repeat(64), format: "file" }, provider, {
         operation: "inventory_artifact",
         parameters: {},
         result: inventory("0"),
         confidence: "observed",
         authority: "shipped-artifact",
     }),
-    right: createEvidence(undefined, provider, {
+    right: createEvidence({ path: "fixture-right", sha256: "1".repeat(64), format: "file" }, provider, {
         operation: "inventory_artifact",
         parameters: {},
         result: inventory("1"),