rea-agents 3.1.0 → 3.2.0

package/dist/config/passiveObservation.js

@@ -1,7 +1,7 @@
 import { ConfigurationError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { browserEndpointSchema, browserOriginSchema, } from "../domain/browserObservation.js";
-import { parseAbsoluteRoots, parseBrowserArray, parseElectronFileRoots, } from "./parsers.js";
+import { parseBrowserArray } from "./parsers.js";
 import { browserNetworkScope, permissionScope } from "./permissions.js";
 /** Parse every passive observation capability into closed policy variants. */
 export const parsePassiveObservationPolicies = (env) => {
@@ -26,22 +26,11 @@ export const appendPassiveObservationCeilings = (ceilings, policies) => {
     appendElectronCeiling(ceilings, policies.electron);
     appendV8InspectorCeiling(ceilings, policies.v8Inspector);
 };
-/** Project the legal file and origin scopes from an enabled V8 policy. */
-export const v8InspectorLocationScopes = (locations) => {
-    switch (locations.scope) {
-        case "files":
-            return { fileRoots: locations.fileRoots, allowedOrigins: [] };
-        case "origins":
-            return { fileRoots: [], allowedOrigins: locations.allowedOrigins };
-        case "files-and-origins":
-            return locations;
-    }
-};
 const parseBrowserObservationPolicy = (env) => {
-    const endpoints = parseBrowserArray(env.REA_BROWSER_CDP_ENDPOINTS_JSON, "REA_BROWSER_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
+    const endpoints = parseBrowserArray(env.REA_BROWSER_CDP_ENDPOINTS_JSON, "REA_BROWSER_CDP_ENDPOINTS_JSON", browserEndpointSchema);
     if (!endpoints.ok)
         return endpoints;
-    const origins = parseBrowserArray(env.REA_BROWSER_ALLOWED_ORIGINS_JSON, "REA_BROWSER_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
+    const origins = parseBrowserArray(env.REA_BROWSER_ALLOWED_ORIGINS_JSON, "REA_BROWSER_ALLOWED_ORIGINS_JSON", browserOriginSchema);
     if (!origins.ok)
         return origins;
     if (env.REA_BROWSER_OBSERVE_ENABLED !== "true")
@@ -59,70 +48,14 @@ const parseBrowserObservationPolicy = (env) => {
     });
 };
 const parseElectronObservationPolicy = (env) => {
-    const endpoints = parseBrowserArray(env.REA_ELECTRON_CDP_ENDPOINTS_JSON, "REA_ELECTRON_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!endpoints.ok)
-        return endpoints;
-    const roots = parseElectronFileRoots(env.REA_ELECTRON_FILE_ROOTS_JSON);
-    if (!roots.ok)
-        return roots;
     if (env.REA_ELECTRON_OBSERVE_ENABLED !== "true")
         return ok({ status: "disabled" });
-    const parsedEndpoints = requireFirst(endpoints.value, "REA_ELECTRON_CDP_ENDPOINTS_JSON must encode at least one loopback endpoint when Electron observation is enabled");
-    if (!parsedEndpoints.ok)
-        return parsedEndpoints;
-    const parsedRoots = requireFirst(roots.value, "REA_ELECTRON_FILE_ROOTS_JSON must encode at least one absolute root when Electron observation is enabled");
-    if (!parsedRoots.ok)
-        return parsedRoots;
-    return ok({
-        status: "enabled",
-        cdpEndpoints: parsedEndpoints.value,
-        fileRoots: parsedRoots.value,
-    });
+    return ok({ status: "enabled" });
 };
 const parseV8InspectorObservationPolicy = (env) => {
-    const endpoints = parseBrowserArray(env.REA_V8_INSPECTOR_ENDPOINTS_JSON, "REA_V8_INSPECTOR_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!endpoints.ok)
-        return endpoints;
-    const roots = parseAbsoluteRoots(env.REA_V8_INSPECTOR_FILE_ROOTS_JSON, "REA_V8_INSPECTOR_FILE_ROOTS_JSON");
-    if (!roots.ok)
-        return roots;
-    const origins = parseBrowserArray(env.REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON, "REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
-    if (!origins.ok)
-        return origins;
     if (env.REA_V8_INSPECTOR_OBSERVE_ENABLED !== "true")
         return ok({ status: "disabled" });
-    const parsedEndpoints = requireFirst(endpoints.value, "REA_V8_INSPECTOR_ENDPOINTS_JSON must encode at least one loopback endpoint when V8 Inspector observation is enabled");
-    if (!parsedEndpoints.ok)
-        return parsedEndpoints;
-    const locations = parseV8Locations(roots.value, origins.value);
-    if (!locations.ok)
-        return locations;
-    return ok({
-        status: "enabled",
-        endpoints: parsedEndpoints.value,
-        locations: locations.value,
-    });
-};
-const parseV8Locations = (roots, origins) => {
-    const [firstRoot, ...remainingRoots] = roots;
-    const [firstOrigin, ...remainingOrigins] = origins;
-    if (firstRoot !== undefined && firstOrigin !== undefined)
-        return ok({
-            scope: "files-and-origins",
-            fileRoots: [firstRoot, ...remainingRoots],
-            allowedOrigins: [firstOrigin, ...remainingOrigins],
-        });
-    if (firstRoot !== undefined)
-        return ok({
-            scope: "files",
-            fileRoots: [firstRoot, ...remainingRoots],
-        });
-    if (firstOrigin !== undefined)
-        return ok({
-            scope: "origins",
-            allowedOrigins: [firstOrigin, ...remainingOrigins],
-        });
-    return err(new ConfigurationError("V8 Inspector observation requires at least one file root or exact origin when enabled"));
+    return ok({ status: "enabled" });
 };
 const requireFirst = (values, message) => {
     const [first, ...remaining] = values;
@@ -141,17 +74,14 @@ const appendBrowserCeiling = (ceilings, policy) => {
 const appendElectronCeiling = (ceilings, policy) => {
     if (policy.status === "disabled")
         return;
-    ceilings.push(permissionScope("electron_observe", policy.fileRoots, {
-        origins: policy.cdpEndpoints,
+    ceilings.push(permissionScope("electron_observe", [], {
         network: "loopback",
     }));
 };
 const appendV8InspectorCeiling = (ceilings, policy) => {
     if (policy.status === "disabled")
         return;
-    const scopes = v8InspectorLocationScopes(policy.locations);
-    ceilings.push(permissionScope("v8_inspector_observe", scopes.fileRoots, {
-        origins: [...policy.endpoints, ...scopes.allowedOrigins],
+    ceilings.push(permissionScope("v8_inspector_observe", [], {
         network: "loopback",
     }));
 };

package/dist/config/permissions.js

@@ -1,11 +1,4 @@
 import { isLiteralLoopbackHostname } from "../domain/browserObservation.js";
-export const filePolicy = (roots) => ({
-    roots,
-    maxBytes: 64 * 1024 * 1024,
-    maxDepth: 64,
-    maxStringLength: 1024 * 1024,
-    maxNodes: 1_000_000,
-});
 export const permissionScope = (capability, roots, options = {}) => ({
     capability,
     roots,

package/dist/contracts/analysisSearchContract.js

@@ -1,14 +1,11 @@
 import { z } from "zod";
-/** Shared bounded provider search input fields. */
+/** Shared provider search input fields. */
 export const analysisSearchInput = {
     pattern: z
         .string()
         .min(1)
-        .max(256)
-        .describe("The literal text or bounded regex pattern to search for"),
+        .describe("The literal text or regex pattern to search for"),
     mode: z.enum(["literal", "regex"]).default("literal"),
     case_sensitive: z.boolean().default(false).describe("Whether to match case"),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
     document: z.string().optional().describe("The document name"),
 };

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: {},
@@ -71,40 +51,12 @@ const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
         cases: [{ case_id: "empty", arguments: [""] }],
     },
 });
-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,
@@ -118,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,
@@ -126,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",
@@ -139,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,
@@ -153,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,
@@ -167,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,
@@ -181,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,
@@ -194,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: {},
@@ -232,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,
@@ -246,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,
                 },
@@ -264,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: [],
@@ -284,61 +234,58 @@ 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",
                 },
             },

package/dist/contracts/applicationWorkflowInputContracts.js

@@ -5,123 +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 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,
 };
-/** MCP/CLI trace request accepting full Evidence or a ledger reference. */
-export const traceApplicationFeatureRequestSchema = z.union([
-    z.strictObject({
-        ...traceApplicationFeatureFacts,
-        application: evidenceSchema,
-    }),
-    z.strictObject({
-        ...traceApplicationFeatureFacts,
-        application_evidence_id: evidenceIdSchema,
-    }),
-]);
-/** MCP/CLI semantic trace request accepting full Evidence or a ledger reference. */
-export const traceJavaScriptSemanticsRequestSchema = z.union([
-    z.strictObject({
-        application: evidenceSchema,
-        query: javaScriptSemanticQueryInputSchema,
-    }),
-    z.strictObject({
-        application_evidence_id: evidenceIdSchema,
-        query: javaScriptSemanticQueryInputSchema,
-    }),
-]);
+/** MCP/CLI trace request carrying all Evidence inline. */
+export const traceApplicationFeatureRequestSchema = z.strictObject({
+    ...traceApplicationFeatureFacts,
+    application: evidenceSchema,
+});
+/** MCP/CLI semantic trace request carrying Evidence inline. */
+export const traceJavaScriptSemanticsRequestSchema = z.strictObject({
+    application: evidenceSchema,
+    query: javaScriptSemanticQueryInputSchema,
+});
 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,
 };
-/** MCP/CLI comparison request accepting full Evidence or ledger references. */
-export const compareApplicationVersionsRequestSchema = z.union([
-    z.strictObject({
-        ...compareApplicationVersionsFacts,
-        left: evidenceSchema,
-        right: evidenceSchema,
-    }),
-    z.strictObject({
-        ...compareApplicationVersionsFacts,
-        left: evidenceSchema,
-        right_evidence_id: evidenceIdSchema,
-    }),
-    z.strictObject({
-        ...compareApplicationVersionsFacts,
-        left_evidence_id: evidenceIdSchema,
-        right: evidenceSchema,
-    }),
-    z.strictObject({
-        ...compareApplicationVersionsFacts,
-        left_evidence_id: evidenceIdSchema,
-        right_evidence_id: evidenceIdSchema,
-    }),
-]);
+/** MCP/CLI comparison request carrying all Evidence inline. */
+export const compareApplicationVersionsRequestSchema = z.strictObject({
+    ...compareApplicationVersionsFacts,
+    left: evidenceSchema,
+    right: evidenceSchema,
+});
 const compareSourceToBundleFacts = {
     reference: compareSourceToBundleInputSchema.shape.reference,
-    limits: compareSourceToBundleInputSchema.shape.limits,
-    unknown_registry_approved: compareSourceToBundleInputSchema.shape.unknown_registry_approved,
 };
-/** Historical-source comparison accepting full application Evidence or a ledger reference. */
-export const compareSourceToBundleRequestSchema = z.union([
-    z.strictObject({
-        ...compareSourceToBundleFacts,
-        application: evidenceSchema,
-    }),
-    z.strictObject({
-        ...compareSourceToBundleFacts,
-        application_evidence_id: evidenceIdSchema,
-    }),
-]);
+/** Historical-source comparison carrying application Evidence inline. */
+export const compareSourceToBundleRequestSchema = z.strictObject({
+    ...compareSourceToBundleFacts,
+    application: evidenceSchema,
+});
 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,
 };
-/** MCP/CLI export-shape request accepting full Evidence or ledger references. */
-export const compareJavaScriptExportShapesRequestSchema = z.union([
-    z.strictObject({
-        ...compareJavaScriptExportShapesFacts,
-        left: evidenceSchema,
-        right: evidenceSchema,
-    }),
-    z.strictObject({
-        ...compareJavaScriptExportShapesFacts,
-        left: evidenceSchema,
-        right_evidence_id: evidenceIdSchema,
-    }),
-    z.strictObject({
-        ...compareJavaScriptExportShapesFacts,
-        left_evidence_id: evidenceIdSchema,
-        right: evidenceSchema,
-    }),
-    z.strictObject({
-        ...compareJavaScriptExportShapesFacts,
-        left_evidence_id: evidenceIdSchema,
-        right_evidence_id: evidenceIdSchema,
-    }),
-]);
+/** MCP/CLI export-shape request carrying application Evidence inline. */
+export const compareJavaScriptExportShapesRequestSchema = z.strictObject({
+    ...compareJavaScriptExportShapesFacts,
+    left: evidenceSchema,
+    right: evidenceSchema,
+});