rea-agents 6.3.0 → 6.4.0

package/dist/server/createServer.js

@@ -1,4 +1,6 @@
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
+import { createPeResourcesService } from "../composition/binaryDiagnostics.js";
+import { registerPeResourcesTool } from "./registerPeResourcesTool.js";
 import { createEvmInterfaceService } from "../composition/evm.js";
 import { registerEvmTools } from "./registerEvmTools.js";
 import { registerRecordedCrashTools } from "./registerRecordedCrashTools.js";
@@ -9,6 +11,7 @@ import { createBinaryLayoutService } from "../composition/binaryDiagnostics.js";
 import { EvidenceMcpServer } from "./EvidenceMcpServer.js";
 import { createToolResultDelivery, } from "./toolResult.js";
 import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
+import { COMPACT_INPUT_SCHEMA_BUDGET_BYTES, parseMcpInputSchemaProfile, } from "../config/mcpInputSchemaProfile.js";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
@@ -29,6 +32,7 @@ import { registerJavaScriptRecoveryTool } from "./registerJavaScriptRecoveryTool
 import { JavaScriptRecoveryService } from "../application/javascript/JavaScriptRecoveryService.js";
 import { createJavaScriptRecoveryProvider } from "../composition/javascriptRecovery.js";
 import { registerElectronTools } from "./registerElectronTools.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { registerEnhancedTools } from "./registerEnhancedTools.js";
 import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
 import { registerManagedTools } from "./registerManagedTools.js";
@@ -36,8 +40,17 @@ import { registerFirmwareTools } from "./registerFirmwareTools.js";
 import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
 import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { registerAndroidTools } from "./registerAndroidTools.js";
+import { registerApktoolTools } from "./registerApktoolTools.js";
+import { registerJebTools } from "./registerJebTools.js";
+import { registerAdbTools } from "./registerAdbTools.js";
 import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
+import { JebAnalysisService } from "../application/jeb/JebAnalysisService.js";
+import { ApktoolResourceAnalysisService } from "../application/apktool/ApktoolResourceAnalysisService.js";
 import { createAndroidAnalysisProvider } from "../composition/android.js";
+import { createApktoolResourceAnalysisProvider } from "../composition/apktool.js";
+import { createJebAnalysisProvider } from "../composition/jeb.js";
+import { AdbDeviceAnalysisService } from "../application/adb/AdbDeviceAnalysisService.js";
+import { createAdbDeviceAnalysisProvider } from "../composition/adb.js";
 import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
 import { NATIVE_TOOL_CONTRACTS } from "../contracts/native/nativeToolContracts.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
@@ -79,7 +92,7 @@ const installSessionToolAvailability = (session, options, environment) => {
         policy,
     };
 };
-const createMcpServer = (session, delivery) => new EvidenceMcpServer({
+const createMcpServer = (session, delivery, compactPresentation) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -89,7 +102,7 @@ const createMcpServer = (session, delivery) => new EvidenceMcpServer({
         : TARGET_FREE_INSTRUCTIONS,
 }, session === undefined
     ? undefined
-    : (evidence) => session.recordEvidence(evidence), delivery);
+    : (evidence) => session.recordEvidence(evidence), delivery, compactPresentation);
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -100,14 +113,56 @@ export const createServer = (source, options = {}) => {
     const analysis = source.kind === "session" ? source.session : source.analysis;
     const environment = snapshotEnvironment(options.environment ?? process.env);
     const delivery = selectToolResultDelivery(environment, options.delivery);
-    const selectedOptions = { ...options, environment, delivery };
+    const evmInterface = options.evmInterface ?? createEvmInterfaceService(environment);
+    const webSourceLocation = options.webSourceLocation ?? createWebSourceLocationService(environment);
+    const javascriptRecovery = options.javascriptRecovery ?? createJavaScriptRecoveryProvider(environment);
+    const artifactResources = new ArtifactResourceScope();
+    const firmwareAnalysis = new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider(environment));
+    const selectedOptions = {
+        ...options,
+        environment,
+        delivery,
+        evmInterface,
+        webSourceLocation,
+        javascriptRecovery,
+    };
     const startedAt = new Date().toISOString();
     const logger = options.logger ?? silentLogger;
-    const server = createMcpServer(session, delivery);
+    const server = createMcpServer(session, delivery, selectCompactInputSchemaPresentation(environment));
     const android = options.androidAnalysis ?? createAndroidAnalysisProvider(environment);
-    const availability = installSessionToolAvailability(session, selectedOptions, environment);
+    const apktool = options.apktoolAnalysis ??
+        createApktoolResourceAnalysisProvider(environment);
+    const jeb = options.jebAnalysis ?? createJebAnalysisProvider(environment);
+    const adbDevice = options.adbDeviceAnalysis ?? createAdbDeviceAnalysisProvider(environment);
+    let providerClose;
+    const closeProviders = () => {
+        providerClose ??= Promise.allSettled([
+            android.close(),
+            apktool.close(),
+            jeb.close(),
+            adbDevice.close(),
+            evmInterface.close(),
+            webSourceLocation.close(),
+            javascriptRecovery.close?.() ?? Promise.resolve(),
+            artifactResources.close(),
+            firmwareAnalysis.close(),
+            options.browserScenarioCapture?.close?.() ?? Promise.resolve(),
+        ])
+            .then((results) => {
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length > 0)
+                throw new AggregateError(failures, "REA provider cleanup failed");
+        })
+            .catch((cause) => {
+            providerClose = undefined;
+            throw cause;
+        });
+        return providerClose;
+    };
+    const availability = installSessionToolAvailability(session, options, environment);
     const toolLogger = logger.child({ layer: "server" });
     const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
+    const analysisAdmission = withAdmittedAnalysis(source);
     const toolContext = {
         server,
         session,
@@ -118,24 +173,27 @@ export const createServer = (source, options = {}) => {
         activeTarget,
         recordEvidence,
         recordEvidenceWithUnknown,
-        withAdmittedAnalysis: withAdmittedAnalysis(source),
+        withAdmittedAnalysis: analysisAdmission,
+        artifactResources,
     };
     registerBinaryAnalysisTools(toolContext);
     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");
+        void closeProviders().catch((cause) => {
+            logger.error({ error: cause instanceof Error ? cause.message : String(cause) }, "Provider cleanup failed during server shutdown");
         });
     };
     const closeServer = server.close.bind(server);
     server.close = async () => {
-        const results = await Promise.allSettled([closeServer(), android.close()]);
+        const results = await Promise.allSettled([closeServer(), closeProviders()]);
         for (const result of results)
             if (result.status === "rejected")
                 throw result.reason;
     };
-    registerConfiguredAnalysisTools(toolContext, android);
+    registerConfiguredAnalysisTools(toolContext, android, jeb, firmwareAnalysis);
+    registerAdbTools(server, new AdbDeviceAnalysisService(adbDevice), toolLogger, recordEvidence, analysisAdmission);
+    registerApktoolTools(server, new ApktoolResourceAnalysisService(apktool), toolLogger, recordEvidence, analysisAdmission);
     registerObservationTools(toolContext);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
@@ -158,19 +216,29 @@ const selectToolResultDelivery = (environment, selected) => {
         throw configured.error;
     return createToolResultDelivery(configured.value);
 };
-const registerConfiguredAnalysisTools = ({ server, options, environment, logger: toolLogger, evidenceById, recordEvidence, }, android) => {
-    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
-    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(environment), toolLogger, recordEvidence);
-    registerAnalysisViewTool(server, toolLogger, evidenceById, recordEvidence);
-    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(environment), toolLogger, recordEvidence);
-    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(environment), toolLogger, recordEvidence);
-    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider(environment)), toolLogger, recordEvidence);
-    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(environment), toolLogger, recordEvidence);
-    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(environment), toolLogger, recordEvidence);
-    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
-    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(environment), toolLogger, recordEvidence);
+const selectCompactInputSchemaPresentation = (environment) => {
+    const configured = parseMcpInputSchemaProfile(environment.REA_MCP_INPUT_SCHEMA_PROFILE);
+    if (!configured.ok)
+        throw configured.error;
+    return configured.value === "compact"
+        ? { budgetBytes: COMPACT_INPUT_SCHEMA_BUDGET_BYTES }
+        : undefined;
+};
+const registerConfiguredAnalysisTools = ({ server, options, environment, logger: toolLogger, evidenceById, recordEvidence, withAdmittedAnalysis, }, android, jeb, firmwareAnalysis) => {
+    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerJebTools(server, new JebAnalysisService(jeb), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(environment), toolLogger, recordEvidence, evidenceById, withAdmittedAnalysis);
+    registerAnalysisViewTool(server, toolLogger, evidenceById, recordEvidence, withAdmittedAnalysis);
+    registerPeResourcesTool(server, createPeResourcesService(), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(environment), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(environment), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerFirmwareTools(server, firmwareAnalysis, toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(environment), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(environment), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence, withAdmittedAnalysis);
+    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(environment), toolLogger, recordEvidence, withAdmittedAnalysis);
     registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ??
-        createJavaScriptRecoveryProvider(environment)), toolLogger, recordEvidence);
+        createJavaScriptRecoveryProvider(environment)), toolLogger, recordEvidence, withAdmittedAnalysis);
 };
 const createSessionRecorders = (server, session) => ({
     evidenceById: session === undefined
@@ -222,11 +290,12 @@ const registerBinaryAnalysisTools = ({ server, session, logger, activeTarget, re
             recordEvidence,
             recordEvidenceWithUnknown,
             session,
+            withAdmittedAnalysis,
         });
 };
-const registerObservationTools = ({ evidenceById, server, options, logger, recordEvidence, recordEvidenceWithUnknown, }) => {
-    const common = { logger, recordEvidence };
-    registerWebScriptTool(server, common);
+const registerObservationTools = ({ evidenceById, server, options, logger, recordEvidence, recordEvidenceWithUnknown, withAdmittedAnalysis, artifactResources, }) => {
+    const common = { logger, recordEvidence, withAdmittedAnalysis };
+    registerWebScriptTool(server, { ...common, artifactResources });
     registerBrowserTools(server, {
         ...common,
         browser: options.browserObservation,
@@ -239,6 +308,8 @@ const registerObservationTools = ({ evidenceById, server, options, logger, recor
     });
     registerElectronTools(server, {
         ...common,
+        artifactResources,
+        evidenceById,
         electron: options.electronObservation,
         electronActive: options.electronActiveObservation,
         observationLoadFailure: options.optionalProviderLoadFailures?.electronObservation,
@@ -254,5 +325,6 @@ const registerObservationTools = ({ evidenceById, server, options, logger, recor
         logger,
         recordEvidence,
         recordEvidenceWithUnknown,
+        withAdmittedAnalysis,
     });
 };

package/dist/server/registerAdbTools.js

@@ -0,0 +1,36 @@
+import { AdbDeviceAnalysisService } from "../application/adb/AdbDeviceAnalysisService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { createContractToolHandler } from "./contractToolHandler.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+/** Bind ADB handlers to their exact named contracts through shared workflows. */
+export const registerAdbTools = (server, service, logger, recordEvidence, withAdmittedAnalysis) => {
+    const handler = createContractToolHandler(server, service, logger, recordEvidence, withAdmittedAnalysis);
+    for (const contract of [
+        toolContract("inspect_adb_client"),
+        toolContract("list_adb_devices"),
+        toolContract("inspect_adb_device"),
+        toolContract("list_adb_packages"),
+        toolContract("pull_adb_package"),
+        toolContract("read_adb_logcat"),
+        toolContract("inspect_adb_package"),
+        toolContract("pull_adb_file"),
+        toolContract("push_adb_file"),
+        toolContract("capture_adb_screen"),
+        toolContract("list_adb_processes"),
+        toolContract("list_adb_directory"),
+        toolContract("list_adb_features"),
+        toolContract("list_adb_services"),
+        toolContract("inspect_adb_display"),
+        toolContract("inspect_adb_window"),
+        toolContract("read_adb_setting"),
+        toolContract("collect_adb_bugreport"),
+        toolContract("resolve_adb_packages"),
+        toolContract("install_adb_package"),
+        toolContract("uninstall_adb_package"),
+        toolContract("start_adb_app"),
+        toolContract("start_adb_activity"),
+        toolContract("stop_adb_app"),
+    ]) {
+        server.registerTool(contract.name, toolRegistrationOptions(contract), handler(contract));
+    }
+};

package/dist/server/registerAnalysisViewTool.js

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

package/dist/server/registerAndroidTools.js

@@ -1,19 +1,10 @@
 import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
 import { toolContract } from "../contracts/toolContracts.js";
-import { logToolExecution } from "./toolLogging.js";
+import { createContractToolHandler } from "./contractToolHandler.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 /** Bind Android handlers to their exact named contracts through shared workflows. */
-export const registerAndroidTools = (server, service, logger, recordEvidence) => {
-    const handler = (contract) => {
-        const name = contract.name;
-        return async (input, context) => {
-            const result = await logToolExecution(logger, name, () => service.execute(name, input, { signal: context.mcpReq.signal }));
-            if (!result.ok)
-                return server.delivery.toCallToolResult(result, contract);
-            const recorded = recordEvidence?.(result.value);
-            return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
-        };
-    };
+export const registerAndroidTools = (server, service, logger, recordEvidence, withAdmittedAnalysis) => {
+    const handler = createContractToolHandler(server, service, logger, recordEvidence, withAdmittedAnalysis);
     const packageContract = toolContract("inspect_android_package");
     server.registerTool(packageContract.name, toolRegistrationOptions(packageContract), handler(packageContract));
     const searchContract = toolContract("search_android_classes");

package/dist/server/registerApktoolTools.js

@@ -0,0 +1,14 @@
+import { ApktoolResourceAnalysisService } from "../application/apktool/ApktoolResourceAnalysisService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { createContractToolHandler } from "./contractToolHandler.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+/** Bind Apktool handlers to their exact named contracts. */
+export const registerApktoolTools = (server, service, logger, recordEvidence, withAdmittedAnalysis) => {
+    const handler = createContractToolHandler(server, service, logger, recordEvidence, withAdmittedAnalysis);
+    for (const contract of [
+        toolContract("inspect_apktool_client"),
+        toolContract("decode_android_resources"),
+    ]) {
+        server.registerTool(contract.name, toolRegistrationOptions(contract), handler(contract));
+    }
+};

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
@@ -9,7 +10,7 @@ import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
 export const registerCompareJavaScriptExportShapesTool = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
         const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, contract);
@@ -17,15 +18,12 @@ export const registerCompareJavaScriptExportShapesTool = (server, options) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareJavaScriptExportShapesEvidenceValidated(parsed)));
         if (!result.ok)
             return server.delivery.toCallToolResult(result, contract);
-        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
-            parsed.left,
-            parsed.right,
-        ]);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [parsed.left, parsed.right]);
         if (!recorded.ok)
             return server.delivery.toCallToolResult(recorded, contract);
         const comparison = javaScriptExportShapeComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0 ||
             comparison.coverage.status !== "complete-within-inputs";
         return recordResult({ ...options, delivery: server.delivery }, contract, result.value, unknown ? "javascript-export-shape" : undefined);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareSourceToBundleEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
@@ -9,7 +10,7 @@ import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
 export const registerCompareSourceToBundleTool = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, contract);
@@ -17,14 +18,12 @@ export const registerCompareSourceToBundleTool = (server, options) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(parsed)));
         if (!result.ok)
             return server.delivery.toCallToolResult(result, contract);
-        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
-            parsed.application,
-        ]);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [parsed.application]);
         if (!recorded.ok)
             return server.delivery.toCallToolResult(recorded, contract);
         const comparison = sourceToBundleComparisonResultSchema.parse(result.value.normalized_result);
         return recordResult({ ...options, delivery: server.delivery }, contract, result.value, comparison.summary.unknown > 0
             ? "source-to-bundle-comparison"
             : undefined);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { compareApplicationVersionsEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
@@ -9,7 +10,7 @@ import { recordResult } from "./helpers.js";
 const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
 export const registerCompareApplicationVersionsTool = (server, options) => {
-    server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
+    server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, compareContract.name, context.mcpReq.signal, async () => {
         const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, compareContract);
@@ -29,5 +30,5 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
         const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
         return recordResult({ ...options, delivery: server.delivery }, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { evaluateReconstructionCoverage } from "../../application/ReconstructionCoverageService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
@@ -5,8 +6,8 @@ import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 const contract = applicationToolContract("evaluate_reconstruction_coverage");
 /** Register the inline fail-closed reconstruction coverage evaluator. */
 export const registerCoverageTools = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionCoverage(input)));
         return server.delivery.toCallToolResult(result, contract);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstructionObligationLedgerRequest, } from "../../application/ReconstructionObligationLedgerService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
@@ -7,7 +8,7 @@ import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("build_reconstruction_obligation_ledger");
 /** Register conservative reconstruction-obligation generation and closure. */
 export const registerReconstructionObligationLedgerTool = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
         const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, contract);
@@ -18,5 +19,5 @@ export const registerReconstructionObligationLedgerTool = (server, options) => {
         if (!recorded.ok)
             return server.delivery.toCallToolResult(recorded, contract);
         return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/projectMobileApplicationGraph.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { projectAndroidApplicationEvidence } from "../../application/android/AndroidApplicationService.js";
 import { projectAppleApplicationEvidence } from "../../application/apple/AppleApplicationService.js";
 import { APPLICATION_TOOL_CONTRACTS, applicationToolContract, } from "../../contracts/applicationToolContracts.js";
@@ -22,7 +23,7 @@ export const registerProjectMobileApplicationGraphTools = (server, options) => {
 };
 const registerProjection = (context) => {
     const { server, options, contract, project } = context;
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, request) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, request.mcpReq.signal, async () => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(project(input)));
         if (!result.ok)
             return server.delivery.toCallToolResult(result, contract);
@@ -30,7 +31,7 @@ const registerProjection = (context) => {
         if (!recordedSources.ok)
             return server.delivery.toCallToolResult(recordedSources, contract);
         return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
-    });
+    }));
 };
 const inventoryEvidenceSources = (input) => {
     if (typeof input !== "object" ||

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceApplicationFeatureEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
@@ -8,7 +9,7 @@ import { recordResult } from "./helpers.js";
 const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
 export const registerTraceFeatureTool = (server, options) => {
-    server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
+    server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, traceContract.name, context.mcpReq.signal, async () => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, traceContract);
@@ -21,5 +22,5 @@ export const registerTraceFeatureTool = (server, options) => {
         if (!recorded.ok)
             return server.delivery.toCallToolResult(recorded, traceContract);
         return recordResult({ ...options, delivery: server.delivery }, traceContract, result.value);
-    });
+    }));
 };

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,3 +1,4 @@
+import { runAdmittedToolOperation } from "../admittedToolOperation.js";
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/javascript/JavaScriptSemanticTraceService.js";
@@ -8,7 +9,7 @@ import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
 export const registerTraceJavaScriptSemanticsTool = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
             return server.delivery.toCallToolResult(resolved, contract);
@@ -16,11 +17,9 @@ export const registerTraceJavaScriptSemanticsTool = (server, options) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(parsed)));
         if (!result.ok)
             return server.delivery.toCallToolResult(result, contract);
-        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
-            parsed.application,
-        ]);
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [parsed.application]);
         if (!recorded.ok)
             return server.delivery.toCallToolResult(recorded, contract);
         return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
-    });
+    }));
 };

package/dist/server/registerArtifactComparisonTool.js

@@ -6,9 +6,12 @@ import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
 import { ARTIFACT_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { withAdmittedAnalysis } from "./analysisAdmission.js";
+import { runAdmittedToolOperation } from "./admittedToolOperation.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+    const admission = withAdmittedAnalysis({ kind: "session", session });
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => runAdmittedToolOperation(server, admission, contract.name, context.mcpReq.signal, async () => {
         const computed = await runDerivedOperation(context, contract.name, () => {
             const left = parseEvidence(input.left);
             const right = parseEvidence(input.right);
@@ -39,7 +42,7 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
         return server.delivery.toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status, evidence.evidence_id)));
-    });
+    }));
 };
 const artifactUnknownInput = (left, right, status, comparisonEvidenceId) => {
     if (status === "unchanged")

package/dist/server/registerBinaryDiagnosticsTools.js

@@ -1,14 +1,26 @@
+import { summarizeRetainedAnalysis } from "../application/analysisView/AnalysisViewService.js";
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { runAdmittedToolOperation } from "./admittedToolOperation.js";
 /** Bind offline layout inspection to its named contract and session Evidence owner. */
-export const registerBinaryDiagnosticsTools = (server, service, logger, recordEvidence) => {
+export const registerBinaryDiagnosticsTools = (server, service, logger, recordEvidence, evidenceById, withAdmittedAnalysis) => {
     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 }));
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async ({ detail, ...request }, context) => runAdmittedToolOperation(server, withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
+        const result = await logToolExecution(logger, contract.name, async () => {
+            const inspected = await service.inspect(request, {
+                signal: context.mcpReq.signal,
+            });
+            return detail === "summary" && inspected.ok
+                ? summarizeRetainedAnalysis(inspected.value, {
+                    recordEvidence,
+                    evidenceById,
+                })
+                : inspected;
+        });
         if (!result.ok)
             return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
         return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
-    });
+    }));
 };

package/dist/server/registerBrowserScenarioTool.js

@@ -5,6 +5,7 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { runAdmittedToolOperation } from "./admittedToolOperation.js";
 /** Register the browser scenario tool with execution-time provider diagnostics. */
 export const registerBrowserScenarioTool = (server, options) => {
     const contract = toolContract("capture_browser_scenario");
@@ -12,12 +13,14 @@ export const registerBrowserScenarioTool = (server, options) => {
         const scenario = browserScenarioSchema.parse(input);
         if (options.loadFailure !== undefined)
             return server.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
-        const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, scenario, {
-            signal: context.mcpReq.signal,
-        }));
-        if (!result.ok)
-            return server.delivery.toCallToolResult(result, contract);
-        const recorded = options.recordEvidence?.(result.value);
-        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
+        return runAdmittedToolOperation(server, options.withAdmittedAnalysis, contract.name, context.mcpReq.signal, async () => {
+            const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, scenario, {
+                signal: context.mcpReq.signal,
+            }));
+            if (!result.ok)
+                return server.delivery.toCallToolResult(result, contract);
+            const recorded = options.recordEvidence?.(result.value);
+            return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
+        });
     });
 };