rea-agents 5.0.0 → 6.0.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/createServer.js

@@ -1,3 +1,9 @@
+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 { McpServer } from "@modelcontextprotocol/server";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.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,8 +48,18 @@ 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 ?? "")),
@@ -115,11 +133,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) {

package/dist/server/promptCompletion.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { uniqueSorted } from "../domain/canonicalOrdering.js";
 import { artifactInventoryResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
-import { processCaptureSchema } from "../domain/processCapture.js";
+import { parseProcessCapture } from "../domain/process/processCapture.js";
 const documentListSchema = z.array(z.string().min(1));
 const providerStatusSchema = z.object({
     providers: z.array(z.object({ id: z.string().min(1) })),
@@ -114,8 +114,15 @@ const evidenceValues = (kind, evidence) => {
 const isProcessCaptureEvidence = (evidence) => {
     if (evidence.operation !== "capture_process_scenario")
         return false;
-    const capture = processCaptureSchema.safeParse(evidence.normalized_result);
-    return capture.success;
+    try {
+        parseProcessCapture(evidence.normalized_result);
+        return true;
+    }
+    catch (cause) {
+        if (cause instanceof TypeError || cause instanceof z.ZodError)
+            return false;
+        throw cause;
+    }
 };
 const unknownCandidates = (session) => session === undefined
     ? []

package/dist/server/registerBinaryDiagnosticsTools.js

@@ -0,0 +1,17 @@
+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);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerEvidenceTools.js

@@ -4,7 +4,7 @@ import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
-import { createArtifactExtractionDestination } from "../application/ArtifactExtractionDestination.js";
+import { createArtifactExtractionDestination } from "../application/artifacts/ArtifactExtractionDestination.js";
 /** Register provider-backed contracts that return atomic Evidence observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
     for (const contract of contracts) {

package/dist/server/registerEvmTools.js

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

package/dist/server/registerProcessComparisonTool.js

@@ -2,7 +2,7 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/processCapture.js";
+import { compareProcessCaptures, parseProcessCapture, } from "../domain/process/processCapture.js";
 import { err } from "../domain/result.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { recordSessionEvidenceSources } from "./sessionEvidence.js";

package/dist/server/registerRecordedCrashTools.js

@@ -0,0 +1,17 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind recorded crash inspection to its named contract and session Evidence owner. */
+export const registerRecordedCrashTools = (server, service, logger, recordEvidence) => {
+    const contract = toolContract("inspect_recorded_crash");
+    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);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerSessionTools.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.js";
 import { readAnalysisSnapshot } from "../application/binary/AnalysisSnapshotFiles.js";
-import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js";
-import { captureProcessScenario } from "../application/ProcessHarness.js";
+import { createProcessCaptureEvidence } from "../application/process/ProcessEvidence.js";
+import { captureProcessScenario } from "../process/capture/ProcessHarness.js";
 import { toolContract } from "../contracts/toolContracts.js";
 import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
 import {} from "../domain/analysisErrorBase.js";

package/dist/server/registerWebNetworkCaptureTool.js

@@ -0,0 +1,28 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind historical inspection to its named contract and caller-owned Evidence writer. */
+export const registerWebNetworkCaptureTool = (server, service, logger, recordEvidence) => {
+    const contract = toolContract("inspect_web_network_capture");
+    const registration = toolRegistrationOptions(contract);
+    // Keep the exact advertised contract; the shared service validates raw input
+    // before effects so caller-declared sensitivity also covers invalid arguments.
+    // SDK pre-validation otherwise emits unprojected issue paths as plain text.
+    const inputSchema = {
+        "~standard": {
+            ...registration.inputSchema["~standard"],
+            vendor: "rea-application",
+            validate: (value) => ({ value }),
+        },
+    };
+    server.registerTool(contract.name, { ...registration, inputSchema }, async (input, context) => {
+        const result = await logToolExecution(logger, contract.name, () => service.inspect(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/sessionAvailabilityPolicy.js

@@ -3,7 +3,10 @@ import { platform } from "node:process";
 export const sessionAvailabilityPolicy = (configured, defaults) => {
     const policy = configured ??
         (() => ({
+            evmInterfaceEnabled: defaults.optionalFeatures?.evmInterfaceEnabled ?? false,
             processCaptureEnabled: platform !== "win32",
+            recordedCrashEnabled: defaults.optionalFeatures?.recordedCrashEnabled ?? false,
+            binaryLayoutEnabled: defaults.optionalFeatures?.binaryLayoutEnabled ?? false,
             firmwareInspectionEnabled: defaults.optionalFeatures?.firmwareInspectionEnabled ?? false,
             firmwareExtractionEnabled: defaults.optionalFeatures?.firmwareExtractionEnabled ?? false,
             androidAnalysisEnabled: defaults.optionalFeatures?.androidAnalysisEnabled ?? false,

package/dist/server/sessionToolPolicies.js

@@ -1,2 +1,2 @@
-export { PROCESS_PROVIDER } from "../application/ProcessEvidence.js";
+export { PROCESS_PROVIDER } from "../application/process/ProcessEvidence.js";
 export { ARTIFACT_COMPARISON_PROVIDER, BUNDLE_COMPARISON_PROVIDER, CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, FUNCTION_COMPARISON_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "../application/InvestigationProviders.js";

package/dist/server/toolResult.js

@@ -3,7 +3,7 @@ import {} from "../domain/analysisErrorBase.js";
 /**
  * Serialize an application result as MCP text and structured content.
  * Shared error projection preserves actionable local diagnostics while omitting
- * raw causes and captured process output.
+ * raw cause objects; explicitly retained bounded command output stays visible.
  */
 export const toCallToolResult = (result, contract) => result.ok ? successResult(result.value, contract) : errorResult(result.error);
 const errorResult = (error) => {

package/native/windows/build/manifest.json

@@ -1,9 +1,9 @@
 {
-  "packageVersion": "5.0.0",
+  "packageVersion": "6.0.0",
   "platform": "win32",
   "architecture": "x64",
   "abiVersion": 1,
   "nodeApiVersion": 8,
   "artifact": "rea-windows-x64.node",
-  "artifactSha256": "f9ae5fa99de3207da630f59be2450febd60c79ed1862abfcf90e9cf080c2c977"
+  "artifactSha256": "9914815706dcd4ef94d01543e31cb0b20035e98d5011d4b4e7f8e509823c8b1d"
 }