rea-agents 6.0.0 → 6.2.0

package/dist/server/createServer.js

@@ -1,10 +1,14 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { createEvmInterfaceService } from "../composition/evm.js";
 import { registerEvmTools } from "./registerEvmTools.js";
 import { registerRecordedCrashTools } from "./registerRecordedCrashTools.js";
 import { createRecordedCrashService } from "../composition/binaryDiagnostics.js";
+import { registerAnalysisViewTool } from "./registerAnalysisViewTool.js";
 import { registerBinaryDiagnosticsTools } from "./registerBinaryDiagnosticsTools.js";
 import { createBinaryLayoutService } from "../composition/binaryDiagnostics.js";
-import { McpServer } from "@modelcontextprotocol/server";
+import { EvidenceMcpServer } from "./EvidenceMcpServer.js";
+import { createToolResultDelivery, } from "./toolResult.js";
+import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
@@ -42,38 +46,27 @@ import { registerSessionTools } from "./registerSessionTools.js";
 import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
 const TARGET_FREE_INSTRUCTIONS = "REA provides reverse-engineering tools for local artifacts, native binaries, managed code, browser pages, and runtimes. Use the tool that directly answers the question; discover targets or inspect inventory only when needed. Tool results include inline Evidence and report their coverage and limitations.";
 const ACTIVE_TARGET_INSTRUCTIONS = "REA analyzes the active reverse-engineering target. Use the analysis tool that answers the question directly. Search or list symbols when discovery is needed; analyze_function provides a function dossier, and focused procedure tools return individual facets.";
-const installSessionToolAvailability = (server, session, options) => {
+const installSessionToolAvailability = (session, options, environment) => {
     if (session === undefined)
         return undefined;
+    const linux = process.platform === "linux";
+    const linuxX64 = linux && process.arch === "x64";
+    const pwntools = linuxX64 && isAbsolute(environment.REA_PWNTOOLS_PYTHON ?? "");
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
         optionalProviderLoadFailures: options.optionalProviderLoadFailures,
         optionalFeatures: {
-            evmInterfaceEnabled: options.evmInterface !== undefined ||
-                (process.platform === "linux" && process.arch === "x64"),
+            evmInterfaceEnabled: options.evmInterface !== undefined || linuxX64,
             webModuleResolutionEnabled: options.webModuleTrace !== undefined ||
-                isAbsolute(process.env.REA_BROWSER_EXECUTABLE ?? ""),
-            recordedCrashEnabled: options.recordedCrash !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_PWNTOOLS_PYTHON ?? "")),
-            binaryLayoutEnabled: options.binaryLayout !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_PWNTOOLS_PYTHON ?? "")),
+                isAbsolute(environment.REA_BROWSER_EXECUTABLE ?? ""),
+            recordedCrashEnabled: options.recordedCrash !== undefined || pwntools,
+            binaryLayoutEnabled: options.binaryLayout !== undefined || pwntools,
             firmwareInspectionEnabled: options.firmwareAnalysis !== undefined ||
-                (process.platform === "linux" &&
-                    isAbsolute(process.env.REA_BINWALK_COMMAND ?? "")),
+                (linux && isAbsolute(environment.REA_BINWALK_COMMAND ?? "")),
             firmwareExtractionEnabled: options.firmwareAnalysis !== undefined ||
-                (process.platform === "linux" &&
-                    isAbsolute(process.env.REA_UNBLOB_COMMAND ?? "")),
-            androidAnalysisEnabled: options.androidAnalysis !== undefined ||
-                ((process.platform === "linux" || process.platform === "darwin") &&
-                    isAbsolute(process.env.REA_JADX_MCP_JAR ?? "")),
+                (linux && isAbsolute(environment.REA_UNBLOB_COMMAND ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
             javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_WAKARU_COMMAND ?? "")),
+                (linuxX64 && isAbsolute(environment.REA_WAKARU_COMMAND ?? "")),
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
             electronAutomationEnabled: options.electronActiveObservation !== undefined,
@@ -84,7 +77,7 @@ const installSessionToolAvailability = (server, session, options) => {
         policy,
     };
 };
-const createMcpServer = (session) => new McpServer({
+const createMcpServer = (session, delivery) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -92,24 +85,31 @@ const createMcpServer = (session) => new McpServer({
     instructions: session === undefined
         ? ACTIVE_TARGET_INSTRUCTIONS
         : TARGET_FREE_INSTRUCTIONS,
-});
+}, session === undefined
+    ? undefined
+    : (evidence) => session.recordEvidence(evidence), delivery);
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
  * fixed-target seam used by focused tests and embedders.
  */
 export const createServer = (analysis, session, options = {}) => {
+    const environment = snapshotEnvironment(options.environment ?? process.env);
+    const delivery = selectToolResultDelivery(environment, options.delivery);
+    const selectedOptions = { ...options, environment, delivery };
     const startedAt = new Date().toISOString();
     const logger = options.logger ?? silentLogger;
-    const server = createMcpServer(session);
-    const availability = installSessionToolAvailability(server, session, options);
+    const server = createMcpServer(session, delivery);
+    const android = options.androidAnalysis ?? createAndroidAnalysisProvider(environment);
+    const availability = installSessionToolAvailability(session, selectedOptions, environment);
     const toolLogger = logger.child({ layer: "server" });
     const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
     const toolContext = {
         server,
         analysis,
         session,
-        options,
+        options: selectedOptions,
+        environment,
         logger: toolLogger,
         evidenceById,
         activeTarget,
@@ -117,7 +117,6 @@ export const createServer = (analysis, session, options = {}) => {
         recordEvidenceWithUnknown,
     };
     registerBinaryAnalysisTools(toolContext);
-    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
     const previousOnclose = server.server.onclose;
     server.server.onclose = () => {
         previousOnclose?.();
@@ -132,33 +131,48 @@ export const createServer = (analysis, session, options = {}) => {
             if (result.status === "rejected")
                 throw result.reason;
     };
-    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
-    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(), toolLogger, recordEvidence);
-    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(), toolLogger, recordEvidence);
-    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(), toolLogger, recordEvidence);
-    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider()), toolLogger, recordEvidence);
+    registerConfiguredAnalysisTools(toolContext, android);
     registerObservationTools(toolContext);
-    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(), toolLogger, recordEvidence);
-    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(), toolLogger, recordEvidence);
-    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
-    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(), toolLogger, recordEvidence);
-    registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ?? createJavaScriptRecoveryProvider()), toolLogger, recordEvidence);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
         registerSessionTools(server, session, toolLogger, {
-            ...options,
+            ...selectedOptions,
             ...(availability === undefined
                 ? {}
                 : { availabilityPolicy: availability.policy }),
+            androidAnalysisAvailability: (signal) => android.inspectAvailability(signal),
             startedAt,
         });
     }
     return server;
 };
+const selectToolResultDelivery = (environment, selected) => {
+    if (selected !== undefined)
+        return selected;
+    const configured = parseMcpResponseBudget(environment.REA_MCP_MAX_RESPONSE_BYTES);
+    if (!configured.ok)
+        throw configured.error;
+    return createToolResultDelivery(configured.value);
+};
+const registerConfiguredAnalysisTools = ({ server, options, environment, logger: toolLogger, evidenceById, recordEvidence, }, android) => {
+    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
+    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(environment), toolLogger, recordEvidence);
+    registerAnalysisViewTool(server, toolLogger, evidenceById, recordEvidence);
+    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(environment), toolLogger, recordEvidence);
+    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(environment), toolLogger, recordEvidence);
+    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider(environment)), toolLogger, recordEvidence);
+    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(environment), toolLogger, recordEvidence);
+    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(environment), toolLogger, recordEvidence);
+    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
+    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(environment), toolLogger, recordEvidence);
+    registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ??
+        createJavaScriptRecoveryProvider(environment)), toolLogger, recordEvidence);
+};
 const createSessionRecorders = (server, session) => ({
     evidenceById: session === undefined
         ? undefined
-        : (evidenceId) => session.evidenceById(evidenceId),
+        : (evidenceId) => session.evidenceForAnalysis?.(evidenceId) ??
+            session.evidenceById(evidenceId),
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
         ? undefined
@@ -187,6 +201,12 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
     registerEnhancedTools(server, analysis, {
         ...analysisOptions,
         analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
+        allowsSnapshotReplay: session === undefined
+            ? undefined
+            : (operation) => session.allowsSnapshotReplay(operation),
+        recordWorkflowSnapshot: session === undefined
+            ? undefined
+            : (input) => session.recordWorkflowSnapshot(input),
     });
     const evidenceOptions = { logger, activeTarget, recordEvidence };
     registerNativeTools(server, analysis, evidenceOptions);

package/dist/server/mcpClientMetadata.js

@@ -1,12 +1,19 @@
 import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
-/** Client metadata bound to the current SDK request rather than server-global state. */
-export const mcpClientMetadata = (context) => {
+/**
+ * Client metadata for the current request. A 2026-era request carries it in
+ * its per-request envelope; a 2025-era connection sends no envelope, so its
+ * `initialize` handshake supplies the values.
+ */
+export const mcpClientMetadata = (context, connection) => {
     const envelope = context.mcpReq.envelope;
-    const client = implementation(mcpEnvelopeValue(envelope, CLIENT_INFO_META_KEY));
-    const protocolVersion = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+    // The SDK deprecates these accessors only in favor of the envelope, which
+    // 2025-era requests do not carry; they still return initialize values.
+    const value = (key, initialized) => envelope === undefined ? initialized() : mcpEnvelopeValue(envelope, key);
+    const client = implementation(value(CLIENT_INFO_META_KEY, () => connection.getClientVersion()));
+    const protocolVersion = value(PROTOCOL_VERSION_META_KEY, () => connection.getNegotiatedProtocolVersion());
     return {
         ...(client === undefined ? {} : { client }),
-        clientFeatures: capabilityFeatures(mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY)),
+        clientFeatures: capabilityFeatures(value(CLIENT_CAPABILITIES_META_KEY, () => connection.getClientCapabilities())),
         ...(typeof protocolVersion === "string" ? { protocolVersion } : {}),
     };
 };

package/dist/server/promptCompletion.js

@@ -2,13 +2,10 @@ import { z } from "zod";
 import { uniqueSorted } from "../domain/canonicalOrdering.js";
 import { artifactInventoryResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
-import { parseProcessCapture } from "../domain/process/processCapture.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 const documentListSchema = z.array(z.string().min(1));
 const providerStatusSchema = z.object({
-    providers: z.array(z.object({ id: z.string().min(1) })),
-    analysis_provider_candidates: z
-        .array(z.object({ provider: z.object({ id: z.string().min(1) }) }))
-        .optional(),
+    analysis_provider_candidates: z.array(z.object({ provider: z.object({ id: z.string().min(1) }) })),
 });
 /** Build live completion over the active provider and session ledger. */
 export const createPromptCompletionSource = (analysis, session) => ({
@@ -74,9 +71,7 @@ const providerCandidates = (session) => {
     const parsed = providerStatusSchema.safeParse(session.status());
     if (!parsed.success)
         return [];
-    const candidates = (parsed.data.analysis_provider_candidates?.length ?? 0) > 0
-        ? (parsed.data.analysis_provider_candidates?.map(({ provider }) => provider.id) ?? [])
-        : parsed.data.providers.map(({ id }) => id);
+    const candidates = parsed.data.analysis_provider_candidates.map(({ provider }) => provider.id);
     return ["auto", ...candidates];
 };
 const evidenceCandidates = (kind, session) => {

package/dist/server/registerAnalysisViewTool.js

@@ -0,0 +1,15 @@
+import { inspectAnalysisView } from "../application/analysisView/AnalysisViewService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+/** Bind selected-view projection to its named contract and session Evidence owner. */
+export const registerAnalysisViewTool = (server, logger, evidenceById, recordEvidence) => {
+    const contract = toolContract("inspect_analysis_view");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(inspectAnalysisView(input, evidenceById)));
+        if (!result.ok)
+            return server.delivery.toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
+    });
+};

package/dist/server/registerAndroidTools.js

@@ -2,7 +2,6 @@ import { AndroidAnalysisService } from "../application/android/AndroidAnalysisSe
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Bind Android handlers to their exact named contracts through shared workflows. */
 export const registerAndroidTools = (server, service, logger, recordEvidence) => {
     const handler = (contract) => {
@@ -10,11 +9,9 @@ export const registerAndroidTools = (server, service, logger, recordEvidence) =>
         return async (input, context) => {
             const result = await logToolExecution(logger, name, () => service.execute(name, 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);
         };
     };
     const packageContract = toolContract("inspect_android_package");

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
@@ -13,19 +12,19 @@ export const registerCompareJavaScriptExportShapesTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareJavaScriptExportShapesEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
+            return server.delivery.toCallToolResult(recorded, contract);
         const comparison = javaScriptExportShapeComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, contract, result.value, unknown ? "javascript-export-shape" : undefined);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value, unknown ? "javascript-export-shape" : undefined);
     });
 };

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { sourceToBundleComparisonResultSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
@@ -13,18 +12,18 @@ export const registerCompareSourceToBundleTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.application,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
+            return server.delivery.toCallToolResult(recorded, contract);
         const comparison = sourceToBundleComparisonResultSchema.parse(result.value.normalized_result);
-        return recordResult(options, contract, result.value, comparison.summary.unknown > 0
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value, comparison.summary.unknown > 0
             ? "source-to-bundle-comparison"
             : undefined);
     });

package/dist/server/registerApplicationTools/compareVersions.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { applicationVersionComparisonResultSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
@@ -13,11 +12,11 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
         const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, compareContract);
+            return server.delivery.toCallToolResult(resolved, compareContract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, compareContract);
+            return server.delivery.toCallToolResult(result, compareContract);
         const sources = [
             parsed.left,
             parsed.right,
@@ -26,9 +25,9 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
         ];
         const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
-            return toCallToolResult(recorded, compareContract);
+            return server.delivery.toCallToolResult(recorded, compareContract);
         const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
+        return recordResult({ ...options, delivery: server.delivery }, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
     });
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -2,12 +2,11 @@ import { evaluateReconstructionCoverage } from "../../application/Reconstruction
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 const contract = applicationToolContract("evaluate_reconstruction_coverage");
 /** Register the inline fail-closed reconstruction coverage evaluator. */
 export const registerCoverageTools = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionCoverage(input)));
-        return toCallToolResult(result, contract);
+        return server.delivery.toCallToolResult(result, contract);
     });
 };

package/dist/server/registerApplicationTools/helpers.js

@@ -1,12 +1,9 @@
 import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { toCallToolResult } from "../toolResult.js";
 export const recordResult = (options, contract, evidence, unknownKind) => {
     const recorded = unknownKind === undefined
         ? options.recordEvidence?.(evidence)
         : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
-    if (recorded !== undefined && !recorded.ok)
-        return toCallToolResult(recorded, contract);
-    return toCallToolResult({ ok: true, value: evidence }, contract);
+    return options.delivery.toEvidenceToolResult(evidence, contract, recorded);
 };
 const unknownRegistration = (evidence, kind) => ({
     question: kind === "application-version-comparison"

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -3,7 +3,6 @@ import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstruc
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("build_reconstruction_obligation_ledger");
 /** Register conservative reconstruction-obligation generation and closure. */
@@ -11,13 +10,13 @@ export const registerReconstructionObligationLedgerTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(buildReconstructionObligationLedgerEvidenceValidated(resolved.value)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, resolved.value.evidence_bundle.records);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recorded, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };

package/dist/server/registerApplicationTools/projectMobileApplicationGraph.js

@@ -4,7 +4,6 @@ import { APPLICATION_TOOL_CONTRACTS, applicationToolContract, } from "../../cont
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 /** Register execution-free Android and Apple inventory projection tools. */
 export const registerProjectMobileApplicationGraphTools = (server, options) => {
@@ -26,11 +25,11 @@ const registerProjection = (context) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(project(input)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, inventoryEvidenceSources(input));
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recordedSources, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };
 const inventoryEvidenceSources = (input) => {

package/dist/server/registerApplicationTools/traceFeature.js

@@ -4,7 +4,6 @@ import { traceApplicationFeatureEvidenceValidated } from "../../application/java
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
@@ -12,15 +11,15 @@ export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, traceContract);
+            return server.delivery.toCallToolResult(resolved, traceContract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, traceContract);
+            return server.delivery.toCallToolResult(result, traceContract);
         const sources = [parsed.application, ...parsed.native_observations];
         const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
-            return toCallToolResult(recorded, traceContract);
-        return recordResult(options, traceContract, result.value);
+            return server.delivery.toCallToolResult(recorded, traceContract);
+        return recordResult({ ...options, delivery: server.delivery }, traceContract, result.value);
     });
 };

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -4,7 +4,6 @@ import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/jav
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
@@ -12,16 +11,16 @@ export const registerTraceJavaScriptSemanticsTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.application,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recorded, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };

package/dist/server/registerArtifactComparisonTool.js

@@ -4,9 +4,8 @@ import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { ARTIFACT_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -16,13 +15,13 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             return { left, right, comparison: compareArtifacts(left, right) };
         });
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const { left, right, comparison } = computed.value;
         const sources = [left, right];
         for (const source of sources) {
             const recordedSource = session.recordEvidence(source);
             if (!recordedSource.ok)
-                return toCallToolResult(recordedSource, contract);
+                return server.delivery.toCallToolResult(recordedSource, contract);
         }
         const leftEvidenceIds = [left.evidence_id];
         const rightEvidenceIds = [right.evidence_id];
@@ -39,18 +38,22 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status)), contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status, evidence.evidence_id)));
     });
 };
-const artifactUnknownInput = (left, right, status) => {
-    if (status === "unchanged" || left.evidence_id === right.evidence_id)
+const artifactUnknownInput = (left, right, status, comparisonEvidenceId) => {
+    if (status === "unchanged")
         return undefined;
+    const contradictory = (status === "changed" || status === "contradiction") &&
+        left.evidence_id !== right.evidence_id;
     return {
-        question: `Artifact comparison is ${status}`,
+        question: `Artifact comparison is ${status} (comparison ${comparisonEvidenceId})`,
         severity: status === "unknown" || status === "truncated" ? "high" : "medium",
         domain: "artifact-comparison",
-        supporting_evidence_ids: [left.evidence_id],
-        contradicting_evidence_ids: [right.evidence_id],
+        supporting_evidence_ids: contradictory
+            ? [left.evidence_id]
+            : [...new Set([left.evidence_id, right.evidence_id])],
+        contradicting_evidence_ids: contradictory ? [right.evidence_id] : [],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,

package/dist/server/registerBinaryDiagnosticsTools.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 offline layout inspection to its named contract and session Evidence owner. */
 export const registerBinaryDiagnosticsTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_binary_layout");
     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);
     });
 };