rea-agents 4.1.0 → 6.0.0

package/dist/process/capture/ProcessHarness.js

@@ -0,0 +1,452 @@
+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 "../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({
+        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 (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({
+    columns: scenario.terminal.columns,
+    rows: scenario.terminal.rows,
+    scrollback: scenario.terminal.scrollback,
+    maxBytes: scenario.limits.output_bytes,
+    normalize: (value) => normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),
+    recordEvent,
+});
+const startCaptureRuntime = async (options) => {
+    const { scenario } = options;
+    let renderer;
+    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;
+        renderer = createTerminalRenderer(scenario, options.temporaryRoot, () => terminal?.pid ?? -1, options.recordEvent);
+        terminal = spawn(scenario.executable, [...scenario.arguments], {
+            cwd: scenario.working_directory,
+            env: makeProcessCaptureEnvironment(options),
+            cols: scenario.terminal.columns,
+            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,
+            started,
+            onOutput: () => (lastOutput = Date.now()),
+            renderer,
+        });
+        scheduleScenarioInteractions({
+            ...options,
+            getTerminal: () => terminal,
+            renderer,
+            started,
+        });
+        const stopSampler = startProcessSampler({
+            rootPid: terminal.pid,
+            runId: options.runId,
+            started,
+            limit: scenario.limits.processes,
+            samples: options.samples,
+            recordEvent: options.recordEvent,
+        });
+        return {
+            renderer,
+            terminal,
+            started,
+            startedAt,
+            executableIdentity,
+            lastOutput: () => lastOutput,
+            framesTruncated,
+            stopSampler,
+        };
+    }
+    catch (cause) {
+        return cleanupFailedStartup({
+            cause,
+            timers: options.timers,
+            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 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,
+        ...(options.cleanupHost === undefined ? {} : { host: options.cleanupHost }),
+    });
+    const cleanupFailure = cleanupReportFailure(cleanup);
+    let { capture, executionFailure } = options;
+    let verifiedCapture;
+    if (capture !== undefined && cleanupFailure === undefined) {
+        const settlement = capture.settlement.state === "quiesced"
+            ? { ...capture.settlement, cleanup_outcome: "not_required" }
+            : { ...capture.settlement, cleanup_outcome: "cleaned" };
+        const completedCapture = {
+            ...capture,
+            settlement,
+            cleanup: {
+                owned_process_group: "verified",
+                temporary_root: "removed",
+            },
+        };
+        try {
+            verifiedCapture = parseProcessCapture(completedCapture);
+        }
+        catch (cause) {
+            executionFailure = new ProcessCaptureError(`process capture validation failed${cause instanceof Error ? `: ${cause.message}` : ""}`, { cause });
+        }
+    }
+    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);
+};
+/** 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")))
+        return processCaptureCancelled();
+    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();
+    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);
+    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);
+    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",
+            at_ms: 0,
+            files: options.before.files,
+            effects: [],
+            truncated: options.before.truncated,
+        },
+        {
+            name: "after_settlement",
+            at_ms: Math.max(0, Date.now() - runtime.started),
+            files: after.files,
+            effects: classifyFilesystemEffects(options.before.files, after.files),
+            truncated: after.truncated,
+        },
+    ];
+    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() ||
+        checkpoints.some(({ truncated: partial }) => partial) ||
+        samplingPartial ||
+        runtime.renderer.truncated();
+    return buildCaptureResult({
+        frames: options.frames,
+        exit: { ...options.exit, reason },
+        samples: options.samples,
+        before: options.before,
+        after,
+        truncated,
+        scenario,
+        rootPid: runtime.terminal.pid,
+        samplingPartial,
+        renderedFrames,
+        interactions: options.interactions,
+        checkpoints,
+        settlement,
+        manifest,
+        eventJournal: options.eventJournal,
+    });
+};
+/** Execute one caller-selected scenario and return bounded observations. */
+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 dispatchedEventIndexes = new Set();
+    try {
+        runtime = await startCaptureRuntime({
+            scenario,
+            hostEnvironment,
+            temporaryRoot,
+            runId,
+            ownershipBaseline,
+            ...(cleanupHost === undefined ? {} : { cleanupHost }),
+            observationBuffer: observations,
+            onSpawn: (pid) => {
+                actualRootPid = pid;
+            },
+            frames,
+            samples,
+            interactions,
+            timers,
+            dispatchedEventIndexes,
+            recordEvent,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        stopSampler = runtime.stopSampler;
+        const exit = await awaitTerminalExit({
+            terminal: runtime.terminal,
+            scenario,
+            started: runtime.started,
+            lastOutput: runtime.lastOutput,
+            signal,
+            timers,
+            interactions,
+            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,
+            runtime,
+            runId,
+            temporaryRoot,
+            before,
+            frames,
+            samples,
+            interactions,
+            exit,
+            initiallyTruncated: before.truncated,
+            eventJournal,
+            observationBuffer: observations,
+            recordEvent,
+            captureSnapshot,
+            ...(signal === undefined ? {} : { signal }),
+        });
+    }
+    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, 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, cleanupHost));
+    }
+    catch (cause) {
+        const failure = normalizeCaptureFailure(cause, signal);
+        const executionFailureReason = describeProcessCaptureExecutionFailure(cause);
+        return err(failure instanceof ProcessCaptureError
+            ? failure
+            : 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/reference/ReferenceSourceReaderEntries.js

@@ -31,6 +31,12 @@ export const traverseDirectory = async (state, current) => {
         state.entries.push(entryFailure(pathFromRoot(state.root, current.path), "directory", "changed", "Directory changed while it was read"));
         return { ok: true, value: undefined };
     }
+    if (current.path !== state.root)
+        state.entries.push({
+            status: "read",
+            kind: "directory",
+            path: pathFromRoot(state.root, current.path),
+        });
     const directories = [];
     for (const name of names.value) {
         const result = await processEntry(state, current, name, directories);
@@ -102,7 +108,6 @@ const processEntry = async (state, current, name, directories) => {
     if (metadata.value.isSymbolicLink())
         state.entries.push(await describeSymlink(state.root, absolute, path, state.signal));
     else if (metadata.value.isDirectory()) {
-        state.entries.push({ status: "read", kind: "directory", path });
         directories.push({ path: absolute });
     }
     else if (!metadata.value.isFile())

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";
@@ -6,16 +12,28 @@ import { registerApplicationTools } from "./registerApplicationTools.js";
 import { registerArtifactTools } from "./registerArtifactTools.js";
 import { registerBrowserScenarioTool } from "./registerBrowserScenarioTool.js";
 import { registerBrowserTools } from "./registerBrowserTools.js";
+import { registerWebScriptTool } from "./registerWebScriptTool.js";
+import { registerWebModuleTool } from "./registerWebModuleTool.js";
+import { createWebModuleTraceService } from "../composition/webModules.js";
+import { createWebSourceLocationService } from "../composition/webSourceLocations.js";
+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";
 import { registerElectronTools } from "./registerElectronTools.js";
 import { registerEnhancedTools } from "./registerEnhancedTools.js";
 import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
 import { registerManagedTools } from "./registerManagedTools.js";
 import { registerFirmwareTools } from "./registerFirmwareTools.js";
-import { FirmwareAnalysisService } from "../application/FirmwareAnalysisService.js";
-import { FirmwareProvider } from "../firmware/FirmwareProvider.js";
+import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
+import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { registerAndroidTools } from "./registerAndroidTools.js";
-import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
-import { JadxProvider } from "../android/JadxProvider.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 { registerOfficialTools } from "./registerOfficialTools.js";
@@ -28,7 +46,20 @@ const installSessionToolAvailability = (server, session, options) => {
     if (session === undefined)
         return undefined;
     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 ?? "")),
@@ -39,6 +70,10 @@ const installSessionToolAvailability = (server, session, options) => {
                 ((process.platform === "linux" || process.platform === "darwin") &&
                     isAbsolute(process.env.REA_JADX_MCP_JAR ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
+            javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
+                (process.platform === "linux" &&
+                    process.arch === "x64" &&
+                    isAbsolute(process.env.REA_WAKARU_COMMAND ?? "")),
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
             electronAutomationEnabled: options.electronActiveObservation !== undefined,
@@ -82,9 +117,32 @@ export const createServer = (analysis, session, options = {}) => {
         recordEvidenceWithUnknown,
     };
     registerBinaryAnalysisTools(toolContext);
-    registerAndroidTools(server, new AndroidAnalysisService(options.androidAnalysis ?? new JadxProvider()), toolLogger, recordEvidence);
-    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? new FirmwareProvider()), toolLogger, recordEvidence);
+    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
+    const previousOnclose = server.server.onclose;
+    server.server.onclose = () => {
+        previousOnclose?.();
+        void android.close().catch((cause) => {
+            logger.error({ error: cause instanceof Error ? cause.message : String(cause) }, "Android provider cleanup failed");
+        });
+    };
+    const closeServer = server.close.bind(server);
+    server.close = async () => {
+        const results = await Promise.allSettled([closeServer(), android.close()]);
+        for (const result of results)
+            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);
     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, {
@@ -149,22 +207,28 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, logger, active
 };
 const registerObservationTools = ({ evidenceById, server, options, logger, recordEvidence, recordEvidenceWithUnknown, }) => {
     const common = { logger, recordEvidence };
+    registerWebScriptTool(server, common);
     registerBrowserTools(server, {
         ...common,
         browser: options.browserObservation,
+        loadFailure: options.optionalProviderLoadFailures?.browserObservation,
     });
     registerBrowserScenarioTool(server, {
         ...common,
         provider: options.browserScenarioCapture,
+        loadFailure: options.optionalProviderLoadFailures?.browserScenarioCapture,
     });
     registerElectronTools(server, {
         ...common,
         electron: options.electronObservation,
         electronActive: options.electronActiveObservation,
+        observationLoadFailure: options.optionalProviderLoadFailures?.electronObservation,
+        activeLoadFailure: options.optionalProviderLoadFailures?.electronActiveObservation,
     });
     registerJavaScriptRuntimeObservationTools(server, {
         ...common,
         runtime: options.javascriptRuntimeObservation,
+        loadFailure: options.optionalProviderLoadFailures?.javascriptRuntimeObservation,
     });
     registerApplicationTools(server, {
         evidenceById,

package/dist/server/mcpClientMetadata.js

@@ -21,10 +21,13 @@ const capabilityFeatures = (value) => {
     const capabilities = isRecord(value) ? value : {};
     const elicitation = isRecord(capabilities.elicitation)
         ? capabilities.elicitation
-        : {};
+        : undefined;
     return {
-        elicitation_form: elicitation.form !== undefined,
-        elicitation_url: elicitation.url !== undefined,
+        // A declared capability without modes retains the protocol's form-only
+        // compatibility rule; a missing capability still grants no support.
+        elicitation_form: elicitation !== undefined &&
+            (elicitation.form !== undefined || elicitation.url === undefined),
+        elicitation_url: elicitation?.url !== undefined,
         roots: capabilities.roots !== undefined,
         sampling: capabilities.sampling !== 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/registerAndroidTools.js

@@ -1,4 +1,4 @@
-import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
+import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";