rea-agents 6.0.0 → 6.2.0

package/dist/server/registerBrowserScenarioTool.js

@@ -5,22 +5,19 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register the browser scenario tool with execution-time provider diagnostics. */
 export const registerBrowserScenarioTool = (server, options) => {
     const contract = toolContract("capture_browser_scenario");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const scenario = browserScenarioSchema.parse(input);
         if (options.loadFailure !== undefined)
-            return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
+            return server.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
         const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, scenario, {
             signal: context.mcpReq.signal,
         }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult({ ok: true, value: result.value }, contract);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerBrowserTools.js

@@ -7,10 +7,10 @@ import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register browser tools with execution-time provider diagnostics. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerBrowserTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_browser_targets");
     const inspectContract = toolContract("inspect_web_page");
     const analyzeContract = toolContract("analyze_web_bundle");
@@ -19,44 +19,39 @@ export const registerBrowserTools = (server, options) => {
     const captureDiffContract = toolContract("compare_web_captures");
     const screenshotContract = toolContract("capture_web_screenshot");
     const screenshotDiffContract = toolContract("compare_web_screenshots");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(options, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, parsed, {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(registration, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, analyzeWebBundleInputSchema.parse(parsed), {
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(registration, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(registration, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, analyzeWebBundleInputSchema.parse(parsed), {
         signal,
         progress,
     })));
-    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), (input, context) => runBrowserTool(options, sessionContract, { input, context }, (parsed, { signal, progress }) => observeWebSession(options.browser, parsed, {
+    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), (input, context) => runBrowserTool(registration, sessionContract, { input, context }, (parsed, { signal, progress }) => observeWebSession(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), (input, context) => runBrowserTool(options, webMcpContract, { input, context }, (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, parsed, {
+    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), (input, context) => runBrowserTool(registration, webMcpContract, { input, context }, (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), (input, context) => runBrowserTool(options, captureDiffContract, { input, context }, (parsed) => compareWebCaptureEvidence(options.browser, parsed)));
-    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), (input, context) => runBrowserTool(options, screenshotContract, { input, context }, (parsed, { signal, progress }) => captureWebScreenshot(options.browser, parsed, {
+    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), (input, context) => runBrowserTool(registration, captureDiffContract, { input, context }, (parsed) => compareWebCaptureEvidence(options.browser, parsed)));
+    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), (input, context) => runBrowserTool(registration, screenshotContract, { input, context }, (parsed, { signal, progress }) => captureWebScreenshot(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), (input, context) => runBrowserTool(options, screenshotDiffContract, { input, context }, (parsed) => compareWebScreenshotEvidence(options.browser, parsed)));
+    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), (input, context) => runBrowserTool(registration, screenshotDiffContract, { input, context }, (parsed) => compareWebScreenshotEvidence(options.browser, parsed)));
 };
 const runBrowserTool = async (options, contract, request, execute) => {
     const { input, context } = request;
     if (options.loadFailure !== undefined)
-        return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
+        return options.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),
     }));
     if (!result.ok)
-        return toCallToolResult(result, contract);
-    return evidenceResult(options, contract, result.value);
-};
-const evidenceResult = (options, contract, evidence) => {
-    const recorded = options.recordEvidence?.(evidence);
-    return recorded !== undefined && !recorded.ok
-        ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract);
+        return options.delivery.toCallToolResult(result, contract);
+    const recorded = options.recordEvidence?.(result.value);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerBundleComparisonTool.js

@@ -3,11 +3,9 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { compareBundles } from "../domain/bundleComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { ok } from "../domain/result.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { BUNDLE_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register canonical Evidence bundle comparison. */
 export const registerBundleComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -16,12 +14,12 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             readEvidenceBundle(input.right_bundle_path),
         ]);
         if (!left.ok)
-            return toCallToolResult(left, contract);
+            return server.delivery.toCallToolResult(left, contract);
         if (!right.ok)
-            return toCallToolResult(right, contract);
+            return server.delivery.toCallToolResult(right, contract);
         const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, input.record_pairs));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const comparison = computed.value;
         const evidence = createEvidence(undefined, BUNDLE_COMPARISON_PROVIDER, {
             predicateType: "rea.bundle-comparison",
@@ -37,6 +35,6 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
         });
         const recorded = session.recordEvidence(evidence);
-        return toCallToolResult(recorded.ok ? ok(evidence) : recorded, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };

package/dist/server/registerCloseLifecycleTool.js

@@ -1,35 +1,24 @@
-import { writeAnalysisSnapshot } from "../application/binary/AnalysisSnapshotFiles.js";
-import { ok } from "../domain/result.js";
 import { reportLifecycleEnd, reportLifecycleStart, } from "./lifecycleProgress.js";
+import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register provider cleanup and optional pre-close snapshot persistence. */
 export const registerCloseLifecycleTool = ({ server, session, logger, closeContract, }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input, context) => {
         const progress = mcpProgressReporter(context);
-        if (input.snapshot_path === undefined) {
+        const snapshotPath = input.snapshot_path;
+        if (snapshotPath === undefined) {
             await reportLifecycleStart(progress, closeContract.name);
             const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-            return toCallToolResult(closed, closeContract);
+            return server.delivery.toCallToolResult(closed, closeContract);
         }
-        const snapshot = session.exportAnalysisSnapshot();
-        if (!snapshot.ok)
-            return toCallToolResult(snapshot, closeContract);
-        const written = await writeAnalysisSnapshot(snapshot.value, input.snapshot_path, input.overwrite);
-        if (!written.ok)
-            return toCallToolResult(written, closeContract);
-        await reportLifecycleStart(progress, closeContract.name, "snapshot written; closing provider");
-        const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
+        await reportLifecycleStart(progress, closeContract.name, "saving snapshot; closing provider");
+        const closed = await logToolExecution(logger, closeContract.name, () => session.closeWithSnapshot(snapshotPath, input.overwrite, {
+            progress,
+        }));
         await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-        return closed.ok
-            ? toCallToolResult(ok({
-                path: written.value.path,
-                bytes: written.value.bytes,
-                entries: snapshot.value.entries.length,
-            }), closeContract)
-            : toCallToolResult(closed, closeContract);
+        return server.delivery.toCallToolResult(closed.ok ? ok({ ...closed.value }) : closed, closeContract);
     });
 };

package/dist/server/registerElectronTools.js

@@ -9,28 +9,28 @@ import { inspectElectronPageInputSchema } from "../domain/javascript/electronObs
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register Electron tools even when a provider is absent. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerElectronTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_electron_targets");
     const inspectContract = toolContract("inspect_electron_page");
     const analyzeContract = toolContract("analyze_javascript_application");
     const reconcileContract = toolContract("reconcile_javascript_runtime");
     const activeContract = toolContract("capture_electron_scenario");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(options, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, parsed, {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(registration, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(options, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(registration, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
         const request = inspectElectronPageInputSchema.parse(parsed);
         return inspectElectronPage(options.electron, request, {
             signal,
             progress,
         });
     }));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
-    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(options, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
-    server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(options, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, parsed, {
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(registration, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
+    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(registration, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
+    server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(registration, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, parsed, {
         signal,
         progress,
     })));
@@ -44,18 +44,13 @@ const runElectronTool = async (options, contract, request, execute) => {
             ? options.observationLoadFailure
             : undefined;
     if (failure !== undefined)
-        return toCallToolResult(err(optionalProviderUnavailable(failure, contract.name)), contract);
+        return options.delivery.toCallToolResult(err(optionalProviderUnavailable(failure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),
     }));
     if (!result.ok)
-        return toCallToolResult(result, contract);
-    return evidenceResult(options, contract, result.value);
-};
-const evidenceResult = (options, contract, evidence) => {
-    const recorded = options.recordEvidence?.(evidence);
-    return recorded !== undefined && !recorded.ok
-        ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract);
+        return options.delivery.toCallToolResult(result, contract);
+    const recorded = options.recordEvidence?.(result.value);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerEnhancedTools.js

@@ -1,16 +1,14 @@
-import { EnhancedTools, } from "../application/EnhancedTools.js";
-import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
+import { EnhancedTools } from "../application/EnhancedTools.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 { 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.
 export const registerEnhancedTools = (server, analysis, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const nativeDispatchMetadata = toolContract("inspect_native_dispatch_metadata");
     const objcClasses = toolContract("get_objc_classes");
     const objcProtocols = toolContract("get_objc_protocols");
@@ -25,59 +23,59 @@ export const registerEnhancedTools = (server, analysis, options) => {
     const traceCallPath = toolContract("trace_call_path");
     const traceNativeUiAction = toolContract("trace_native_ui_action");
     const traceNativeValues = toolContract("trace_native_values");
-    server.registerTool(traceNativeValues.name, toolRegistrationOptions(traceNativeValues), (input, context) => executeEnhancedTool(analysis, options, traceNativeValues, {
+    server.registerTool(traceNativeValues.name, toolRegistrationOptions(traceNativeValues), (input, context) => executeEnhancedTool(analysis, registration, traceNativeValues, {
         validatedCall: { name: "trace_native_values", input },
         context,
     }));
-    server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(analysis, options, nativeDispatchMetadata, {
+    server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(analysis, registration, nativeDispatchMetadata, {
         validatedCall: { name: "inspect_native_dispatch_metadata", input },
         context,
     }));
-    server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(analysis, options, objcClasses, {
+    server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(analysis, registration, objcClasses, {
         validatedCall: { name: "get_objc_classes", input },
         context,
     }));
-    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(analysis, options, objcProtocols, {
+    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(analysis, registration, objcProtocols, {
         validatedCall: { name: "get_objc_protocols", input },
         context,
     }));
-    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(analysis, options, batchDecompile, {
+    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(analysis, registration, batchDecompile, {
         validatedCall: { name: "batch_decompile", input },
         context,
     }));
-    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(analysis, options, callGraph, {
+    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(analysis, registration, callGraph, {
         validatedCall: { name: "get_call_graph", input },
         context,
     }));
-    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(analysis, options, swiftTypes, {
+    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(analysis, registration, swiftTypes, {
         validatedCall: { name: "analyze_swift_types", input },
         context,
     }));
-    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(analysis, options, xrefsToName, {
+    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(analysis, registration, xrefsToName, {
         validatedCall: { name: "find_xrefs_to_name", input },
         context,
     }));
-    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(analysis, options, binaryOverview, {
+    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(analysis, registration, binaryOverview, {
         validatedCall: { name: "binary_overview", input },
         context,
     }));
-    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(analysis, options, analyzeFunction, {
+    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(analysis, registration, analyzeFunction, {
         validatedCall: { name: "analyze_function", input },
         context,
     }));
-    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(analysis, options, inspectNativeApi, {
+    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(analysis, registration, inspectNativeApi, {
         validatedCall: { name: "inspect_native_api", input },
         context,
     }));
-    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(analysis, options, traceFeature, {
+    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(analysis, registration, traceFeature, {
         validatedCall: { name: "trace_feature", input },
         context,
     }));
-    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, options, traceCallPath, {
+    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, registration, traceCallPath, {
         validatedCall: { name: "trace_call_path", input },
         context,
     }));
-    server.registerTool(traceNativeUiAction.name, toolRegistrationOptions(traceNativeUiAction), (input, context) => executeEnhancedTool(analysis, options, traceNativeUiAction, {
+    server.registerTool(traceNativeUiAction.name, toolRegistrationOptions(traceNativeUiAction), (input, context) => executeEnhancedTool(analysis, registration, traceNativeUiAction, {
         validatedCall: { name: "trace_native_ui_action", input },
         context,
     }));
@@ -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);
+            return registration.delivery.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 registration.delivery.toCallToolResult(snapshot, contract);
+            }
+        }
         const unknowns = recordWorkflowUnknowns({
             name,
             result: result.value,
@@ -139,10 +138,10 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
             recordUnknown: registration.recordUnknown,
         });
         if (!unknowns.ok)
-            return toCallToolResult(unknowns, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract);
+            return registration.delivery.toCallToolResult(unknowns, contract);
+        return registration.delivery.toEvidenceToolResult(evidence, contract, recorded);
     }
-    return toCallToolResult(result, contract);
+    return registration.delivery.toCallToolResult(result, contract);
 };
 const executeFunctionTool = async (analysis, registration, contract, request) => {
     const { context, parameters } = request;
@@ -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 registration.delivery.toCallToolResult(result, contract);
+    return registration.delivery.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,6 @@ 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 { createArtifactExtractionDestination } from "../application/artifacts/ArtifactExtractionDestination.js";
 /** Register provider-backed contracts that return atomic Evidence observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
@@ -35,7 +34,7 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 terminal: true,
             });
             if (!execution.ok)
-                return toCallToolResult(execution, contract);
+                return server.delivery.toCallToolResult(execution, contract);
             const sourceEvidence = options.sourceEvidence?.(contract.name, execution.value.result) ?? [];
             const evidence = createEvidence(execution.value.subject ?? options.activeTarget?.(), execution.value.provider, {
                 operation: contract.name,
@@ -52,12 +51,10 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
             for (const source of sourceEvidence) {
                 const sourceRecorded = options.recordEvidence?.(source);
                 if (sourceRecorded !== undefined && !sourceRecorded.ok)
-                    return toCallToolResult(sourceRecorded, contract);
+                    return server.delivery.toCallToolResult(sourceRecorded, contract);
             }
             const recorded = options.recordEvidence?.(evidence);
-            return recorded !== undefined && !recorded.ok
-                ? toCallToolResult(recorded, contract)
-                : toCallToolResult({ ok: true, value: evidence }, contract);
+            return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
         });
     }
 };

package/dist/server/registerEvmTools.js

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

package/dist/server/registerFirmwareTools.js

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

package/dist/server/registerFunctionComparisonTool.js

@@ -2,14 +2,13 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { err } from "../domain/result.js";
-import { compareFunctions } from "../domain/functionComparison.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { FUNCTION_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
+import { compareFunctions } from "../domain/functionComparison.js";
 /** Register explicit Evidence-backed function comparison. */
 export const registerFunctionComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -20,22 +19,22 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             rightEvidence = parseEvidence(input.right);
         }
         catch (cause) {
-            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
+            return server.delivery.toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
         }
         if (leftEvidence.operation !== "analyze_function" ||
             rightEvidence.operation !== "analyze_function" ||
             leftEvidence.predicate_type !== "rea.analysis" ||
             rightEvidence.predicate_type !== "rea.analysis")
-            return toCallToolResult(err(new EvidenceIntegrityError("Expected analyze_function Evidence")), contract);
+            return server.delivery.toCallToolResult(err(new EvidenceIntegrityError("Expected analyze_function Evidence")), contract);
         const leftIds = [leftEvidence.evidence_id];
         const rightIds = [rightEvidence.evidence_id];
         const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(leftEvidence, rightEvidence));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const comparison = computed.value;
         const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftEvidence, rightEvidence]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
+            return server.delivery.toCallToolResult(recordedSources, contract);
         const evidence = createEvidence(undefined, FUNCTION_COMPARISON_PROVIDER, {
             predicateType: "rea.function-comparison",
             operation: contract.name,
@@ -53,19 +52,23 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             status: comparison.status,
             leftIds,
             rightIds,
+            comparisonEvidenceId: evidence.evidence_id,
         }));
-        return toCallToolResult(recorded, contract);
+        return server.delivery.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,