rea-agents 3.1.0 → 3.2.1

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -1,29 +1,30 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareManagedMembersEvidenceValidated } from "../../application/ManagedMemberComparisonService.js";
 import { managedMemberComparisonResultSchema } from "../../domain/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
-import { recordManagedSources, resolveManagedEvidence } from "./evidence.js";
+import { resolveManagedEvidence } from "./evidence.js";
 const compareContract = managedWorkflowContract("compare_managed_members");
 /** Register the managed member comparison workflow tool. */
 export const registerCompareManagedMembers = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const resolved = resolveManagedEvidence(options.session, [
-            input.left_evidence_id,
-            input.right_evidence_id,
-        ]);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, compareContract);
-        const [left, right] = resolved.value;
+        const leftResolved = resolveManagedEvidence(input.left);
+        const rightResolved = resolveManagedEvidence(input.right);
+        if (!leftResolved.ok)
+            return toCallToolResult(leftResolved, compareContract);
+        if (!rightResolved.ok)
+            return toCallToolResult(rightResolved, compareContract);
+        const [left] = leftResolved.value;
+        const [right] = rightResolved.value;
         if (left === undefined || right === undefined)
             throw new TypeError("Managed comparison Evidence resolution failed");
-        const { left_evidence_id: _leftEvidenceId, right_evidence_id: _rightEvidenceId, ...referencedInput } = input;
-        const parsed = { ...referencedInput, left, right };
+        const parsed = { left, right };
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareManagedMembersEvidenceValidated(parsed)));
         if (!result.ok)
             return toCallToolResult(result, compareContract);
-        const recorded = recordManagedSources(options.recordEvidence, [
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
@@ -31,9 +32,8 @@ export const registerCompareManagedMembers = (server, options) => {
             return toCallToolResult(recorded, compareContract);
         const comparison = managedMemberComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        const output = parsed.unknown_registry_approved === true && unknown
+        const output = unknown
             ? options.recordEvidenceWithUnknown?.(result.value, {
-                approved: true,
                 question: "Which managed members remain unmatched or ambiguous across these versions?",
                 severity: "medium",
                 domain: "managed-member-comparison",
@@ -45,7 +45,7 @@ export const registerCompareManagedMembers = (server, options) => {
                 recommended_probes: [
                     {
                         operation: "inspect_managed_members",
-                        rationale: "Repeat static member inspection with complete pages and method bodies.",
+                        rationale: "Review the inspection Evidence coverage and limit diagnostics; this operation has no page override, so unresolved members must remain unknown.",
                     },
                 ],
                 relationships: [],
@@ -53,8 +53,6 @@ export const registerCompareManagedMembers = (server, options) => {
             : options.recordEvidence?.(result.value);
         if (output !== undefined && !output.ok)
             return toCallToolResult(output, compareContract);
-        return toCallToolResult({ ok: true, value: result.value }, compareContract, {
-            evidenceResourcesAvailable: output !== undefined,
-        });
+        return toCallToolResult({ ok: true, value: result.value }, compareContract);
     });
 };

package/dist/server/registerManagedWorkflowTools/evidence.js

@@ -1,40 +1,24 @@
-import { resolveSessionEvidenceIds } from "../sessionEvidence.js";
-export const resolveManagedEvidence = (session, evidenceIds) => resolveSessionEvidenceIds(session, evidenceIds, {
-    operation: "inspect_managed_members",
-    predicate: "rea.analysis/v2",
-});
-export const resolveManagedArtifactEvidence = (session, evidenceId) => resolveSessionEvidenceIds(session, [evidenceId], {
-    operation: "inspect_managed_artifact",
-    predicate: "rea.analysis/v2",
-});
-export const resolveManagedBoundaryEvidence = (session, evidenceId) => resolveSessionEvidenceIds(session, [evidenceId], {
-    operation: "inspect_managed_native_boundaries",
-    predicate: "rea.analysis/v2",
-});
-export const resolveNativeEvidence = (session, evidenceIds) => {
-    const records = [];
-    for (const evidenceId of evidenceIds) {
-        const operation = session.evidenceById(evidenceId)?.operation;
-        const expectedOperation = operation === "inspect_macho" || operation === "analyze_function"
-            ? operation
-            : "inspect_macho or analyze_function";
-        const resolved = resolveSessionEvidenceIds(session, [evidenceId], {
-            operation: expectedOperation,
-            predicate: "rea.analysis/v2",
-        });
-        if (!resolved.ok)
-            return resolved;
-        records.push(...resolved.value);
+import { parseEvidence } from "../../domain/evidence.js";
+import { EvidenceIntegrityError } from "../../domain/errors.js";
+import { err, ok } from "../../domain/result.js";
+const parseExpectedEvidence = (rawEvidence, expectedOperations) => {
+    try {
+        const evidence = rawEvidence.map(parseEvidence);
+        for (const record of evidence)
+            if (!expectedOperations.includes(record.operation) ||
+                record.predicate_type !== "rea.analysis")
+                throw new TypeError(`Expected ${expectedOperations.join(" or ")} Evidence, received ${record.operation}`);
+        return ok(evidence);
     }
-    return { ok: true, value: records };
-};
-export const recordManagedSources = (recordEvidence, sources) => {
-    for (const source of sources) {
-        const recorded = recordEvidence?.(source);
-        if (recorded !== undefined && !recorded.ok)
-            return recorded;
+    catch (cause) {
+        return err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence"));
     }
-    return { ok: true, value: null };
+};
+export const resolveManagedEvidence = (evidence) => parseExpectedEvidence([evidence], ["inspect_managed_members"]);
+export const resolveManagedArtifactEvidence = (evidence) => parseExpectedEvidence([evidence], ["inspect_managed_artifact"]);
+export const resolveManagedBoundaryEvidence = (evidence) => parseExpectedEvidence([evidence], ["inspect_managed_native_boundaries"]);
+export const resolveNativeEvidence = (evidence) => {
+    return parseExpectedEvidence(evidence, ["inspect_macho", "analyze_function"]);
 };
 export const sourceEvidence = (input) => [
     input.managed_artifact,

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -8,16 +8,13 @@ const reconstructionContract = managedWorkflowContract("import_managed_reconstru
 /** Register the managed reconstruction import workflow tool. */
 export const registerImportManagedReconstruction = (server, options) => {
     server.registerTool(reconstructionContract.name, toolRegistrationOptions(reconstructionContract), async (input) => {
-        const resolved = resolveManagedEvidence(options.session, [
-            input.static_members_evidence_id,
-        ]);
+        const resolved = resolveManagedEvidence(input.static_members);
         if (!resolved.ok)
             return toCallToolResult(resolved, reconstructionContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed reconstruction Evidence resolution failed");
-        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = input;
-        const parsed = { ...referencedInput, static_members: staticMembers };
+        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);
@@ -27,8 +24,6 @@ export const registerImportManagedReconstruction = (server, options) => {
         const recorded = options.recordEvidence?.(result.value);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, reconstructionContract);
-        return toCallToolResult(result, reconstructionContract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult(result, reconstructionContract);
     });
 };

package/dist/server/registerManagedWorkflowTools/planManagedRuntimeCorrelation.js

@@ -8,16 +8,13 @@ const runtimeContract = managedWorkflowContract("plan_managed_runtime_correlatio
 /** Register the managed runtime correlation planning workflow tool. */
 export const registerPlanManagedRuntimeCorrelation = (server, options) => {
     server.registerTool(runtimeContract.name, toolRegistrationOptions(runtimeContract), async (input) => {
-        const resolved = resolveManagedEvidence(options.session, [
-            input.static_members_evidence_id,
-        ]);
+        const resolved = resolveManagedEvidence(input.static_members);
         if (!resolved.ok)
             return toCallToolResult(resolved, runtimeContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed runtime Evidence resolution failed");
-        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = input;
-        const parsed = { ...referencedInput, static_members: staticMembers };
+        const parsed = { ...input, static_members: staticMembers };
         const result = await logToolExecution(options.logger, runtimeContract.name, () => Promise.resolve(planManagedRuntimeCorrelationEvidenceValidated(options.runtime, parsed)));
         if (!result.ok)
             return toCallToolResult(result, runtimeContract);
@@ -27,8 +24,6 @@ export const registerPlanManagedRuntimeCorrelation = (server, options) => {
         const recorded = options.recordEvidence?.(result.value);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, runtimeContract);
-        return toCallToolResult(result, runtimeContract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult(result, runtimeContract);
     });
 };

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -1,32 +1,30 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { projectManagedApplicationGraphEvidence } from "../../application/ManagedApplicationGraphService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
-import { recordManagedSources, resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
+import { resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
 const graphContract = managedWorkflowContract("project_managed_application_graph");
 /** Register the managed application graph projection workflow tool. */
 export const registerProjectManagedApplicationGraph = (server, options) => {
     server.registerTool(graphContract.name, toolRegistrationOptions(graphContract), async (input) => {
-        const managedArtifact = input.managed_artifact_evidence_id === undefined
+        const managedArtifact = input.managed_artifact === undefined
             ? undefined
-            : resolveManagedArtifactEvidence(options.session, input.managed_artifact_evidence_id);
+            : resolveManagedArtifactEvidence(input.managed_artifact);
         if (managedArtifact !== undefined && !managedArtifact.ok)
             return toCallToolResult(managedArtifact, graphContract);
-        const managedMembers = input.managed_members_evidence_id === undefined
+        const managedMembers = input.managed_members === undefined
             ? undefined
-            : resolveManagedEvidence(options.session, [
-                input.managed_members_evidence_id,
-            ]);
+            : resolveManagedEvidence(input.managed_members);
         if (managedMembers !== undefined && !managedMembers.ok)
             return toCallToolResult(managedMembers, graphContract);
-        const managedBoundaries = input.managed_native_boundaries_evidence_id === undefined
+        const managedBoundaries = input.managed_native_boundaries === undefined
             ? undefined
-            : resolveManagedBoundaryEvidence(options.session, input.managed_native_boundaries_evidence_id);
+            : resolveManagedBoundaryEvidence(input.managed_native_boundaries);
         if (managedBoundaries !== undefined && !managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, graphContract);
         const parsed = {
-            limits: input.limits,
             managed_artifact: managedArtifact?.value[0],
             managed_members: managedMembers?.value[0],
             managed_native_boundaries: managedBoundaries?.value[0],
@@ -34,14 +32,12 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
         const result = await logToolExecution(options.logger, graphContract.name, () => Promise.resolve(projectManagedApplicationGraphEvidence(parsed)));
         if (!result.ok)
             return toCallToolResult(result, graphContract);
-        const recordedSources = recordManagedSources(options.recordEvidence, sourceEvidence(parsed));
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, sourceEvidence(parsed));
         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, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult(result, graphContract);
     });
 };

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,45 +1,41 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { verifyManagedNativeBoundariesEvidence } from "../../application/ManagedNativeVerificationService.js";
 import { managedNativeVerificationResultSchema } from "../../domain/managedNativeVerification.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
-import { recordManagedSources, resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
+import { resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
 const nativeVerificationContract = managedWorkflowContract("verify_managed_native_boundaries");
 /** Register the managed/native boundary verification workflow tool. */
 export const registerVerifyManagedNativeBoundaries = (server, options) => {
     server.registerTool(nativeVerificationContract.name, toolRegistrationOptions(nativeVerificationContract), async (input) => {
-        const managedBoundaries = resolveManagedBoundaryEvidence(options.session, input.managed_boundaries_evidence_id);
+        const managedBoundaries = resolveManagedBoundaryEvidence(input.managed_boundaries);
         if (!managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, nativeVerificationContract);
-        const nativeObservations = resolveNativeEvidence(options.session, input.native_observation_evidence_ids);
+        const nativeObservations = resolveNativeEvidence(input.native_observations);
         if (!nativeObservations.ok)
             return toCallToolResult(nativeObservations, nativeVerificationContract);
         const managedBoundary = managedBoundaries.value[0];
         if (managedBoundary === undefined)
             throw new TypeError("Managed boundary Evidence resolution failed");
-        const { managed_boundaries_evidence_id: _managedBoundariesEvidenceId, native_observation_evidence_ids: _nativeObservationEvidenceIds, ...referencedInput } = input;
         const parsed = {
-            ...referencedInput,
+            ...input,
             managed_boundaries: managedBoundary,
             native_observations: nativeObservations.value,
         };
         const result = await logToolExecution(options.logger, nativeVerificationContract.name, () => Promise.resolve(verifyManagedNativeBoundariesEvidence(parsed)));
         if (!result.ok)
             return toCallToolResult(result, nativeVerificationContract);
-        const recordedSources = recordManagedSources(options.recordEvidence, [
-            parsed.managed_boundaries,
-            ...parsed.native_observations,
-        ]);
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, [parsed.managed_boundaries, ...parsed.native_observations]);
         if (!recordedSources.ok)
             return toCallToolResult(recordedSources, nativeVerificationContract);
         const verification = managedNativeVerificationResultSchema.parse(result.value.normalized_result);
         const unknown = verification.summary.unresolved > 0 ||
             verification.summary.contradicted > 0 ||
             verification.summary.native_body_unresolved > 0;
-        const output = parsed.unknown_registry_approved === true && unknown
+        const output = unknown
             ? options.recordEvidenceWithUnknown?.(result.value, {
-                approved: true,
                 question: "Which managed/native boundaries remain unresolved or contradicted by the supplied native Evidence?",
                 severity: "medium",
                 domain: "managed-native-verification",
@@ -51,7 +47,7 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
                 recommended_probes: [
                     {
                         operation: "inspect_managed_native_boundaries",
-                        rationale: "Repeat managed boundary inspection with complete ModuleRef, ImplMap, and native implementation pages.",
+                        rationale: "Review the inspection Evidence coverage and limit diagnostics; this operation has no page override, so unresolved declarations must remain unknown.",
                     },
                     {
                         operation: "analyze_function",
@@ -63,8 +59,6 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
             : options.recordEvidence?.(result.value);
         if (output !== undefined && !output.ok)
             return toCallToolResult(output, nativeVerificationContract);
-        return toCallToolResult(result, nativeVerificationContract, {
-            evidenceResourcesAvailable: output !== undefined,
-        });
+        return toCallToolResult(result, nativeVerificationContract);
     });
 };

package/dist/server/registerOfficialTools.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { AnalysisCapabilityUnavailableError, UnknownRegistryError, } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
@@ -14,7 +13,6 @@ export const registerOfficialTools = (server, analysis, options) => {
             logger: options.logger,
             activeTarget: options.activeTarget,
             recordEvidence: options.recordEvidence,
-            recordUnknown: options.recordUnknown,
         });
     }
 };
@@ -28,9 +26,6 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             progress,
         });
         if (!result.ok) {
-            const unknownError = recordOfficialUnknown(input, result.error, contract, registration.recordUnknown);
-            if (unknownError !== undefined)
-                return toCallToolResult(unknownError, contract);
             return toCallToolResult(result, contract);
         }
         const evidence = createEvidence(result.value.subject ?? registration.activeTarget?.(), result.value.provider, {
@@ -47,9 +42,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
         const recorded = registration.recordEvidence?.(evidence);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult({ ok: true, value: evidence }, contract);
     });
 };
 const runOfficialOperation = async (analysis, contract, arguments_, execution) => {
@@ -72,48 +65,13 @@ const runOfficialOperation = async (analysis, contract, arguments_, execution) =
     });
     return result;
 };
-const recordOfficialUnknown = (input, error, contract, recordUnknown) => {
-    if (!(error instanceof AnalysisCapabilityUnavailableError) ||
-        !approvedUnknownTracking(input) ||
-        recordUnknown === undefined)
-        return undefined;
-    const unknown = recordUnknown({
-        approved: true,
-        question: "The requested analysis is unavailable for the current target.",
-        severity: "medium",
-        domain: "analysis-capability",
-        supporting_evidence_ids: [],
-        contradicting_evidence_ids: [],
-        required_authority: "shipped-artifact",
-        required_confidence: "observed",
-        required_environment: null,
-        recommended_probes: [
-            {
-                operation: contract.name,
-                rationale: "Choose another analysis or target that can answer this question.",
-            },
-        ],
-        relationships: [],
-    });
-    if (!unknown.ok &&
-        !(unknown.error instanceof UnknownRegistryError &&
-            unknown.error.reason === "already-exists"))
-        return unknown;
-    return undefined;
-};
 const projectOfficialArguments = (contract, 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)) {
-        if (key === "unknown_registry_approved")
-            continue;
         projected[key] = jsonValueSchema.parse(parsed[key] ?? null);
     }
     return projected;
 };
-const approvedUnknownTracking = (input) => typeof input === "object" &&
-    input !== null &&
-    "unknown_registry_approved" in input &&
-    input.unknown_registry_approved === true;

package/dist/server/registerProcessComparisonTool.js

@@ -1,35 +1,43 @@
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { EvidenceIntegrityError } from "../domain/errors.js";
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { compareProcessCaptures, parseProcessCapture, } from "../domain/processCapture.js";
 import { err } from "../domain/result.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
+import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
 import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 const PROCESS_CAPTURE_EVIDENCE = {
     operation: "capture_process_scenario",
-    predicate: "rea.process-capture/v4",
+    predicate: "rea.process-capture",
 };
 const sourceLocations = (left, right) => [...(left ?? []), ...(right ?? [])];
 /** 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) => {
-        const leftRecord = resolveSessionEvidenceIds(session, [input.left_evidence_id], PROCESS_CAPTURE_EVIDENCE);
-        if (!leftRecord.ok)
-            return toCallToolResult(leftRecord, contract);
-        const rightRecord = resolveSessionEvidenceIds(session, [input.right_evidence_id], PROCESS_CAPTURE_EVIDENCE);
-        if (!rightRecord.ok)
-            return toCallToolResult(rightRecord, contract);
+        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.value[0]?.normalized_result);
-            rightCapture = parseProcessCapture(rightRecord.value[0]?.normalized_result);
+            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
                     ? {}
@@ -46,16 +54,14 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         catch (cause) {
             return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error
                 ? cause.message
-                : "Invalid Process Capture v4")), contract);
+                : "Invalid process capture")), contract);
         }
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
-            predicateType: input.trace_spec === undefined
-                ? "rea.process-comparison/v3"
-                : "rea.process-comparison/v4",
+            predicateType: "rea.process-comparison",
             operation: contract.name,
             parameters: {
-                left_evidence_id: input.left_evidence_id,
-                right_evidence_id: input.right_evidence_id,
+                left_evidence_id: leftRecord.evidence_id,
+                right_evidence_id: rightRecord.evidence_id,
                 left_normalization: leftCapture.normalization,
                 right_normalization: rightCapture.normalization,
                 ...(input.trace_spec === undefined
@@ -66,15 +72,20 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
             confidence: "derived",
             authority: "analyst-inference",
             limitations: comparison.limitations,
-            locations: sourceLocations(leftRecord.value[0]?.locations, rightRecord.value[0]?.locations),
-            evidenceLinks: [input.left_evidence_id, input.right_evidence_id],
+            locations: sourceLocations(leftRecord.locations, rightRecord.locations),
+            evidenceLinks: [leftRecord.evidence_id, rightRecord.evidence_id],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(input, comparison)), contract);
+        const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftRecord, rightRecord]);
+        if (!recordedSources.ok)
+            return toCallToolResult(recordedSources, contract);
+        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput({
+            left_evidence_id: leftRecord.evidence_id,
+            right_evidence_id: rightRecord.evidence_id,
+        }, comparison)), contract);
     });
 };
 const comparisonUnknownInput = (parsed, comparison) => {
-    if (parsed.unknown_registry_approved !== true ||
-        comparison.status === "unchanged")
+    if (comparison.status === "unchanged")
         return undefined;
     const differingScopes = [
         ["terminal", comparison.terminal],
@@ -89,7 +100,6 @@ const comparisonUnknownInput = (parsed, comparison) => {
         .map(([scope]) => scope)
         .join(", ");
     return {
-        approved: true,
         question: `Process captures disagree across: ${differingScopes}`,
         severity: "high",
         domain: "process-comparison",

package/dist/server/registerPrompts.js

@@ -39,12 +39,7 @@ const promptArgumentsSchema = (contract, completion) => {
     return z.object(shape);
 };
 const argumentSchema = (argument, completion) => {
-    const value = z
-        .string()
-        .trim()
-        .min(1)
-        .max(4_096)
-        .describe(argument.description);
+    const value = z.string().trim().min(1).describe(argument.description);
     const kind = argument.completion;
     const completed = kind === undefined
         ? value
@@ -53,15 +48,22 @@ const argumentSchema = (argument, completion) => {
         ]);
     return argument.required ? completed : completed.optional();
 };
-const promptResult = (contract, arguments_) => ({
-    description: contract.description,
-    messages: [
-        {
-            role: "user",
-            content: {
-                type: "text",
-                text: renderGuidedPrompt(contract, promptValuesSchema.parse(arguments_)),
+const promptResult = (contract, arguments_) => {
+    const values = promptValuesSchema.parse(arguments_);
+    for (const [name, argument] of Object.entries(contract.arguments))
+        if (argument.required &&
+            (values[name] === undefined || values[name]?.trim().length === 0))
+            throw new TypeError(`Invalid arguments: ${name} must not be empty`);
+    return {
+        description: contract.description,
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: renderGuidedPrompt(contract, values),
+                },
             },
-        },
-    ],
-});
+        ],
+    };
+};