rea-agents 5.0.0 → 6.1.0

package/dist/{application → process/capture}/ProcessHarness.js

@@ -1,32 +1,60 @@
-import { parseProcessCapture } from "../domain/processCapture.js";
-import { err, ok } from "../domain/result.js";
-import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
+import { parseProcessCapture } from "../../domain/process/processCapture.js";
+import { err, ok } from "../../domain/result.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { describeProcessCaptureExecutionFailure, ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
 export { ProcessCaptureError } from "./ProcessCaptureError.js";
 import { startProcessSampler } from "./ProcessSampling.js";
 import { snapshotRoots } from "./FilesystemSnapshot.js";
 import { TerminalRenderer } from "./TerminalRenderer.js";
 import { normalizeProcessText } from "./ProcessNormalization.js";
-import { selectCapturedProcessGroupIds } from "../process/ProcessOwnershipProcessTree.js";
-import { awaitTerminalExit, buildCaptureResult, captureTerminalFrames, createRunManifest, observeSettlement, prepareProcessCapture, releaseProcessResources, resolveProcessResult, settleProcessCaptureJournal, } from "./ProcessCaptureLifecycle.js";
+import { selectCapturedProcessGroupIds } from "../ProcessOwnershipProcessTree.js";
+import { awaitTerminalExit, buildCaptureResult, cleanupReportFailure, captureTerminalFrames, createProcessCaptureObservationBuffer, createRunManifest, observeLaunchedExecutable, observeSelectedExecutable, observeSettlement, prepareProcessCapture, releaseProcessResources, resolveProcessResult, settleProcessCaptureJournal, } from "./ProcessCaptureLifecycle.js";
 import { assertNotCancelled, resolveProcessScenarioRuntimePaths, } from "./ProcessScenarioRuntimeValidation.js";
 import { createProcessCaptureJournal, scheduleScenarioInteractions, } from "./ProcessCaptureJournal.js";
 import { makeProcessCaptureEnvironment } from "./ProcessCaptureEnvironment.js";
 import { classifyFilesystemEffects } from "./ProcessFilesystemEffects.js";
 import { processCaptureOwnershipUnavailableReason } from "./ProcessCaptureCapability.js";
+import { DarwinProcessOwnershipInspectionError } from "../DarwinProcessRunTokenReader.js";
 export { probeProcessCaptureCapability } from "./ProcessCaptureCapability.js";
 const cleanupFailedStartup = async (options) => {
+    const sampledProcessGroupIds = options.terminal !== undefined &&
+        options.observations?.process_samples.state === "available"
+        ? selectCapturedProcessGroupIds(options.terminal.pid, options.observations.process_samples.value).filter((groupId) => groupId !== options.terminal?.pid)
+        : undefined;
     options.terminal?.kill("SIGKILL");
+    if (options.observations !== undefined && options.renderer !== undefined) {
+        try {
+            options.observations.rendered_frames = {
+                state: "available",
+                value: await options.renderer.frames(),
+            };
+        }
+        catch (cause) {
+            options.observations.rendered_frames = {
+                state: "unavailable",
+                reason: `Rendered terminal frame collection failed: ${cause instanceof Error ? cause.message : "unknown failure"}`,
+            };
+        }
+    }
     const cleanupFailure = await releaseProcessResources({
-        ...options,
-        capturedProcessGroupIds: options.terminal === undefined ? [] : [options.terminal.pid],
+        timers: options.timers,
+        terminal: options.terminal,
+        renderer: options.renderer,
+        runId: options.runId,
+        captureBaseline: options.captureBaseline,
+        ...(sampledProcessGroupIds === undefined ? {} : { sampledProcessGroupIds }),
+        temporaryRoot: options.temporaryRoot,
+        ...(options.cleanupHost === undefined ? {} : { host: options.cleanupHost }),
     });
-    if (cleanupFailure !== undefined)
-        throw new ProcessCaptureError(cleanupFailure, {
-            cause: options.cause,
-            reason: "cleanup_incomplete",
+    if (cleanupReportFailure(cleanupFailure) !== undefined) {
+        resolveProcessResult(undefined, options.cause, cleanupFailure, options.observations, {
+            scenario: options.scenario,
+            ...(options.terminal === undefined
+                ? {}
+                : { rootPid: options.terminal.pid }),
         });
+    }
     throw options.cause;
 };
 const createTerminalRenderer = (scenario, temporaryRoot, terminalPid, recordEvent) => new TerminalRenderer({
@@ -43,6 +71,7 @@ const startCaptureRuntime = async (options) => {
     let terminal;
     try {
         const { spawn } = await import("@lydell/node-pty");
+        const selectedExecutable = await observeSelectedExecutable(scenario.executable, options.signal);
         const startedAt = new Date();
         const started = Date.now();
         let lastOutput = started;
@@ -54,6 +83,12 @@ const startCaptureRuntime = async (options) => {
             rows: scenario.terminal.rows,
             name: "xterm-256color",
         });
+        options.onSpawn(terminal.pid);
+        options.observationBuffer.target_pid = {
+            state: "available",
+            value: scenario.normalization.pids ? 1 : terminal.pid,
+        };
+        const executableIdentity = observeLaunchedExecutable(scenario.executable, selectedExecutable);
         const framesTruncated = captureTerminalFrames({
             ...options,
             terminal,
@@ -80,6 +115,7 @@ const startCaptureRuntime = async (options) => {
             terminal,
             started,
             startedAt,
+            executableIdentity,
             lastOutput: () => lastOutput,
             framesTruncated,
             stopSampler,
@@ -92,22 +128,32 @@ const startCaptureRuntime = async (options) => {
             terminal,
             renderer,
             runId: options.runId,
+            captureBaseline: options.ownershipBaseline,
+            scenario,
+            ...(options.cleanupHost === undefined
+                ? {}
+                : { cleanupHost: options.cleanupHost }),
+            observations: options.observationBuffer,
             temporaryRoot: options.temporaryRoot,
         });
     }
 };
 const finishProcessRun = async (options) => {
     await options.stopSampler();
-    const cleanupFailure = await releaseProcessResources({
+    const sampledProcessGroupIds = options.runtime === undefined
+        ? undefined
+        : selectCapturedProcessGroupIds(options.runtime.terminal.pid, options.samples).filter((groupId) => groupId !== options.runtime?.terminal.pid);
+    const cleanup = await releaseProcessResources({
         timers: options.timers,
         terminal: options.runtime?.terminal,
         renderer: options.runtime?.renderer,
         runId: options.runId,
+        captureBaseline: options.captureBaseline,
+        ...(sampledProcessGroupIds === undefined ? {} : { sampledProcessGroupIds }),
         temporaryRoot: options.temporaryRoot,
-        capturedProcessGroupIds: options.runtime === undefined
-            ? []
-            : selectCapturedProcessGroupIds(options.runtime.terminal.pid, options.samples),
+        ...(options.cleanupHost === undefined ? {} : { host: options.cleanupHost }),
     });
+    const cleanupFailure = cleanupReportFailure(cleanup);
     let { capture, executionFailure } = options;
     let verifiedCapture;
     if (capture !== undefined && cleanupFailure === undefined) {
@@ -129,11 +175,18 @@ const finishProcessRun = async (options) => {
             executionFailure = new ProcessCaptureError(`process capture validation failed${cause instanceof Error ? `: ${cause.message}` : ""}`, { cause });
         }
     }
-    return resolveProcessResult(verifiedCapture, executionFailure, cleanupFailure);
+    const rootPid = options.runtime?.terminal.pid ?? options.rootPid;
+    const partialContext = rootPid === undefined
+        ? { scenario: options.scenario }
+        : { scenario: options.scenario, rootPid };
+    return resolveProcessResult(cleanupFailure === undefined ? verifiedCapture : capture, executionFailure, cleanup, options.observations, partialContext);
 };
-const normalizeCaptureFailure = (cause, signal) => {
+/** Preserve typed process-inspection preflight failures at the capture boundary. */
+export const normalizeCaptureFailure = (cause, signal) => {
     if (cause instanceof ProcessCaptureError)
         return cause;
+    if (cause instanceof DarwinProcessOwnershipInspectionError)
+        return new ProcessCaptureError(cause.message, { cause });
     if (signal?.aborted === true &&
         (cause === signal.reason ||
             (cause instanceof Error && cause.name === "AbortError")))
@@ -141,17 +194,66 @@ const normalizeCaptureFailure = (cause, signal) => {
     return cause;
 };
 const completeCapture = async (options) => {
+    const unavailableReason = (stage, cause) => `${stage} failed: ${cause instanceof Error ? cause.message : "unknown failure"}`;
     const { runtime, scenario } = options;
     const { reason } = options.exit;
     if (reason === "cancelled")
         throw processCaptureCancelled();
-    const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent, options.hostPlatform);
+    let settlement;
+    try {
+        settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent, options.hostPlatform);
+    }
+    catch (cause) {
+        options.observationBuffer.settlement = {
+            state: "unavailable",
+            reason: unavailableReason("Process settlement observation", cause),
+        };
+        throw cause;
+    }
+    options.observationBuffer.settlement = {
+        state: "available",
+        value: settlement,
+    };
     const samplingPartial = (await runtime.stopSampler()).partial;
     await settleProcessCaptureJournal(options.eventJournal);
     assertNotCancelled(options.signal);
-    const after = await options.captureSnapshot(scenario, options.signal);
+    let after;
+    try {
+        after = await options.captureSnapshot(scenario, options.signal);
+    }
+    catch (cause) {
+        options.observationBuffer.filesystem_snapshots = {
+            ...options.observationBuffer.filesystem_snapshots,
+            after: {
+                state: "unavailable",
+                reason: unavailableReason("Final filesystem snapshot", cause),
+            },
+        };
+        throw cause;
+    }
+    options.observationBuffer.filesystem_snapshots = {
+        ...options.observationBuffer.filesystem_snapshots,
+        after: {
+            state: "available",
+            value: { files: after.files, truncated: after.truncated },
+        },
+    };
     options.recordEvent("filesystem_checkpoints", 1);
-    const renderedFrames = await runtime.renderer.frames();
+    let renderedFrames;
+    try {
+        renderedFrames = await runtime.renderer.frames();
+    }
+    catch (cause) {
+        options.observationBuffer.rendered_frames = {
+            state: "unavailable",
+            reason: unavailableReason("Rendered terminal frame collection", cause),
+        };
+        throw cause;
+    }
+    options.observationBuffer.rendered_frames = {
+        state: "available",
+        value: renderedFrames,
+    };
     const checkpoints = [
         {
             name: "before",
@@ -168,7 +270,18 @@ const completeCapture = async (options) => {
             truncated: after.truncated,
         },
     ];
-    const manifest = await createRunManifest(scenario, runtime.startedAt, new Date(), { platform: options.hostPlatform, architecture: process.arch });
+    let manifest;
+    try {
+        manifest = await createRunManifest(scenario, runtime.startedAt, new Date(), runtime.executableIdentity, { platform: options.hostPlatform, architecture: process.arch });
+    }
+    catch (cause) {
+        options.observationBuffer.manifest = {
+            state: "unavailable",
+            reason: unavailableReason("Capture manifest creation", cause),
+        };
+        throw cause;
+    }
+    options.observationBuffer.manifest = { state: "available", value: manifest };
     const truncated = options.initiallyTruncated ||
         after.truncated ||
         runtime.framesTruncated() ||
@@ -194,19 +307,27 @@ const completeCapture = async (options) => {
     });
 };
 /** Execute one caller-selected scenario and return bounded observations. */
-const runProcessScenario = async (scenario, signal, hostEnvironment = process.env, hostPlatform = process.platform, captureSnapshot = snapshotRoots) => {
-    const { temporaryRoot, runId, before } = await prepareProcessCapture(scenario, signal, captureSnapshot);
+const runProcessScenario = async (scenario, signal, hostEnvironment = process.env, hostPlatform = process.platform, captureSnapshot = snapshotRoots, cleanupHost) => {
+    const { temporaryRoot, runId, ownershipBaseline, before } = await prepareProcessCapture(scenario, signal, captureSnapshot);
     const frames = [];
     const samples = [];
+    const interactions = [];
     const journal = createProcessCaptureJournal();
     const { entries: eventJournal, recordEvent } = journal;
     recordEvent("filesystem_checkpoints", 0);
+    const observations = createProcessCaptureObservationBuffer({
+        frames,
+        interactions,
+        samples,
+        eventJournal,
+        before,
+    });
     let runtime;
+    let actualRootPid;
     const timers = new Set();
     let capture;
     let executionFailure;
     let stopSampler = async () => ({ partial: false });
-    const interactions = [];
     const dispatchedEventIndexes = new Set();
     try {
         runtime = await startCaptureRuntime({
@@ -214,6 +335,12 @@ const runProcessScenario = async (scenario, signal, hostEnvironment = process.en
             hostEnvironment,
             temporaryRoot,
             runId,
+            ownershipBaseline,
+            ...(cleanupHost === undefined ? {} : { cleanupHost }),
+            observationBuffer: observations,
+            onSpawn: (pid) => {
+                actualRootPid = pid;
+            },
             frames,
             samples,
             interactions,
@@ -234,6 +361,14 @@ const runProcessScenario = async (scenario, signal, hostEnvironment = process.en
             dispatchedEventIndexes,
             recordEvent,
         });
+        observations.exit = {
+            state: "available",
+            value: {
+                code: exit.reason === "exited" && exit.exitCode >= 0 ? exit.exitCode : null,
+                signal: exit.signal ?? null,
+                reason: exit.reason,
+            },
+        };
         capture = await completeCapture({
             scenario,
             hostPlatform,
@@ -247,6 +382,7 @@ const runProcessScenario = async (scenario, signal, hostEnvironment = process.en
             exit,
             initiallyTruncated: before.truncated,
             eventJournal,
+            observationBuffer: observations,
             recordEvent,
             captureSnapshot,
             ...(signal === undefined ? {} : { signal }),
@@ -255,32 +391,62 @@ const runProcessScenario = async (scenario, signal, hostEnvironment = process.en
     catch (cause) {
         runtime?.terminal.kill("SIGKILL");
         executionFailure = normalizeCaptureFailure(cause, signal);
+        if (runtime !== undefined &&
+            observations.rendered_frames.state === "unavailable" &&
+            observations.rendered_frames.reason.startsWith("Rendered terminal frames were not collected")) {
+            try {
+                observations.rendered_frames = {
+                    state: "available",
+                    value: await runtime.renderer.frames(),
+                };
+            }
+            catch (renderCause) {
+                const renderFailure = renderCause instanceof Error
+                    ? renderCause.message
+                    : "unknown failure";
+                observations.rendered_frames = {
+                    state: "unavailable",
+                    reason: `Rendered terminal frame collection failed: ${renderFailure}`,
+                };
+            }
+        }
     }
     return finishProcessRun({
         runtime,
         timers,
         runId,
+        captureBaseline: ownershipBaseline,
+        ...(cleanupHost === undefined ? {} : { cleanupHost }),
         temporaryRoot,
+        scenario,
         samples,
         stopSampler,
         capture,
         executionFailure,
+        observations,
+        ...(actualRootPid === undefined ? {} : { rootPid: actualRootPid }),
     });
 };
 /** Execute one scenario through a typed expected-failure channel. */
-export const captureProcessScenario = async (scenario, signal, platform = process.platform, environment = process.env, captureSnapshot = snapshotRoots) => {
+export const captureProcessScenario = async (scenario, signal, platform = process.platform, environment = process.env, captureSnapshot = snapshotRoots, cleanupHost) => {
     const ownershipReason = processCaptureOwnershipUnavailableReason(platform);
     if (ownershipReason !== undefined)
         return err(new AnalysisCapabilityUnavailableError("rea-process", "capture_process_scenario", ownershipReason, { userMessage: ownershipReason }));
     try {
         assertNotCancelled(signal);
         const resolvedScenario = await resolveProcessScenarioRuntimePaths(scenario, environment);
-        return ok(await runProcessScenario(resolvedScenario, signal, environment, platform, captureSnapshot));
+        return ok(await runProcessScenario(resolvedScenario, signal, environment, platform, captureSnapshot, cleanupHost));
     }
     catch (cause) {
         const failure = normalizeCaptureFailure(cause, signal);
+        const executionFailureReason = describeProcessCaptureExecutionFailure(cause);
         return err(failure instanceof ProcessCaptureError
             ? failure
-            : new ProcessCaptureError("process capture failed", { cause }));
+            : new ProcessCaptureError("process capture failed", {
+                cause,
+                ...(executionFailureReason === undefined
+                    ? {}
+                    : { executionFailure: executionFailureReason }),
+            }));
     }
 };

package/dist/{application → process/capture}/ProcessSampling.js

@@ -1,6 +1,6 @@
 import { readFile, readdir } from "node:fs/promises";
-import { execFileOutput } from "../process/ExecFileOutput.js";
-import { readProcessRunId } from "../process/ProcessOwnership.js";
+import { execFileOutput } from "../ExecFileOutput.js";
+import { readProcessRunId } from "../ProcessOwnership.js";
 const PROC_READ_CONCURRENCY = 64;
 /** Prove that forkpty completed session setup and installed the run token. */
 export const isInitializedPtyRoot = (options) => {

package/dist/server/EvidenceMcpServer.js

@@ -0,0 +1,146 @@
+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";
+/** Bind oversized MCP error recovery to this server's Evidence ledger. */
+export class EvidenceMcpServer extends McpServer {
+    recordEvidence;
+    constructor(info, options, recordEvidence) {
+        super(info, options);
+        this.recordEvidence = recordEvidence;
+    }
+    /** Preserve the SDK transport lifecycle while retaining oversized errors. */
+    connect(transport) {
+        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence));
+    }
+}
+class ErrorEvidenceTransport {
+    transport;
+    recordEvidence;
+    onclose;
+    onerror;
+    onmessage;
+    hasPerRequestStream;
+    pendingTools = new Map();
+    constructor(transport, recordEvidence) {
+        this.transport = transport;
+        this.recordEvidence = recordEvidence;
+        if (transport.hasPerRequestStream !== undefined)
+            this.hasPerRequestStream = transport.hasPerRequestStream;
+        transport.onmessage = (message, extra) => {
+            if (isJSONRPCRequest(message) &&
+                message.method === "tools/call" &&
+                typeof message.params?.["name"] === "string")
+                this.pendingTools.set(message.id, message.params["name"]);
+            // The SDK suppresses replies after cancellation, so send() cannot release
+            // this bookkeeping. Keep transport authentication outside retained data.
+            if (isJSONRPCNotification(message) &&
+                message.method === "notifications/cancelled") {
+                const id = message.params?.["requestId"];
+                if (typeof id === "string" || typeof id === "number")
+                    this.pendingTools.delete(id);
+            }
+            this.onmessage?.(message, extra);
+        };
+        transport.onerror = (error) => this.onerror?.(error);
+        transport.onclose = () => {
+            this.pendingTools.clear();
+            this.onclose?.();
+        };
+    }
+    get sessionId() {
+        return this.transport.sessionId;
+    }
+    set sessionId(value) {
+        this.transport.sessionId = value;
+    }
+    start() {
+        return this.transport.start();
+    }
+    async close() {
+        try {
+            await this.transport.close();
+        }
+        finally {
+            this.pendingTools.clear();
+        }
+    }
+    setProtocolVersion(version) {
+        this.transport.setProtocolVersion?.(version);
+    }
+    setSupportedProtocolVersions(versions) {
+        this.transport.setSupportedProtocolVersions?.(versions);
+    }
+    async send(message, options) {
+        const id = "id" in message &&
+            (typeof message.id === "string" || typeof message.id === "number")
+            ? message.id
+            : undefined;
+        const tool = id === undefined ? undefined : this.pendingTools.get(id);
+        try {
+            await this.transport.send(this.recoverError(message, tool), options);
+        }
+        finally {
+            if (!isJSONRPCRequest(message) && id !== undefined)
+                this.pendingTools.delete(id);
+        }
+    }
+    recoverError(message, tool) {
+        if (!isJSONRPCResultResponse(message) ||
+            !isCallToolResult(message.result) ||
+            message.result.isError !== true ||
+            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);
+        if (encoded.ok)
+            return message;
+        const operation = tool ?? "mcp_tool_error";
+        const originalError = analysisErrorProjectionSchema.safeParse(structured["error"]);
+        // Retain the already projected diagnostic. Transport authentication and raw
+        // request arguments are deliberately excluded: the application owns their
+        // explicit sensitivity policy, and its error projection is authoritative.
+        const evidence = createEvidence(undefined, { id: "rea-mcp", name: "REA MCP delivery", version: "1" }, {
+            operation: "mcp_tool_error",
+            parameters: { tool_name: operation },
+            result: structured,
+            rawResult: jsonObjectSchema.parse(message.result),
+        });
+        const recorded = this.recordEvidence?.(evidence);
+        const retained = recorded !== undefined && recorded.ok;
+        const failure = new AnalysisResourceConstraintError(operation, "transport", "The tool failed, but its complete error response exceeds the MCP response budget.", {
+            boundary: "mcp-response",
+            ...(originalError.success
+                ? { original_error_code: originalError.data.code }
+                : {}),
+            result_budget_bytes: budget,
+            response_bytes_at_least: encoded.bytesAtLeast,
+            constraint: encoded.constraint,
+            ...(retained
+                ? {
+                    evidence_reference: {
+                        kind: "retained-evidence",
+                        evidence_id: evidence.evidence_id,
+                    },
+                }
+                : { retention: recorded === undefined ? "unavailable" : "failed" }),
+            ...(recorded !== undefined && !recorded.ok
+                ? { retention_error: projectAnalysisError(recorded.error) }
+                : {}),
+        }, {
+            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.",
+        });
+        return { ...message, result: toErrorToolResult(failure) };
+    }
+}

package/dist/server/createServer.js

@@ -1,4 +1,10 @@
-import { McpServer } from "@modelcontextprotocol/server";
+import { createEvmInterfaceService } from "../composition/evm.js";
+import { registerEvmTools } from "./registerEvmTools.js";
+import { registerRecordedCrashTools } from "./registerRecordedCrashTools.js";
+import { createRecordedCrashService } from "../composition/binaryDiagnostics.js";
+import { registerBinaryDiagnosticsTools } from "./registerBinaryDiagnosticsTools.js";
+import { createBinaryLayoutService } from "../composition/binaryDiagnostics.js";
+import { EvidenceMcpServer } from "./EvidenceMcpServer.js";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
@@ -13,6 +19,8 @@ import { createWebSourceLocationService } from "../composition/webSourceLocation
 import { registerWebSourceLocationTool } from "./registerWebSourceLocationTool.js";
 import { createWebRuntimeService } from "../composition/webRuntime.js";
 import { registerWebRuntimeTools } from "./registerWebRuntimeTools.js";
+import { createWebNetworkCaptureService } from "../composition/webNetworkCaptures.js";
+import { registerWebNetworkCaptureTool } from "./registerWebNetworkCaptureTool.js";
 import { registerJavaScriptRecoveryTool } from "./registerJavaScriptRecoveryTool.js";
 import { JavaScriptRecoveryService } from "../application/javascript/JavaScriptRecoveryService.js";
 import { createJavaScriptRecoveryProvider } from "../composition/javascriptRecovery.js";
@@ -40,17 +48,24 @@ const installSessionToolAvailability = (server, session, options) => {
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
         optionalProviderLoadFailures: options.optionalProviderLoadFailures,
         optionalFeatures: {
+            evmInterfaceEnabled: options.evmInterface !== undefined ||
+                (process.platform === "linux" && process.arch === "x64"),
             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 ?? "")),
             firmwareInspectionEnabled: options.firmwareAnalysis !== undefined ||
                 (process.platform === "linux" &&
                     isAbsolute(process.env.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 ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
             javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
                 (process.platform === "linux" &&
@@ -66,7 +81,7 @@ const installSessionToolAvailability = (server, session, options) => {
         policy,
     };
 };
-const createMcpServer = (session) => new McpServer({
+const createMcpServer = (session) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -74,7 +89,9 @@ const createMcpServer = (session) => new McpServer({
     instructions: session === undefined
         ? ACTIVE_TARGET_INSTRUCTIONS
         : TARGET_FREE_INSTRUCTIONS,
-});
+}, session === undefined
+    ? undefined
+    : (evidence) => session.recordEvidence(evidence));
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -84,6 +101,7 @@ export const createServer = (analysis, session, options = {}) => {
     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 toolLogger = logger.child({ layer: "server" });
     const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
@@ -99,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?.();
@@ -115,11 +132,15 @@ export const createServer = (analysis, session, options = {}) => {
                 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);
     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) {
@@ -128,6 +149,7 @@ export const createServer = (analysis, session, options = {}) => {
             ...(availability === undefined
                 ? {}
                 : { availabilityPolicy: availability.policy }),
+            androidAnalysisAvailability: (signal) => android.inspectAvailability(signal),
             startedAt,
         });
     }
@@ -136,7 +158,8 @@ export const createServer = (analysis, session, options = {}) => {
 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
@@ -165,6 +188,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);