rea-agents 6.0.0 → 6.1.0

package/dist/server/registerEnhancedTools.js

@@ -1,12 +1,10 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
-import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
+import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "../application/WorkflowEvidence.js";
 import { toolContract } from "../contracts/toolContracts.js";
-import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
-import { createEvidence } from "../domain/evidence.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 import { executeFunctionAnalysisEvidence } from "../application/FunctionAnalysisEvidence.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
@@ -114,24 +112,25 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
         terminal: true,
     });
     if (result.ok) {
-        const upstreamProfile = registration.analysisProfile?.();
-        const evidence = createEvidence(registration.activeTarget?.(), REA_WORKFLOW_PROVIDER, {
+        const evidence = createWorkflowEvidence({
+            target: registration.activeTarget?.(),
             operation: name,
             parameters,
             result: result.value,
-            ...(upstreamProfile === undefined
-                ? {}
-                : {
-                    analysisProfile: workflowAnalysisProfile(upstreamProfile),
-                }),
-            confidence: "derived",
-            limitations: [
-                "Derived by an REA workflow from one or more provider observations.",
-            ],
+            upstreamProfile: registration.analysisProfile?.(),
         });
         const recorded = registration.recordEvidence?.(evidence);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, contract);
+        if (name !== "trace_native_ui_action" &&
+            registration.allowsSnapshotReplay?.(name) === true) {
+            const workflowRecord = workflowSnapshotRecord(evidence, name);
+            if (workflowRecord !== undefined) {
+                const snapshot = registration.recordWorkflowSnapshot?.(workflowRecord);
+                if (snapshot !== undefined && !snapshot.ok)
+                    return toCallToolResult(snapshot, contract);
+            }
+        }
         const unknowns = recordWorkflowUnknowns({
             name,
             result: result.value,
@@ -140,7 +139,7 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
         });
         if (!unknowns.ok)
             return toCallToolResult(unknowns, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract);
+        return toEvidenceToolResult(evidence, contract, recorded);
     }
     return toCallToolResult(result, contract);
 };
@@ -158,48 +157,8 @@ const executeFunctionTool = async (analysis, registration, contract, request) =>
         message: result.ok ? "completed" : "failed",
         terminal: true,
     });
-    if (result.ok) {
-        const recorded = registration.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, contract);
-    }
-    return toCallToolResult(result, contract);
+    if (!result.ok)
+        return toCallToolResult(result, contract);
+    return toEvidenceToolResult(result.value, contract, registration.recordEvidence?.(result.value));
 };
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
-const recordWorkflowUnknowns = ({ name, result, evidenceId, recordUnknown, }) => {
-    if (!["trace_feature", "trace_call_path", "inspect_native_api"].includes(name) ||
-        recordUnknown === undefined ||
-        typeof result !== "object" ||
-        result === null ||
-        Array.isArray(result) ||
-        !Array.isArray(result.residual_unknowns))
-        return { ok: true, value: null };
-    for (const question of result.residual_unknowns) {
-        if (typeof question !== "string")
-            continue;
-        const recorded = recordUnknown({
-            question,
-            severity: "medium",
-            domain: name === "inspect_native_api" ? "native-api" : "control-flow",
-            supporting_evidence_ids: [evidenceId],
-            contradicting_evidence_ids: [],
-            required_authority: "shipped-artifact",
-            required_confidence: "observed",
-            required_environment: null,
-            recommended_probes: [
-                {
-                    operation: name,
-                    rationale: name === "inspect_native_api"
-                        ? "Confirm the unsupported boundary with a capable provider or ABI probe."
-                        : "Continue with a focused query or another available provider.",
-                },
-            ],
-            relationships: [],
-        });
-        if (!recorded.ok &&
-            !(recorded.error instanceof UnknownRegistryError &&
-                recorded.error.reason === "already-exists"))
-            return recorded;
-    }
-    return { ok: true, value: null };
-};

package/dist/server/registerEvidenceTools.js

@@ -3,7 +3,7 @@ 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";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 import { createArtifactExtractionDestination } from "../application/artifacts/ArtifactExtractionDestination.js";
 /** Register provider-backed contracts that return atomic Evidence observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
@@ -55,9 +55,7 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                     return toCallToolResult(sourceRecorded, contract);
             }
             const recorded = options.recordEvidence?.(evidence);
-            return recorded !== undefined && !recorded.ok
-                ? toCallToolResult(recorded, contract)
-                : toCallToolResult({ ok: true, value: evidence }, contract);
+            return toEvidenceToolResult(evidence, contract, recorded);
         });
     }
 };

package/dist/server/registerEvmTools.js

@@ -1,7 +1,7 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind the named EVM contract to shared validation and session Evidence recording. */
 export const registerEvmTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_evm_interface");
@@ -10,8 +10,6 @@ export const registerEvmTools = (server, service, logger, recordEvidence) => {
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerFirmwareTools.js

@@ -1,7 +1,7 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind firmware handlers to their exact named schemas. */
 export const registerFirmwareTools = (server, service, logger, recordEvidence) => {
     const handler = (contract) => async (input, context) => {
@@ -11,9 +11,7 @@ export const registerFirmwareTools = (server, service, logger, recordEvidence) =
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     };
     const inspect = toolContract("inspect_firmware_regions");
     server.registerTool(inspect.name, toolRegistrationOptions(inspect), handler(inspect));

package/dist/server/registerFunctionComparisonTool.js

@@ -9,7 +9,7 @@ import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register explicit Evidence-backed function comparison. */
 export const registerFunctionComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -53,19 +53,23 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             status: comparison.status,
             leftIds,
             rightIds,
+            comparisonEvidenceId: evidence.evidence_id,
         }));
-        return toCallToolResult(recorded, contract);
+        return toEvidenceToolResult(evidence, contract, recorded);
     });
 };
-const functionUnknownInput = ({ status, leftIds, rightIds, }) => {
+const functionUnknownInput = ({ status, leftIds, rightIds, comparisonEvidenceId, }) => {
     if (status === "unchanged")
         return undefined;
+    const supportingIds = [...new Set([...leftIds, ...rightIds])];
+    const contradictingIds = rightIds.filter((id) => !leftIds.includes(id));
+    const contradictory = status === "changed";
     return {
-        question: `Function comparison is ${status}`,
+        question: `Function comparison is ${status} (comparison ${comparisonEvidenceId})`,
         severity: status === "changed" ? "medium" : "high",
         domain: "function-comparison",
-        supporting_evidence_ids: [...leftIds],
-        contradicting_evidence_ids: [...rightIds],
+        supporting_evidence_ids: contradictory ? [...leftIds] : supportingIds,
+        contradicting_evidence_ids: contradictory ? contradictingIds : [],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,

package/dist/server/registerInvestigationTools.js

@@ -9,7 +9,7 @@ import { comparisonClosure, evidenceClosure, functionEvidenceIds, isIncomplete,
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register Evidence-composed differential investigation workflows. */
 export const registerInvestigationTools = (server, session) => {
     registerChangedBehavior(server, session, toolContract("find_changed_behavior"));
@@ -51,7 +51,7 @@ const registerChangedBehavior = (server, session, contract) => {
                 },
             ],
         });
-        return toCallToolResult(recorded, contract);
+        return toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerCallPath = (server, session, contract) => {
@@ -89,7 +89,7 @@ const registerCallPath = (server, session, contract) => {
                 },
             ],
         });
-        return toCallToolResult(recorded, contract);
+        return toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerStaticRuntime = (server, session, contract) => {
@@ -117,7 +117,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
+        return 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 +128,7 @@ const registerStaticRuntime = (server, session, contract) => {
                     rationale: "Repeat runtime observations and complete the mapped static comparison Evidence.",
                 },
             ],
-        }), contract);
+        }));
     });
 };
 const registerReconstruction = (server, session, contract) => {
@@ -155,7 +155,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown", {
+        return toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,
@@ -164,6 +164,6 @@ const registerReconstruction = (server, session, contract) => {
                 operation,
                 rationale,
             })),
-        }), contract);
+        }));
     });
 };

package/dist/server/registerJavaScriptRecoveryTool.js

@@ -1,7 +1,7 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } 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");
@@ -10,8 +10,6 @@ export const registerJavaScriptRecoveryTool = (server, service, logger, recordEv
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -5,7 +5,7 @@ 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";
+import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register passive Inspector tools even when policy keeps them unavailable. */
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
     const listContract = toolContract("list_javascript_runtime_targets");
@@ -24,7 +24,5 @@ const runRuntimeTool = async (options, contract, request, execute) => {
     if (!result.ok)
         return 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 toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -3,7 +3,7 @@ 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 { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const compareContract = managedWorkflowContract("compare_managed_members");
@@ -51,8 +51,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 toEvidenceToolResult(result.value, compareContract, output);
     });
 };

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -1,7 +1,7 @@
 import { importManagedReconstructionEvidenceValidated } from "../../application/managed/ManagedReconstructionService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const reconstructionContract = managedWorkflowContract("import_managed_reconstruction");
@@ -22,8 +22,6 @@ export const registerImportManagedReconstruction = (server, options) => {
         if (recordedSource !== undefined && !recordedSource.ok)
             return toCallToolResult(recordedSource, reconstructionContract);
         const recorded = options.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, reconstructionContract);
-        return toCallToolResult(result, reconstructionContract);
+        return toEvidenceToolResult(result.value, reconstructionContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -2,7 +2,7 @@ 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 { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
 const graphContract = managedWorkflowContract("project_managed_application_graph");
@@ -36,8 +36,6 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
         if (!recordedSources.ok)
             return toCallToolResult(recordedSources, graphContract);
         const recorded = options.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, graphContract);
-        return toCallToolResult(result, graphContract);
+        return toEvidenceToolResult(result.value, graphContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -3,7 +3,7 @@ import { verifyManagedNativeBoundariesEvidence } from "../../application/managed
 import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerification.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
 const nativeVerificationContract = managedWorkflowContract("verify_managed_native_boundaries");
@@ -57,8 +57,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 toEvidenceToolResult(result.value, nativeVerificationContract, output);
     });
 };

package/dist/server/registerOfficialTools.js

@@ -5,7 +5,7 @@ import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } 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) {
@@ -40,9 +40,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 toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const runOfficialOperation = async (analysis, contract, arguments_, execution) => {

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 { 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 { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } 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 toCallToolResult(left, contract);
+        const right = parseCaptureSide(contract.name, "right", input.right);
+        if (!right.ok)
+            return 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 toCallToolResult(computed, contract);
+        const comparison = computed.value;
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
             predicateType: "rea.process-comparison",
             operation: contract.name,
@@ -78,11 +100,11 @@ 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 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,7 +1,7 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { toCallToolResult, toEvidenceToolResult } 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");
@@ -10,8 +10,6 @@ export const registerRecordedCrashTools = (server, service, logger, recordEviden
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerSessionRecordTools.js

@@ -11,7 +11,7 @@ export const registerEvidenceTools = (registration) => {
 };
 const registerExportEvidenceTool = ({ server, session, exportContract, }) => {
     server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
-        const bundle = session.exportEvidenceBundle();
+        const bundle = bundleForSerialization(session);
         const written = await writeEvidenceBundle(bundle, input.path, input.overwrite);
         return written.ok
             ? toCallToolResult(ok({
@@ -24,7 +24,7 @@ const registerExportEvidenceTool = ({ server, session, exportContract, }) => {
     });
 };
 const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) => {
-    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => toCallToolResult(ok(session.exportEvidenceBundle()), snapshotContract));
+    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => toCallToolResult(ok(bundleForSerialization(session)), snapshotContract));
 };
 const registerImportEvidenceTool = ({ server, session, importContract, }) => {
     server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
@@ -32,19 +32,18 @@ const registerImportEvidenceTool = ({ server, session, importContract, }) => {
         const loaded = await readEvidenceBundle(path);
         if (!loaded.ok)
             return toCallToolResult(loaded, importContract);
-        const retainedUnknownRevisions = new Set(session
-            .exportEvidenceBundle()
-            .unknowns.map((unknown) => unknownRevisionKey(unknown)));
+        const retainedUnknownRevisions = new Set(bundleForSerialization(session).unknowns.map((unknown) => unknownRevisionKey(unknown)));
         const imported = session.importEvidenceBundle(loaded.value);
         return imported.ok
             ? toCallToolResult(ok({
                 imported: imported.value,
                 unknowns_added: loaded.value.unknowns.filter((unknown) => !retainedUnknownRevisions.has(unknownRevisionKey(unknown))).length,
-                total: session.exportEvidenceBundle().records.length,
+                total: bundleForSerialization(session).records.length,
             }), importContract)
             : toCallToolResult(imported, importContract);
     });
 };
+const bundleForSerialization = (session) => session.evidenceBundleForSerialization?.() ?? session.exportEvidenceBundle();
 const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
 /** Register residual-unknown query and mutation tools. */
 const registerListUnknownsTool = ({ server, session, }) => {