rea-agents 6.1.0 → 6.3.0

package/dist/process/capture/TerminalRenderer.js

@@ -19,6 +19,8 @@ export class TerminalRenderer {
     #frames = [];
     #pending = Promise.resolve();
     #capturedBytes = 0;
+    #observedBytes = 0;
+    #observedFrames = 0;
     #truncated = false;
     constructor(options) {
         this.options = options;
@@ -55,6 +57,16 @@ export class TerminalRenderer {
     truncated() {
         return this.#truncated;
     }
+    /** Budget accounting after awaiting queued writes with frames(). */
+    retention() {
+        return {
+            budget_bytes: this.options.maxBytes,
+            observed_bytes: this.#observedBytes,
+            retained_bytes: this.#capturedBytes,
+            observed_frames: this.#observedFrames,
+            retained_frames: this.#frames.length,
+        };
+    }
     /** Release addon and terminal resources after all writes settle. */
     async dispose() {
         await this.#pending;
@@ -71,6 +83,8 @@ export class TerminalRenderer {
         const serializedState = this.options.normalize(this.#serializeAddon.serialize());
         const bytes = Buffer.byteLength(serializedState) +
             lines.reduce((total, line) => total + Buffer.byteLength(line), 0);
+        this.#observedBytes += bytes;
+        this.#observedFrames += 1;
         if (this.#capturedBytes + bytes > this.options.maxBytes) {
             this.#truncated = true;
             return;

package/dist/process/snapshotEnvironment.js

@@ -0,0 +1,14 @@
+/** Snapshot caller-selected variables using Node child-process key semantics. */
+export const snapshotEnvironment = (environment, platform = process.platform) => {
+    if (platform !== "win32")
+        return Object.freeze({ ...environment });
+    const snapshot = {};
+    // Node sorts keys lexicographically and forwards the first case-insensitive
+    // match on Windows. Canonical keys also make subsequent lookups deterministic.
+    for (const key of Object.keys(environment).sort()) {
+        const canonicalKey = key.toUpperCase();
+        if (!Object.hasOwn(snapshot, canonicalKey))
+            snapshot[canonicalKey] = environment[key];
+    }
+    return Object.freeze(snapshot);
+};

package/dist/server/EvidenceMcpServer.js

@@ -1,35 +1,37 @@
 import { McpServer, isCallToolResult, isJSONRPCRequest, isJSONRPCNotification, isJSONRPCResultResponse, } from "@modelcontextprotocol/server";
 import { analysisErrorProjectionSchema } from "../contracts/errorSchemas.js";
-import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
 import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { toErrorToolResult } from "./toolResult.js";
-import { encodeToolResult, MCP_RESULT_BUDGET_BYTES, } from "./toolResultEncoding.js";
+import { encodeToolResult } from "./toolResultEncoding.js";
 /** Bind oversized MCP error recovery to this server's Evidence ledger. */
 export class EvidenceMcpServer extends McpServer {
     recordEvidence;
-    constructor(info, options, recordEvidence) {
+    delivery;
+    constructor(info, options, recordEvidence, delivery) {
         super(info, options);
         this.recordEvidence = recordEvidence;
+        this.delivery = delivery;
     }
     /** Preserve the SDK transport lifecycle while retaining oversized errors. */
     connect(transport) {
-        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence));
+        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence, this.delivery));
     }
 }
 class ErrorEvidenceTransport {
     transport;
     recordEvidence;
+    delivery;
     onclose;
     onerror;
     onmessage;
     hasPerRequestStream;
     pendingTools = new Map();
-    constructor(transport, recordEvidence) {
+    constructor(transport, recordEvidence, delivery) {
         this.transport = transport;
         this.recordEvidence = recordEvidence;
+        this.delivery = delivery;
         if (transport.hasPerRequestStream !== undefined)
             this.hasPerRequestStream = transport.hasPerRequestStream;
         transport.onmessage = (message, extra) => {
@@ -83,7 +85,18 @@ class ErrorEvidenceTransport {
             : undefined;
         const tool = id === undefined ? undefined : this.pendingTools.get(id);
         try {
-            await this.transport.send(this.recoverError(message, tool), options);
+            const recovered = this.recoverError(message, tool);
+            if (isJSONRPCResultResponse(recovered) &&
+                isCallToolResult(recovered.result) &&
+                recovered.result.isError === true) {
+                // Keep the complete typed JSON in content. Error projections are not
+                // success outputSchema data; oversized recovery must consume their
+                // private structured carrier before it is removed from the wire.
+                const { structuredContent: _diagnostic, ...result } = recovered.result;
+                await this.transport.send({ ...recovered, result }, options);
+            }
+            else
+                await this.transport.send(recovered, options);
         }
         finally {
             if (!isJSONRPCRequest(message) && id !== undefined)
@@ -97,11 +110,9 @@ class ErrorEvidenceTransport {
             message.result.structuredContent === undefined)
             return message;
         const structured = jsonObjectSchema.parse(message.result.structuredContent);
-        const configured = parseMcpResponseBudget(process.env.REA_MCP_MAX_RESPONSE_BYTES);
-        const budget = configured.ok && configured.value !== undefined
-            ? configured.value - 1024
-            : MCP_RESULT_BUDGET_BYTES;
-        const encoded = encodeToolResult(structured, budget);
+        const budget = this.delivery.resultBudgetBytes;
+        // The delivered error omits structuredContent, so only its text counts.
+        const encoded = encodeToolResult(structured, budget, "text");
         if (encoded.ok)
             return message;
         const operation = tool ?? "mcp_tool_error";
@@ -139,8 +150,8 @@ class ErrorEvidenceTransport {
         }, {
             remediationAction: retained
                 ? "Export the retained original error through export_evidence_bundle to a caller-selected path. The connection remains usable."
-                : "Configure a larger REA_MCP_MAX_RESPONSE_BYTES and matching client receive buffer, then retry. The original error could not be retained by this server.",
+                : "Restart REA with a larger REA_MCP_MAX_RESPONSE_BYTES and matching client receive buffer, then retry. The original error could not be retained by this server.",
         });
-        return { ...message, result: toErrorToolResult(failure) };
+        return { ...message, result: this.delivery.toErrorToolResult(failure) };
     }
 }

package/dist/server/analysisAdmission.js

@@ -0,0 +1,8 @@
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { err, ok } from "../domain/result.js";
+/** Run against the source's explicit owner, admitting session-scoped work. */
+export const withAdmittedAnalysis = (source) => source.kind === "session"
+    ? (operationName, signal, operation) => source.session.withAdmittedAnalysis(operationName, signal, operation)
+    : async (operationName, signal, operation) => signal?.aborted === true
+        ? err(new AnalysisCancelledError(operationName))
+        : ok(await operation(source.analysis));

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 { 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";
@@ -35,42 +39,36 @@ import { registerAndroidTools } from "./registerAndroidTools.js";
 import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
 import { createAndroidAnalysisProvider } from "../composition/android.js";
 import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
-import { registerNativeTools } from "./registerNativeTools.js";
+import { NATIVE_TOOL_CONTRACTS } from "../contracts/native/nativeToolContracts.js";
+import { registerEvidenceTools } from "./registerEvidenceTools.js";
 import { registerOfficialTools } from "./registerOfficialTools.js";
 import { registerGuidedPrompts } from "./registerPrompts.js";
 import { registerSessionTools } from "./registerSessionTools.js";
 import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
+import { withAdmittedAnalysis, } from "./analysisAdmission.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 ?? "")),
+                (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,
@@ -81,7 +79,7 @@ const installSessionToolAvailability = (server, session, options) => {
         policy,
     };
 };
-const createMcpServer = (session) => new EvidenceMcpServer({
+const createMcpServer = (session, delivery) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -91,30 +89,36 @@ const createMcpServer = (session) => new EvidenceMcpServer({
         : TARGET_FREE_INSTRUCTIONS,
 }, session === undefined
     ? undefined
-    : (evidence) => session.recordEvidence(evidence));
+    : (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 = {}) => {
+export const createServer = (source, options = {}) => {
+    const session = source.kind === "session" ? source.session : undefined;
+    const analysis = source.kind === "session" ? source.session : source.analysis;
+    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 android = options.androidAnalysis ?? createAndroidAnalysisProvider();
-    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,
         recordEvidence,
         recordEvidenceWithUnknown,
+        withAdmittedAnalysis: withAdmittedAnalysis(source),
     };
     registerBinaryAnalysisTools(toolContext);
     const previousOnclose = server.server.onclose;
@@ -131,21 +135,12 @@ 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 }),
@@ -155,6 +150,28 @@ export const createServer = (analysis, session, options = {}) => {
     }
     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
@@ -163,18 +180,12 @@ const createSessionRecorders = (server, session) => ({
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
         ? undefined
-        : (evidence) => {
-            const recorded = session.recordEvidence(evidence);
-            return recorded;
-        },
+        : (evidence) => session.recordEvidence(evidence),
     recordEvidenceWithUnknown: session === undefined
         ? undefined
-        : (evidence, input) => {
-            const recorded = session.recordEvidenceWithUnknown(evidence, input);
-            return recorded;
-        },
+        : (evidence, input) => session.recordEvidenceWithUnknown(evidence, input),
 });
-const registerBinaryAnalysisTools = ({ server, analysis, session, logger, activeTarget, recordEvidence, recordEvidenceWithUnknown, }) => {
+const registerBinaryAnalysisTools = ({ server, session, logger, activeTarget, recordEvidence, recordEvidenceWithUnknown, withAdmittedAnalysis, }) => {
     const recordUnknown = session === undefined
         ? undefined
         : (input) => session.recordUnknown(input);
@@ -183,9 +194,10 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
         activeTarget,
         recordEvidence,
         recordUnknown,
+        withAdmittedAnalysis,
     };
-    registerOfficialTools(server, analysis, analysisOptions);
-    registerEnhancedTools(server, analysis, {
+    registerOfficialTools(server, analysisOptions);
+    registerEnhancedTools(server, {
         ...analysisOptions,
         analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
         allowsSnapshotReplay: session === undefined
@@ -195,15 +207,15 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
             ? undefined
             : (input) => session.recordWorkflowSnapshot(input),
     });
-    const evidenceOptions = { logger, activeTarget, recordEvidence };
-    registerNativeTools(server, analysis, evidenceOptions);
-    registerArtifactTools(server, analysis, {
-        ...evidenceOptions,
-    });
-    registerManagedTools(server, analysis, {
-        ...evidenceOptions,
-        session,
-    });
+    const evidenceOptions = {
+        logger,
+        activeTarget,
+        recordEvidence,
+        withAdmittedAnalysis,
+    };
+    registerEvidenceTools(server, NATIVE_TOOL_CONTRACTS, evidenceOptions);
+    registerArtifactTools(server, evidenceOptions);
+    registerManagedTools(server, evidenceOptions);
     if (session !== undefined)
         registerManagedWorkflowTools(server, {
             logger,

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, toEvidenceToolResult } 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,9 +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 toEvidenceToolResult(result.value, contract, recorded);
+            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,20 @@ 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);
+        const unknown = comparison.summary.unknown > 0 ||
+            comparison.coverage.status !== "complete-within-inputs";
+        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,17 +1,17 @@
 import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { toEvidenceToolResult } from "../toolResult.js";
 export const recordResult = (options, contract, evidence, unknownKind) => {
     const recorded = unknownKind === undefined
         ? options.recordEvidence?.(evidence)
         : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
-    return toEvidenceToolResult(evidence, contract, recorded);
+    return options.delivery.toEvidenceToolResult(evidence, contract, recorded);
 };
 const unknownRegistration = (evidence, kind) => ({
-    question: kind === "application-version-comparison"
+    // Scope unknown identity to the comparison while keeping exact replays stable.
+    question: `${kind === "application-version-comparison"
         ? "Which application entities remain unmatched or ambiguous across these versions?"
         : kind === "source-to-bundle-comparison"
             ? "Which historical source files remain unmatched or ambiguously mapped to the shipped bundle?"
-            : "Which selected JavaScript export return shapes remain dynamic, incomplete, or ambiguously paired?",
+            : "Which selected JavaScript export return shapes remain dynamic, incomplete, or ambiguously paired?"} (comparison ${evidence.evidence_id})`,
     severity: "medium",
     domain: kind,
     supporting_evidence_ids: [evidence.evidence_id],