rea-agents 3.0.0 → 3.2.0

package/dist/server/registerInvestigationTools.js

@@ -1,58 +1,37 @@
-import { runCrossVersionInvestigationValidated } from "../application/CrossVersionInvestigation.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
-import { buildCallPath, callPathInputSchema } from "../domain/callPath.js";
-import { correlateStaticAndRuntime, staticRuntimeCorrelationInputSchema, } from "../domain/staticRuntimeCorrelation.js";
-import { reconstructionVerificationInputSchema, verifyReconstruction, } from "../domain/reconstructionVerification.js";
-import { changedBehaviorResultSchema, changedBehaviorInputSchema, findChangedBehavior, } from "../domain/changedBehavior.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { buildCallPath } from "../domain/callPath.js";
+import { findChangedBehavior } from "../domain/changedBehavior.js";
 import { createEvidence } from "../domain/evidence.js";
-import {} from "../domain/errors.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 { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
-import { mcpProgressReporter } from "./mcpProgress.js";
-import { runDerivedOperation, } from "./runDerivedOperation.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../application/DeferredFileAuthorization.js";
-import { comparisonClosure, evidenceClosure, functionEvidenceIds, investigationContext, isIncomplete, recordWorkflowEvidence, verifyCoverageReadiness, } from "./registerInvestigationTools/helpers.js";
 /** Register Evidence-composed differential investigation workflows. */
-export const registerInvestigationTools = (server, session, contracts, policies) => {
-    registerChangedBehavior(server, session, contracts[0], policies);
+export const registerInvestigationTools = (server, session, contracts) => {
+    registerChangedBehavior(server, session, contracts[0]);
     registerCallPath(server, session, contracts[1]);
     registerStaticRuntime(server, session, contracts[2]);
     registerReconstruction(server, session, contracts[3]);
 };
-const registerChangedBehavior = (server, session, contract, policies) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(changedBehaviorInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const investigationRun = parsed.investigation_run;
-        if (investigationRun !== undefined)
-            return runAutomaticInvestigation({
-                server,
-                session,
-                contract,
-                policies,
-                investigationRun,
-                unknownRegistryApproved: parsed.unknown_registry_approved,
-                context,
-            });
-        const closure = evidenceClosure(session, comparisonClosure(parsed.comparisons));
+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);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(parsed.comparisons, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
-            predicateType: "rea.changed-behavior/v1",
+            predicateType: "rea.changed-behavior",
             operation: contract.name,
             parameters: {
-                comparison_evidence_ids: parsed.comparisons.map(({ evidence_id: id }) => id),
-                offset: parsed.offset,
-                limit: parsed.limit,
+                comparison_evidence_ids: input.comparisons.map(({ evidence_id: id }) => id),
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -60,7 +39,7 @@ const registerChangedBehavior = (server, session, contract, policies) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, isIncomplete(result.behavior_status), {
+        const recorded = recordWorkflowEvidence(session, evidence, isIncomplete(result.behavior_status), {
             question: "Did both versions behave the same under a complete controlled replay?",
             domain: "changed-behavior",
             requiredAuthority: "controlled-replay",
@@ -75,97 +54,22 @@ const registerChangedBehavior = (server, session, contract, policies) => {
         return toCallToolResult(recorded, contract);
     });
 };
-const runAutomaticInvestigation = async (input) => {
-    const { policies, investigationRun, contract, session } = input;
-    const progress = mcpProgressReporter(input.context);
-    let workspaceAuthorization;
-    let authorizeInputRead;
-    if (policies.permissionAuthority !== undefined) {
-        const authority = policies.permissionAuthority;
-        const authorizedWorkspace = await authorizeFileReadWithDeferredWrite(authority, {
-            path: investigationRun.workspace_path,
-            readCapability: "investigation_workspace_read",
-            writeCapability: "investigation_workspace_write",
-            operation: contract.name,
-        });
-        if (!authorizedWorkspace.ok)
-            return toCallToolResult(authorizedWorkspace, contract);
-        workspaceAuthorization = authorizedWorkspace.value;
-        authorizeInputRead = () => authorizeRootPermission(authority, {
-            capability: "investigation_input",
-            roots: [investigationRun.left_path, investigationRun.right_path],
-            access: "read",
-            operation: contract.name,
-        });
-    }
-    const investigated = await runCrossVersionInvestigationValidated(investigationRun, policies.evidenceFiles, {
-        ...investigationContext({
-            session,
-            signal: input.context.mcpReq.signal,
-            inputRoots: policies.inputRoots,
-            integrityContinueEnabled: policies.integrityContinueEnabled?.() ?? false,
-            progress,
-        }),
-        ...(workspaceAuthorization === undefined
-            ? {}
-            : { authorizeWorkspaceWrite: workspaceAuthorization.authorizeWrite }),
-        ...(authorizeInputRead === undefined ? {} : { authorizeInputRead }),
-    });
-    if (!investigated.ok)
-        return toCallToolResult(investigated, contract);
-    const workspace = investigated.value.workspace;
-    session.retainInvestigationWorkspace(workspace);
-    const result = changedBehaviorResultSchema.parse(investigated.value.evidence.normalized_result);
-    const toolResult = toCallToolResult(recordWorkflowEvidence(session, investigated.value.evidence, input.unknownRegistryApproved, isIncomplete(result.behavior_status), {
-        question: `Automatic changed behavior run ${result.investigation_run?.run_id ?? "unknown"} remains ${result.behavior_status}`,
-        domain: "changed-behavior",
-        requiredAuthority: "controlled-replay",
-        requiredConfidence: "observed",
-        probes: [
-            {
-                operation: "capture_process_scenario",
-                rationale: "Capture both versions under the same bounded scenario and environment.",
-            },
-        ],
-    }), contract);
-    return {
-        ...toolResult,
-        content: [
-            ...toolResult.content,
-            {
-                type: "resource_link",
-                uri: `rea://workspace/${workspace.workspace_id}/revision/${String(workspace.revision)}`,
-                name: `${workspace.workspace_id} revision ${String(workspace.revision)}`,
-                description: "Immutable CAS-linked investigation workspace revision",
-                mimeType: "application/json",
-            },
-        ],
-    };
-};
 const registerCallPath = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(callPathInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const closure = evidenceClosure(session, functionEvidenceIds(parsed.functions));
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const closure = evidenceClosure(session, functionEvidenceIds(input.functions));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(parsed));
+        const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(input));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {
-            predicateType: "rea.call-path/v1",
+            predicateType: "rea.call-path",
             operation: contract.name,
             parameters: {
-                start: parsed.start.address,
-                goal: parsed.goal.address,
-                max_depth: parsed.max_depth,
-                max_paths: parsed.max_paths,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                start: input.start.address,
+                goal: input.goal.address,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -173,7 +77,7 @@ const registerCallPath = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        const recorded = recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Can the requested call path be established from complete analysis?",
             domain: "call-path",
             requiredAuthority: "shipped-artifact",
@@ -189,29 +93,23 @@ const registerCallPath = (server, session, contract) => {
     });
 };
 const registerStaticRuntime = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(staticRuntimeCorrelationInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, comparisonClosure([
-            ...parsed.static_comparisons,
-            ...parsed.runtime_comparisons,
+            ...input.static_comparisons,
+            ...input.runtime_comparisons,
         ]));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(parsed));
+        const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(input));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {
-            predicateType: "rea.static-runtime-correlation/v1",
+            predicateType: "rea.static-runtime-correlation",
             operation: contract.name,
             parameters: {
-                mapping_count: parsed.mappings.length,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                mapping_count: input.mappings.length,
             },
             result: jsonValueSchema.parse(result),
             confidence: "inferred",
@@ -219,7 +117,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
             question: "Does runtime behavior match the available static analysis?",
             domain: "static-runtime-correlation",
             requiredAuthority: null,
@@ -234,16 +132,9 @@ const registerStaticRuntime = (server, session, contract) => {
     });
 };
 const registerReconstruction = (server, session, contract) => {
-    server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(reconstructionVerificationInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const coverage = verifyCoverageReadiness(session, parsed.coverage);
-        if (!coverage.ok)
-            return toCallToolResult(coverage, contract);
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const owned = session.exportEvidenceBundle();
-        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(parsed.specification, owned, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -252,13 +143,11 @@ const registerReconstruction = (server, session, contract) => {
             return toCallToolResult(closure, contract);
         const links = closure.value;
         const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {
-            predicateType: "rea.reconstruction-verification/v1",
+            predicateType: "rea.reconstruction-verification",
             operation: contract.name,
             parameters: {
                 specification_sha256: result.specification_sha256,
-                claim_ids: parsed.specification.claims.map(({ claim_id: id }) => id),
-                offset: parsed.offset,
-                limit: parsed.limit,
+                claim_ids: input.specification.claims.map(({ claim_id: id }) => id),
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -266,7 +155,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,
@@ -278,4 +167,3 @@ const registerReconstruction = (server, session, contract) => {
         }), contract);
     });
 };
-const contractOptions = toolRegistrationOptions;

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -1,37 +1,25 @@
 import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/JavaScriptRuntimeObservationService.js";
 import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "../contracts/javascriptRuntimeObservationToolContracts.js";
-import { listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeObservation.js";
+import { observeJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
-import { safeParseToolInput } from "./toolInputValidation.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 [listContract, observeContract] = JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS;
-    registerRuntimeTool(server, options, {
-        contract: listContract,
-        schema: listJavaScriptRuntimeTargetsInputSchema,
-        execute: (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal }),
-    });
-    registerRuntimeTool(server, options, {
-        contract: observeContract,
-        schema: observeJavaScriptRuntimeInputSchema,
-        execute: (parsed, signal) => observeJavaScriptRuntime(options.runtime, options.permissionAuthority, parsed, { signal }),
-    });
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal })));
+    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, async (parsed, signal) => {
+        const request = observeJavaScriptRuntimeInputSchema.parse(parsed);
+        return observeJavaScriptRuntime(options.runtime, options.permissionAuthority, request, { signal });
+    }));
 };
-const registerRuntimeTool = (server, options, spec) => {
-    server.registerTool(spec.contract.name, toolRegistrationOptions(spec.contract), async (input, context) => {
-        const parsed = safeParseToolInput(spec.schema, input, spec.contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, spec.contract);
-        const result = await logToolExecution(options.logger, spec.contract.name, () => spec.execute(parsed.value, context.mcpReq.signal));
-        if (!result.ok)
-            return toCallToolResult(result, spec.contract);
-        const recorded = options.recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, spec.contract)
-            : toCallToolResult({ ok: true, value: result.value }, spec.contract, {
-                evidenceResourcesAvailable: recorded !== undefined,
-            });
-    });
+const runRuntimeTool = async (options, contract, request, execute) => {
+    const { input, context } = request;
+    const result = await logToolExecution(options.logger, contract.name, () => execute(input, context.mcpReq.signal));
+    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);
 };

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -1,34 +1,30 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareManagedMembersEvidenceValidated } from "../../application/ManagedMemberComparisonService.js";
-import { compareManagedMembersReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { managedMemberComparisonResultSchema } from "../../domain/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.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 parsedInput = safeParseToolInput(compareManagedMembersReferenceInputSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
-        const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.left_evidence_id,
-            parsedInput.value.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 } = parsedInput.value;
-        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,
         ]);
@@ -36,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",
@@ -50,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: [],
@@ -58,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/contract.js

@@ -1,8 +1,7 @@
 import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "../../contracts/managedWorkflowToolContracts.js";
-/** Locate one managed workflow tool contract by exact name. */
-export const managedWorkflowContract = (name) => {
+export function managedWorkflowContract(name) {
     const found = MANAGED_WORKFLOW_TOOL_CONTRACTS.find((candidate) => candidate.name === name);
     if (found === undefined)
         throw new Error(`Missing ${name} contract`);
     return found;
-};
+}

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

@@ -1,28 +1,20 @@
 import { importManagedReconstructionEvidenceValidated } from "../../application/ManagedReconstructionService.js";
-import { managedReconstructionReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const reconstructionContract = managedWorkflowContract("import_managed_reconstruction");
 /** Register the managed reconstruction import workflow tool. */
 export const registerImportManagedReconstruction = (server, options) => {
     server.registerTool(reconstructionContract.name, toolRegistrationOptions(reconstructionContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedReconstructionReferenceInputSchema, input, reconstructionContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, reconstructionContract);
-        const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.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 } = parsedInput.value;
-        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);
@@ -32,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

@@ -1,28 +1,20 @@
 import { planManagedRuntimeCorrelationEvidenceValidated } from "../../application/ManagedRuntimeCorrelationService.js";
-import { managedRuntimeCorrelationReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const runtimeContract = managedWorkflowContract("plan_managed_runtime_correlation");
 /** Register the managed runtime correlation planning workflow tool. */
 export const registerPlanManagedRuntimeCorrelation = (server, options) => {
     server.registerTool(runtimeContract.name, toolRegistrationOptions(runtimeContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedRuntimeCorrelationReferenceInputSchema, input, runtimeContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, runtimeContract);
-        const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.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 } = parsedInput.value;
-        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);
@@ -32,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);
     });
 };