rea-agents 6.0.0 → 6.2.0

package/dist/server/registerInvestigationTools.js

@@ -3,13 +3,12 @@ import { buildCallPath } from "../domain/callPath.js";
 import { findChangedBehavior } from "../domain/changedBehavior.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { verifyReconstruction } from "../domain/reconstructionVerification.js";
 import { correlateStaticAndRuntime } from "../domain/staticRuntimeCorrelation.js";
 import { comparisonClosure, evidenceClosure, functionEvidenceIds, isIncomplete, recordWorkflowEvidence, } from "./registerInvestigationTools/helpers.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
+import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { verifyReconstruction } from "../domain/reconstructionVerification.js";
 /** Register Evidence-composed differential investigation workflows. */
 export const registerInvestigationTools = (server, session) => {
     registerChangedBehavior(server, session, toolContract("find_changed_behavior"));
@@ -21,11 +20,11 @@ const registerChangedBehavior = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, comparisonClosure(input.comparisons));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
             predicateType: "rea.changed-behavior",
@@ -51,18 +50,18 @@ const registerChangedBehavior = (server, session, contract) => {
                 },
             ],
         });
-        return toCallToolResult(recorded, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerCallPath = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, functionEvidenceIds(input.functions));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(input));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {
             predicateType: "rea.call-path",
@@ -89,7 +88,7 @@ const registerCallPath = (server, session, contract) => {
                 },
             ],
         });
-        return toCallToolResult(recorded, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerStaticRuntime = (server, session, contract) => {
@@ -99,11 +98,11 @@ const registerStaticRuntime = (server, session, contract) => {
             ...input.runtime_comparisons,
         ]));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(input));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {
             predicateType: "rea.static-runtime-correlation",
@@ -117,7 +116,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
             question: "Does runtime behavior match the available static analysis?",
             domain: "static-runtime-correlation",
             requiredAuthority: null,
@@ -128,7 +127,7 @@ const registerStaticRuntime = (server, session, contract) => {
                     rationale: "Repeat runtime observations and complete the mapped static comparison Evidence.",
                 },
             ],
-        }), contract);
+        }));
     });
 };
 const registerReconstruction = (server, session, contract) => {
@@ -136,11 +135,11 @@ const registerReconstruction = (server, session, contract) => {
         const owned = session.exportEvidenceBundle();
         const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const closure = evidenceClosure(session, result.evidence_links);
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {
             predicateType: "rea.reconstruction-verification",
@@ -155,7 +154,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown", {
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,
@@ -164,6 +163,6 @@ const registerReconstruction = (server, session, contract) => {
                 operation,
                 rationale,
             })),
-        }), contract);
+        }));
     });
 };

package/dist/server/registerJavaScriptRecoveryTool.js

@@ -1,17 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Bind optional recovery to its exact named contract without acquiring an engine. */
 export const registerJavaScriptRecoveryTool = (server, service, logger, recordEvidence) => {
     const contract = toolContract("recover_javascript_sources");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(logger, contract.name, () => service.recover(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -5,13 +5,13 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { observeJavaScriptRuntimeInputSchema } from "../domain/javascript/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register passive Inspector tools even when policy keeps them unavailable. */
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_javascript_runtime_targets");
     const observeContract = toolContract("observe_javascript_runtime");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, parsed, { signal })));
-    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, async (parsed, signal) => {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(registration, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, parsed, { signal })));
+    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(registration, observeContract, { input, context }, async (parsed, signal) => {
         const request = observeJavaScriptRuntimeInputSchema.parse(parsed);
         return observeJavaScriptRuntime(options.runtime, request, { signal });
     }));
@@ -19,12 +19,10 @@ export const registerJavaScriptRuntimeObservationTools = (server, options) => {
 const runRuntimeTool = async (options, contract, request, execute) => {
     const { input, context } = request;
     if (options.loadFailure !== undefined)
-        return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
+        return options.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, context.mcpReq.signal));
     if (!result.ok)
-        return toCallToolResult(result, contract);
+        return options.delivery.toCallToolResult(result, contract);
     const recorded = options.recordEvidence?.(result.value);
-    return recorded !== undefined && !recorded.ok
-        ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: result.value }, contract);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -3,7 +3,6 @@ import { compareManagedMembersEvidenceValidated } from "../../application/manage
 import { managedMemberComparisonResultSchema } from "../../domain/managed/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const compareContract = managedWorkflowContract("compare_managed_members");
@@ -13,9 +12,9 @@ export const registerCompareManagedMembers = (server, options) => {
         const leftResolved = resolveManagedEvidence(input.left);
         const rightResolved = resolveManagedEvidence(input.right);
         if (!leftResolved.ok)
-            return toCallToolResult(leftResolved, compareContract);
+            return server.delivery.toCallToolResult(leftResolved, compareContract);
         if (!rightResolved.ok)
-            return toCallToolResult(rightResolved, compareContract);
+            return server.delivery.toCallToolResult(rightResolved, compareContract);
         const [left] = leftResolved.value;
         const [right] = rightResolved.value;
         if (left === undefined || right === undefined)
@@ -23,13 +22,13 @@ export const registerCompareManagedMembers = (server, options) => {
         const parsed = { left, right };
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareManagedMembersEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, compareContract);
+            return server.delivery.toCallToolResult(result, compareContract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, compareContract);
+            return server.delivery.toCallToolResult(recorded, compareContract);
         const comparison = managedMemberComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
         const output = unknown
@@ -51,8 +50,6 @@ export const registerCompareManagedMembers = (server, options) => {
                 relationships: [],
             })
             : options.recordEvidence?.(result.value);
-        if (output !== undefined && !output.ok)
-            return toCallToolResult(output, compareContract);
-        return toCallToolResult({ ok: true, value: result.value }, compareContract);
+        return server.delivery.toEvidenceToolResult(result.value, compareContract, output);
     });
 };

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -1,7 +1,6 @@
 import { importManagedReconstructionEvidenceValidated } from "../../application/managed/ManagedReconstructionService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const reconstructionContract = managedWorkflowContract("import_managed_reconstruction");
@@ -10,20 +9,18 @@ export const registerImportManagedReconstruction = (server, options) => {
     server.registerTool(reconstructionContract.name, toolRegistrationOptions(reconstructionContract), async (input) => {
         const resolved = resolveManagedEvidence(input.static_members);
         if (!resolved.ok)
-            return toCallToolResult(resolved, reconstructionContract);
+            return server.delivery.toCallToolResult(resolved, reconstructionContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed reconstruction Evidence resolution failed");
         const parsed = { ...input, static_members: staticMembers };
         const result = await logToolExecution(options.logger, reconstructionContract.name, () => Promise.resolve(importManagedReconstructionEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, reconstructionContract);
+            return server.delivery.toCallToolResult(result, reconstructionContract);
         const recordedSource = options.recordEvidence?.(parsed.static_members);
         if (recordedSource !== undefined && !recordedSource.ok)
-            return toCallToolResult(recordedSource, reconstructionContract);
+            return server.delivery.toCallToolResult(recordedSource, reconstructionContract);
         const recorded = options.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, reconstructionContract);
-        return toCallToolResult(result, reconstructionContract);
+        return server.delivery.toEvidenceToolResult(result.value, reconstructionContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -2,7 +2,6 @@ import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { projectManagedApplicationGraphEvidence } from "../../application/managed/ManagedApplicationGraphService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
 const graphContract = managedWorkflowContract("project_managed_application_graph");
@@ -13,17 +12,17 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
             ? undefined
             : resolveManagedArtifactEvidence(input.managed_artifact);
         if (managedArtifact !== undefined && !managedArtifact.ok)
-            return toCallToolResult(managedArtifact, graphContract);
+            return server.delivery.toCallToolResult(managedArtifact, graphContract);
         const managedMembers = input.managed_members === undefined
             ? undefined
             : resolveManagedEvidence(input.managed_members);
         if (managedMembers !== undefined && !managedMembers.ok)
-            return toCallToolResult(managedMembers, graphContract);
+            return server.delivery.toCallToolResult(managedMembers, graphContract);
         const managedBoundaries = input.managed_native_boundaries === undefined
             ? undefined
             : resolveManagedBoundaryEvidence(input.managed_native_boundaries);
         if (managedBoundaries !== undefined && !managedBoundaries.ok)
-            return toCallToolResult(managedBoundaries, graphContract);
+            return server.delivery.toCallToolResult(managedBoundaries, graphContract);
         const parsed = {
             managed_artifact: managedArtifact?.value[0],
             managed_members: managedMembers?.value[0],
@@ -31,13 +30,11 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
         };
         const result = await logToolExecution(options.logger, graphContract.name, () => Promise.resolve(projectManagedApplicationGraphEvidence(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, graphContract);
+            return server.delivery.toCallToolResult(result, graphContract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, sourceEvidence(parsed));
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, graphContract);
+            return server.delivery.toCallToolResult(recordedSources, graphContract);
         const recorded = options.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, graphContract);
-        return toCallToolResult(result, graphContract);
+        return server.delivery.toEvidenceToolResult(result.value, graphContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,9 +1,8 @@
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { verifyManagedNativeBoundariesEvidence } from "../../application/managed/ManagedNativeVerificationService.js";
-import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerification.js";
+import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerificationSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
 const nativeVerificationContract = managedWorkflowContract("verify_managed_native_boundaries");
@@ -12,10 +11,10 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
     server.registerTool(nativeVerificationContract.name, toolRegistrationOptions(nativeVerificationContract), async (input) => {
         const managedBoundaries = resolveManagedBoundaryEvidence(input.managed_boundaries);
         if (!managedBoundaries.ok)
-            return toCallToolResult(managedBoundaries, nativeVerificationContract);
+            return server.delivery.toCallToolResult(managedBoundaries, nativeVerificationContract);
         const nativeObservations = resolveNativeEvidence(input.native_observations);
         if (!nativeObservations.ok)
-            return toCallToolResult(nativeObservations, nativeVerificationContract);
+            return server.delivery.toCallToolResult(nativeObservations, nativeVerificationContract);
         const managedBoundary = managedBoundaries.value[0];
         if (managedBoundary === undefined)
             throw new TypeError("Managed boundary Evidence resolution failed");
@@ -26,10 +25,10 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
         };
         const result = await logToolExecution(options.logger, nativeVerificationContract.name, () => Promise.resolve(verifyManagedNativeBoundariesEvidence(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, nativeVerificationContract);
+            return server.delivery.toCallToolResult(result, nativeVerificationContract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, [parsed.managed_boundaries, ...parsed.native_observations]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, nativeVerificationContract);
+            return server.delivery.toCallToolResult(recordedSources, nativeVerificationContract);
         const verification = managedNativeVerificationResultSchema.parse(result.value.normalized_result);
         const unknown = verification.summary.unresolved > 0 ||
             verification.summary.contradicted > 0 ||
@@ -57,8 +56,6 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
                 relationships: [],
             })
             : options.recordEvidence?.(result.value);
-        if (output !== undefined && !output.ok)
-            return toCallToolResult(output, nativeVerificationContract);
-        return toCallToolResult(result, nativeVerificationContract);
+        return server.delivery.toEvidenceToolResult(result.value, nativeVerificationContract, output);
     });
 };

package/dist/server/registerOfficialTools.js

@@ -1,11 +1,9 @@
-import { z } from "zod";
 import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/officialToolContracts.js";
 import { createEvidence } from "../domain/evidence.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register direct bridge proxies, preserving MCP cancellation and typed errors. */
 export const registerOfficialTools = (server, analysis, options) => {
     for (const contract of OFFICIAL_TOOL_CONTRACTS) {
@@ -18,7 +16,7 @@ export const registerOfficialTools = (server, analysis, options) => {
 };
 const registerOfficialTool = (server, analysis, contract, registration) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const arguments_ = projectOfficialArguments(contract, input);
+        const arguments_ = jsonObjectSchema.parse(contract.inputSchema.parse(input));
         const progress = mcpProgressReporter(context);
         const result = await runOfficialOperation(analysis, contract, arguments_, {
             logger: registration.logger,
@@ -26,7 +24,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             progress,
         });
         if (!result.ok) {
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         }
         const evidence = createEvidence(result.value.subject ?? registration.activeTarget?.(), result.value.provider, {
             operation: contract.name,
@@ -40,9 +38,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             locations: result.value.locations,
         });
         const recorded = registration.recordEvidence?.(evidence);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const runOfficialOperation = async (analysis, contract, arguments_, execution) => {
@@ -65,16 +61,3 @@ const runOfficialOperation = async (analysis, contract, arguments_, execution) =
     });
     return result;
 };
-const projectOfficialArguments = (contract, input) => {
-    // Annotation omissions preserve existing values; they are not Python defaults.
-    if (contract.name === "annotate_native_function")
-        return jsonObjectSchema.parse(contract.inputSchema.parse(input));
-    const parsed = jsonObjectSchema.parse(input);
-    if (!(contract.inputSchema instanceof z.ZodObject))
-        throw new TypeError("Official tool input contract must be an object schema");
-    const projected = {};
-    for (const key of Object.keys(contract.inputSchema.shape)) {
-        projected[key] = jsonValueSchema.parse(parsed[key] ?? null);
-    }
-    return projected;
-};

package/dist/server/registerProcessComparisonTool.js

@@ -1,61 +1,83 @@
 import { toolContract } from "../contracts/toolContracts.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
+import { describeValidationFailure } from "../domain/evidenceBundle.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/process/processCapture.js";
-import { err } from "../domain/result.js";
+import { compareProcessCaptures } from "../domain/process/processComparison.js";
+import { parseProcessCapture, } from "../domain/process/processCaptureParsing.js";
+import { err, ok } from "../domain/result.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
+import { PROCESS_PROVIDER } from "../domain/process/processEvidenceProvider.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 const PROCESS_CAPTURE_EVIDENCE = {
     operation: "capture_process_scenario",
     predicate: "rea.process-capture",
 };
 const sourceLocations = (left, right) => [...(left ?? []), ...(right ?? [])];
+/**
+ * Parse one side and name the failed constraint: tampered Evidence, Evidence
+ * from another workflow, or an invalid capture result.
+ */
+const parseCaptureSide = (operation, side, value) => {
+    let record;
+    try {
+        record = parseEvidence(value);
+    }
+    catch (cause) {
+        return err(new EvidenceIntegrityError(`${side} Evidence failed validation`, {
+            cause,
+            userMessage: `The ${side} Evidence failed validation (${describeValidationFailure(cause)}). Supply unmodified capture Evidence from capture_process_scenario.`,
+        }));
+    }
+    if (record.operation !== PROCESS_CAPTURE_EVIDENCE.operation ||
+        record.predicate_type !== PROCESS_CAPTURE_EVIDENCE.predicate)
+        return err(new AnalysisInputError(operation, undefined, [
+            {
+                path: [side],
+                reason: "invalid_value",
+                message: `Expected process capture Evidence (operation ${PROCESS_CAPTURE_EVIDENCE.operation}, predicate ${PROCESS_CAPTURE_EVIDENCE.predicate}); the ${side} Evidence has operation ${record.operation} and predicate ${record.predicate_type}.`,
+            },
+        ]));
+    try {
+        return ok({
+            record,
+            capture: parseProcessCapture(record.normalized_result),
+        });
+    }
+    catch (cause) {
+        return err(new EvidenceIntegrityError(`${side} process capture failed validation`, {
+            cause,
+            userMessage: `The ${side} Evidence has an invalid process capture result (${describeValidationFailure(cause)}). Recreate the capture with capture_process_scenario.`,
+        }));
+    }
+};
 /** Register deterministic process-capture comparison and contradiction tracking. */
 export const registerProcessComparisonTool = (server, session, contract, now = Date.now) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        let leftRecord;
-        let rightRecord;
-        try {
-            leftRecord = parseEvidence(input.left);
-            rightRecord = parseEvidence(input.right);
-            if (leftRecord.operation !== PROCESS_CAPTURE_EVIDENCE.operation ||
-                rightRecord.operation !== PROCESS_CAPTURE_EVIDENCE.operation ||
-                leftRecord.predicate_type !== PROCESS_CAPTURE_EVIDENCE.predicate ||
-                rightRecord.predicate_type !== PROCESS_CAPTURE_EVIDENCE.predicate)
-                throw new TypeError("Expected process capture Evidence");
-        }
-        catch (cause) {
-            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
-        }
-        let comparison;
-        let leftCapture;
-        let rightCapture;
-        try {
-            leftCapture = parseProcessCapture(leftRecord.normalized_result);
-            rightCapture = parseProcessCapture(rightRecord.normalized_result);
-            const computed = await runDerivedOperation(context, contract.name, () => compareProcessCaptures(leftCapture, rightCapture, {
-                ...(input.max_capture_age_ms === undefined
-                    ? {}
-                    : { maxCaptureAgeMs: input.max_capture_age_ms }),
-                ...(input.trace_spec === undefined
-                    ? {}
-                    : { traceSpecification: input.trace_spec }),
-                now,
-            }));
-            if (!computed.ok)
-                return toCallToolResult(computed, contract);
-            comparison = computed.value;
-        }
-        catch (cause) {
-            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error
-                ? cause.message
-                : "Invalid process capture")), contract);
-        }
+        const left = parseCaptureSide(contract.name, "left", input.left);
+        if (!left.ok)
+            return server.delivery.toCallToolResult(left, contract);
+        const right = parseCaptureSide(contract.name, "right", input.right);
+        if (!right.ok)
+            return server.delivery.toCallToolResult(right, contract);
+        const { record: leftRecord, capture: leftCapture } = left.value;
+        const { record: rightRecord, capture: rightCapture } = right.value;
+        const computed = await runDerivedOperation(context, contract.name, () => compareProcessCaptures(leftCapture, rightCapture, {
+            ...(input.max_capture_age_ms === undefined
+                ? {}
+                : { maxCaptureAgeMs: input.max_capture_age_ms }),
+            ...(input.trace_spec === undefined
+                ? {}
+                : { traceSpecification: input.trace_spec }),
+            now,
+        }));
+        if (!computed.ok)
+            return server.delivery.toCallToolResult(computed, contract);
+        const comparison = computed.value;
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
             predicateType: "rea.process-comparison",
             operation: contract.name,
@@ -77,12 +99,12 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         });
         const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftRecord, rightRecord]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
-        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput({
+            return server.delivery.toCallToolResult(recordedSources, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, comparisonUnknownInput({
             left_evidence_id: leftRecord.evidence_id,
             right_evidence_id: rightRecord.evidence_id,
             comparison_evidence_id: evidence.evidence_id,
-        }, comparison)), contract);
+        }, comparison)));
     });
 };
 const comparisonUnknownInput = (parsed, comparison) => {
@@ -98,14 +120,18 @@ const comparisonUnknownInput = (parsed, comparison) => {
         .filter(([, status]) => status !== "unchanged")
         .map(([scope]) => scope)
         .join(", ");
+    const contradictory = comparison.status === "changed" &&
+        parsed.left_evidence_id !== parsed.right_evidence_id;
     // Unknown identity uses the question, not its supporting records. Bind the
     // question to this comparison so distinct capture pairs and policies coexist.
     return {
-        question: `Process captures disagree across: ${differingScopes} (comparison ${parsed.comparison_evidence_id})`,
+        question: `${contradictory ? "Process captures disagree" : `Process comparison is ${comparison.status}`} across: ${differingScopes} (comparison ${parsed.comparison_evidence_id})`,
         severity: "high",
         domain: "process-comparison",
-        supporting_evidence_ids: [parsed.left_evidence_id],
-        contradicting_evidence_ids: [parsed.right_evidence_id],
+        supporting_evidence_ids: contradictory
+            ? [parsed.left_evidence_id]
+            : [...new Set([parsed.left_evidence_id, parsed.right_evidence_id])],
+        contradicting_evidence_ids: contradictory ? [parsed.right_evidence_id] : [],
         required_authority: "controlled-replay",
         required_confidence: "observed",
         required_environment: null,

package/dist/server/registerRecordedCrashTools.js

@@ -1,17 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Bind recorded crash inspection to its named contract and session Evidence owner. */
 export const registerRecordedCrashTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_recorded_crash");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(logger, contract.name, () => service.inspect(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };