rea-agents 3.2.0 → 4.0.0

package/dist/server/registerEnhancedTools.js

@@ -1,6 +1,6 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
-import { ENHANCED_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { UnknownRegistryError } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
@@ -10,7 +10,24 @@ import { toCallToolResult } from "./toolResult.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerEnhancedTools = (server, analysis, options) => {
-    const [nativeDispatchMetadata, objcClasses, objcProtocols, batchDecompile, callGraph, swiftTypes, xrefsToName, binaryOverview, analyzeFunction, inspectNativeApi, traceFeature, codeForString, traceCallPath, traceNativeUiAction,] = ENHANCED_TOOL_CONTRACTS;
+    const nativeDispatchMetadata = toolContract("inspect_native_dispatch_metadata");
+    const objcClasses = toolContract("get_objc_classes");
+    const objcProtocols = toolContract("get_objc_protocols");
+    const batchDecompile = toolContract("batch_decompile");
+    const callGraph = toolContract("get_call_graph");
+    const swiftTypes = toolContract("analyze_swift_types");
+    const xrefsToName = toolContract("find_xrefs_to_name");
+    const binaryOverview = toolContract("binary_overview");
+    const analyzeFunction = toolContract("analyze_function");
+    const inspectNativeApi = toolContract("inspect_native_api");
+    const traceFeature = toolContract("trace_feature");
+    const traceCallPath = toolContract("trace_call_path");
+    const traceNativeUiAction = toolContract("trace_native_ui_action");
+    const traceNativeValues = toolContract("trace_native_values");
+    server.registerTool(traceNativeValues.name, toolRegistrationOptions(traceNativeValues), (input, context) => executeEnhancedTool(analysis, options, traceNativeValues, {
+        validatedCall: { name: "trace_native_values", input },
+        context,
+    }));
     server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(analysis, options, nativeDispatchMetadata, {
         validatedCall: { name: "inspect_native_dispatch_metadata", input },
         context,
@@ -55,10 +72,6 @@ export const registerEnhancedTools = (server, analysis, options) => {
         validatedCall: { name: "trace_feature", input },
         context,
     }));
-    server.registerTool(codeForString.name, toolRegistrationOptions(codeForString), (input, context) => executeEnhancedTool(analysis, options, codeForString, {
-        validatedCall: { name: "find_code_for_string", input },
-        context,
-    }));
     server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, options, traceCallPath, {
         validatedCall: { name: "trace_call_path", input },
         context,
@@ -127,12 +140,7 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
 };
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
 const recordWorkflowUnknowns = ({ name, result, evidenceId, recordUnknown, }) => {
-    if (![
-        "trace_feature",
-        "find_code_for_string",
-        "trace_call_path",
-        "inspect_native_api",
-    ].includes(name) ||
+    if (!["trace_feature", "trace_call_path", "inspect_native_api"].includes(name) ||
         recordUnknown === undefined ||
         typeof result !== "object" ||
         result === null ||

package/dist/server/registerEvidenceTools.js

@@ -1,12 +1,10 @@
-import { projectPermissionFailure } from "../application/PermissionFailure.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { err } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
-import { artifactExtractionPermissionRequest, createArtifactExtractionDestination, } from "../application/ArtifactExtractionDestination.js";
+import { createArtifactExtractionDestination } from "../application/ArtifactExtractionDestination.js";
 /** Register provider-backed contracts that return atomic Evidence observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
     for (const contract of contracts) {
@@ -25,14 +23,6 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                     output_root: createArtifactExtractionDestination(),
                 }
                 : parameters;
-            if (options.permissionAuthority !== undefined) {
-                const request = permissionRequest(contract.name, executionParameters);
-                if (request !== undefined) {
-                    const authorized = await options.permissionAuthority.authorize(request, contract.name === "extract_artifact" ? "write" : "read");
-                    if (!authorized.ok)
-                        return toCallToolResult(err(projectPermissionFailure(authorized.error)), contract);
-                }
-            }
             const execution = await logToolExecution(options.logger, contract.name, () => analysis.execute(contract.name, executionParameters, {
                 signal: context.mcpReq.signal,
                 progress,
@@ -51,6 +41,9 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 operation: contract.name,
                 parameters,
                 result: execution.value.result,
+                ...(execution.value.analysisProfile === undefined
+                    ? {}
+                    : { analysisProfile: execution.value.analysisProfile }),
                 rawResult: execution.value.rawResult,
                 limitations: execution.value.limitations,
                 locations: execution.value.locations,
@@ -68,20 +61,3 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
         });
     }
 };
-const permissionRequest = (operation, parameters) => {
-    if (operation === "extract_artifact" &&
-        typeof parameters.output_root === "string")
-        return artifactExtractionPermissionRequest();
-    if (operation === "inspect_artifact" &&
-        parameters.native_mount_approved === true)
-        return {
-            capability: "native_mount",
-            roots: [],
-            executables: [],
-            environment_names: [],
-            network: "none",
-            mount: true,
-            operation_identity: `${operation}:native_mount`,
-        };
-    return undefined;
-};

package/dist/server/registerFunctionComparisonTool.js

@@ -1,4 +1,4 @@
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { EvidenceIntegrityError } from "../domain/errors.js";
 import { err } from "../domain/result.js";

package/dist/server/registerInvestigationTools.js

@@ -1,4 +1,4 @@
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { buildCallPath } from "../domain/callPath.js";
 import { findChangedBehavior } from "../domain/changedBehavior.js";
 import { createEvidence } from "../domain/evidence.js";
@@ -11,11 +11,11 @@ import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER,
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-composed differential investigation workflows. */
-export const registerInvestigationTools = (server, session, contracts) => {
-    registerChangedBehavior(server, session, contracts[0]);
-    registerCallPath(server, session, contracts[1]);
-    registerStaticRuntime(server, session, contracts[2]);
-    registerReconstruction(server, session, contracts[3]);
+export const registerInvestigationTools = (server, session) => {
+    registerChangedBehavior(server, session, toolContract("find_changed_behavior"));
+    registerCallPath(server, session, toolContract("build_call_path"));
+    registerStaticRuntime(server, session, toolContract("correlate_static_and_runtime"));
+    registerReconstruction(server, session, toolContract("verify_reconstruction"));
 };
 const registerChangedBehavior = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -7,10 +7,10 @@ import { toCallToolResult } from "./toolResult.js";
 /** Register passive Inspector tools even when policy keeps them unavailable. */
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
     const [listContract, observeContract] = JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS;
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal })));
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, parsed, { signal })));
     server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, async (parsed, signal) => {
         const request = observeJavaScriptRuntimeInputSchema.parse(parsed);
-        return observeJavaScriptRuntime(options.runtime, options.permissionAuthority, request, { signal });
+        return observeJavaScriptRuntime(options.runtime, request, { signal });
     }));
 };
 const runRuntimeTool = async (options, contract, request, execute) => {

package/dist/server/registerManagedTools.js

@@ -1,23 +1,37 @@
 import { MANAGED_TOOL_CONTRACTS } from "../contracts/managedToolContracts.js";
+import { AnalysisInputError } from "../domain/errors.js";
 import { err } from "../domain/result.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
+import { runManagedProviderExecution } from "../application/DirectAnalysis.js";
+import { isManagedToolName } from "../contracts/managedToolContracts.js";
 /** Register execution-free managed PE/CLI inspection. */
 export const registerManagedTools = (server, analysis, options) => {
-    const targetAwareAnalysis = {
+    let selectedManagedPath;
+    const managedAnalysis = {
         execute: async (operation, parameters, executionOptions) => {
-            const path = operation === "inspect_managed_artifact" &&
-                typeof parameters.path === "string"
-                ? parameters.path
-                : undefined;
-            if (path !== undefined && options.session !== undefined) {
-                const opened = await options.session.open(path, executionOptions?.signal === undefined
-                    ? undefined
-                    : { signal: executionOptions.signal });
-                if (!opened.ok)
-                    return err(opened.error);
-            }
-            return analysis.execute(operation, parameters, executionOptions);
+            if (!isManagedToolName(operation))
+                return analysis.execute(operation, parameters, executionOptions);
+            const requestedPath = parameters.path;
+            const activeTarget = options.activeTarget?.();
+            const path = typeof requestedPath === "string"
+                ? requestedPath
+                : (selectedManagedPath ??
+                    (activeTarget?.format === "pe" && activeTarget.managed
+                        ? activeTarget.path
+                        : undefined));
+            if (path === undefined)
+                return err(new AnalysisInputError(operation, undefined, [
+                    {
+                        path: ["path"],
+                        reason: "missing_argument",
+                        message: "Provide a managed PE/CLI path or first select one with inspect_managed_artifact.",
+                    },
+                ]));
+            const execution = await runManagedProviderExecution(path, operation, executionOptions?.signal);
+            if (execution.ok && typeof requestedPath === "string")
+                selectedManagedPath = requestedPath;
+            return execution;
         },
     };
-    registerEvidenceTools(server, targetAwareAnalysis, MANAGED_TOOL_CONTRACTS, options);
+    registerEvidenceTools(server, managedAnalysis, MANAGED_TOOL_CONTRACTS, options);
 };

package/dist/server/registerManagedWorkflowTools.js

@@ -1,13 +1,11 @@
 import { registerCompareManagedMembers } from "./registerManagedWorkflowTools/compareManagedMembers.js";
 import { registerVerifyManagedNativeBoundaries } from "./registerManagedWorkflowTools/verifyManagedNativeBoundaries.js";
 import { registerImportManagedReconstruction } from "./registerManagedWorkflowTools/importManagedReconstruction.js";
-import { registerPlanManagedRuntimeCorrelation } from "./registerManagedWorkflowTools/planManagedRuntimeCorrelation.js";
 import { registerProjectManagedApplicationGraph } from "./registerManagedWorkflowTools/projectManagedApplicationGraph.js";
 /** Register provider-neutral managed-code workflows. */
 export const registerManagedWorkflowTools = (server, options) => {
     registerCompareManagedMembers(server, options);
     registerVerifyManagedNativeBoundaries(server, options);
     registerImportManagedReconstruction(server, options);
-    registerPlanManagedRuntimeCorrelation(server, options);
     registerProjectManagedApplicationGraph(server, options);
 };

package/dist/server/registerProcessComparisonTool.js

@@ -1,4 +1,4 @@
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { EvidenceIntegrityError } from "../domain/errors.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
@@ -92,9 +92,7 @@ const comparisonUnknownInput = (parsed, comparison) => {
         ["interaction", comparison.interaction],
         ["exit", comparison.exit],
         ["filesystem", comparison.filesystem],
-        ["protocol", comparison.protocol],
         ["process", comparison.process],
-        ["shim", comparison.shim],
     ]
         .filter(([, status]) => status !== "unchanged")
         .map(([scope]) => scope)

package/dist/server/registerSessionRecordTools.js

@@ -1,5 +1,5 @@
 import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { ok } from "../domain/result.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
@@ -47,8 +47,8 @@ const registerImportEvidenceTool = ({ server, session, importContract, }) => {
 };
 const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
 /** Register residual-unknown query and mutation tools. */
-const registerListUnknownsTool = ({ server, session, contracts, }) => {
-    const listContract = contracts[14];
+const registerListUnknownsTool = ({ server, session, }) => {
+    const listContract = toolContract("list_unknowns");
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
         const filters = input;
         const all = session.listUnknowns({
@@ -64,22 +64,22 @@ const registerListUnknownsTool = ({ server, session, contracts, }) => {
         }), listContract);
     });
 };
-const registerRecordUnknownTool = ({ server, session, contracts, }) => {
-    const recordContract = contracts[15];
+const registerRecordUnknownTool = ({ server, session, }) => {
+    const recordContract = toolContract("record_unknown");
     server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
         const result = session.recordUnknown(input);
         return toCallToolResult(result, recordContract);
     });
 };
-const registerUpdateUnknownTool = ({ server, session, contracts, }) => {
-    const updateContract = contracts[16];
+const registerUpdateUnknownTool = ({ server, session, }) => {
+    const updateContract = toolContract("update_unknown");
     server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
         const result = session.updateUnknown(input);
         return toCallToolResult(result, updateContract);
     });
 };
-const registerVerifyUnknownTool = ({ server, session, contracts, }) => {
-    const verifyContract = contracts[17];
+const registerVerifyUnknownTool = ({ server, session, }) => {
+    const verifyContract = toolContract("verify_unknown_resolution");
     server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => toCallToolResult(session.verifyUnknownResolution(input.unknown_id), verifyContract));
 };
 export const registerUnknownTools = (registration) => {

package/dist/server/registerSessionStatusTool.js

@@ -1,5 +1,5 @@
 import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { mcpClientMetadata } from "./mcpClientMetadata.js";

package/dist/server/registerSessionTools.js

@@ -1,31 +1,25 @@
 import { z } from "zod";
-import { isInputRequiredResult } from "@modelcontextprotocol/server";
 import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.js";
 import { readAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
-import { processCapturePermissionRequest } from "../application/ProcessCapturePermission.js";
 import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js";
 import { captureProcessScenario } from "../application/ProcessHarness.js";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { UnknownRegistryError } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
-import { projectPermissionFailure } from "../application/PermissionFailure.js";
+import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { authorizeProcessCaptureWithElicitation, } from "./ProcessCaptureElicitation.js";
 import { registerArtifactComparisonTool } from "./registerArtifactComparisonTool.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
 import { registerCloseLifecycleTool } from "./registerCloseLifecycleTool.js";
 import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
 import { registerInvestigationTools } from "./registerInvestigationTools.js";
 import { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
-import { registerReplayMachineTool } from "./registerReplayMachineTool.js";
 import { registerEvidenceTools, registerUnknownTools, } from "./registerSessionRecordTools.js";
 import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
-import { DENY_PROCESS_POLICY } from "./sessionToolPolicies.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
-const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) => {
+const recordProcessResidualUnknowns = (session, evidence, residuals) => {
     for (const residual of residuals) {
         const unknown = session.recordUnknown({
             question: `Was ${residual.scope} behavior fully observed during capture?`,
@@ -51,19 +45,9 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
     }
     return ok(null);
 };
-const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, processCaptureElicitation, }) => {
+const registerProcessTools = ({ server, session, logger, captureContract, }) => {
     server.registerTool(captureContract.name, toolRegistrationOptions(captureContract), async (input, context) => {
         const scenario = input;
-        if (permissionAuthority !== undefined) {
-            const request = processCapturePermissionRequest(scenario);
-            const authorized = processCaptureElicitation === undefined
-                ? await permissionAuthority.authorize(request, "read")
-                : await authorizeProcessCaptureWithElicitation(permissionAuthority, request, context, processCaptureElicitation);
-            if (isInputRequiredResult(authorized))
-                return authorized;
-            if (!authorized.ok)
-                return toCallToolResult(err(projectPermissionFailure(authorized.error)), captureContract);
-        }
         const progress = mcpProgressReporter(context);
         await progress.report({
             phase: captureContract.name,
@@ -71,7 +55,7 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
             total: 1,
             message: "started",
         });
-        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, processPolicy(), context.mcpReq.signal));
+        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, context.mcpReq.signal));
         await progress.report({
             phase: captureContract.name,
             completed: 1,
@@ -85,25 +69,25 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
         const recorded = session.recordEvidence(evidence);
         if (!recorded.ok)
             return toCallToolResult(recorded, captureContract);
-        const unknowns = recordProcessResidualUnknowns(session, scenario, evidence, captured.value.residual_unknowns);
+        const unknowns = recordProcessResidualUnknowns(session, evidence, captured.value.residual_unknowns);
         if (!unknowns.ok)
             return toCallToolResult(unknowns, captureContract);
         return toCallToolResult(ok(evidence), captureContract);
     });
 };
 const registerLifecycleTools = (registration) => {
-    const { server, session, contracts, startedAt, availabilityPolicy } = registration;
+    const { server, session, statusContract, startedAt, availabilityPolicy } = registration;
     registerOpenLifecycleTool(registration);
     registerCloseLifecycleTool(registration);
     registerSessionStatusTool({
         server,
         session,
-        contract: contracts[2],
+        contract: statusContract,
         startedAt,
         availabilityPolicy,
     });
 };
-const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openContract], }) => {
+const registerOpenLifecycleTool = ({ server, session, logger, openContract, }) => {
     server.registerTool(openContract.name, toolRegistrationOptions(openContract), async (input, context) => {
         let snapshot;
         if (input.snapshot_path !== undefined) {
@@ -136,17 +120,9 @@ const registerOpenLifecycleTool = ({ server, session, logger, contracts: [openCo
             : toCallToolResult(opened, openContract);
     });
 };
-const registerRecordAndReplayTools = (server, session, logger) => {
-    registerUnknownTools({
-        server,
-        session,
-        contracts: SESSION_TOOL_CONTRACTS,
-    });
-    registerReplayMachineTool(server, logger);
-};
 const registerContextTools = (server, session) => {
-    const navigationContract = SESSION_TOOL_CONTRACTS[20];
-    const addressContract = SESSION_TOOL_CONTRACTS[21];
+    const navigationContract = toolContract("get_navigation_context");
+    const addressContract = toolContract("inspect_address_context");
     server.registerTool(navigationContract.name, toolRegistrationOptions(navigationContract), async (input, context) => {
         return toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
     });
@@ -155,18 +131,26 @@ const registerContextTools = (server, session) => {
     });
 };
 export const registerSessionTools = (server, session, logger, options = {}) => {
-    const processPolicy = options.processPolicy ?? (() => DENY_PROCESS_POLICY);
-    const [openContract, closeContract, statusContract, exportContract, importContract, captureContract, compareContract, compareArtifactsContract, compareFunctionsContract, compareBundlesContract, changedBehaviorContract, callPathContract, staticRuntimeContract, reconstructionContract,] = SESSION_TOOL_CONTRACTS;
-    const snapshotContract = SESSION_TOOL_CONTRACTS[19];
+    const openContract = toolContract("open_binary");
+    const closeContract = toolContract("close_binary");
+    const statusContract = toolContract("binary_session");
+    const exportContract = toolContract("export_evidence_bundle");
+    const importContract = toolContract("import_evidence_bundle");
+    const captureContract = toolContract("capture_process_scenario");
+    const compareContract = toolContract("compare_process_captures");
+    const compareArtifactsContract = toolContract("compare_artifacts");
+    const compareFunctionsContract = toolContract("compare_functions");
+    const compareBundlesContract = toolContract("compare_bundles");
+    const snapshotContract = toolContract("get_evidence_bundle");
     registerLifecycleTools({
         server,
         session,
         logger,
-        contracts: [openContract, closeContract, statusContract],
+        openContract,
+        closeContract,
+        statusContract,
         startedAt: options.startedAt ?? new Date().toISOString(),
-        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {
-            processPolicy: processPolicy(),
-        }),
+        availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {}),
     });
     registerEvidenceTools({
         server,
@@ -179,26 +163,13 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         server,
         session,
         logger,
-        processPolicy,
         captureContract,
-        ...(options.permissionAuthority === undefined
-            ? {}
-            : { permissionAuthority: options.permissionAuthority }),
-        ...(options.processCaptureElicitation === undefined
-            ? {}
-            : { processCaptureElicitation: options.processCaptureElicitation }),
     });
     registerProcessComparisonTool(server, session, compareContract);
     registerArtifactComparisonTool(server, session, compareArtifactsContract);
     registerFunctionComparisonTool(server, session, compareFunctionsContract);
     registerBundleComparisonTool(server, session, compareBundlesContract);
-    const investigationContracts = [
-        changedBehaviorContract,
-        callPathContract,
-        staticRuntimeContract,
-        reconstructionContract,
-    ];
-    registerInvestigationTools(server, session, investigationContracts);
-    registerRecordAndReplayTools(server, session, logger);
+    registerInvestigationTools(server, session);
+    registerUnknownTools({ server, session });
     registerContextTools(server, session);
 };

package/dist/server/sessionAvailabilityPolicy.js

@@ -1,12 +1,11 @@
+import { platform } from "node:process";
 /** Select configured availability reporting or the target-free defaults. */
 export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
     (() => ({
-        processCaptureEnabled: defaults.processPolicy.status === "enabled",
+        processCaptureEnabled: platform !== "win32",
         browserObservationEnabled: defaults.optionalFeatures?.browserObservationEnabled ?? false,
         browserScenarioEnabled: defaults.optionalFeatures?.browserScenarioEnabled ?? false,
         electronObservationEnabled: defaults.optionalFeatures?.electronObservationEnabled ?? false,
         electronAutomationEnabled: defaults.optionalFeatures?.electronAutomationEnabled ?? false,
         v8InspectorObservationEnabled: defaults.optionalFeatures?.v8InspectorObservationEnabled ?? false,
-        javascriptReplayEnabled: defaults.optionalFeatures?.javascriptReplayEnabled ?? false,
-        managedRuntimeEnabled: defaults.optionalFeatures?.managedRuntimeEnabled ?? false,
     }));

package/dist/server/sessionToolPolicies.js

@@ -1,6 +1,2 @@
-/** Fail-closed process policy used when operator configuration is absent. */
-export const DENY_PROCESS_POLICY = {
-    status: "disabled",
-};
 export { PROCESS_PROVIDER } from "../application/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

@@ -1,8 +1,8 @@
 import { projectAnalysisError } from "../domain/errors.js";
 /**
- * Translate an application result into MCP text content.
- * Error tags and safe messages remain visible while underlying causes, process
- * output, and other potentially sensitive details stay private.
+ * 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.
  */
 export const toCallToolResult = (result, contract) => result.ok ? successResult(result.value, contract) : errorResult(result.error);
 const errorResult = (error) => {
@@ -20,7 +20,7 @@ const errorResult = (error) => {
     };
 };
 const successResult = (value, contract) => {
-    const candidate = compactEvidence(value) ??
+    const candidate = projectEvidence(value) ??
         (contract.kind === "session" ? { result: value } : value);
     return {
         content: [
@@ -32,7 +32,7 @@ const successResult = (value, contract) => {
         structuredContent: candidate,
     };
 };
-const compactEvidence = (value) => {
+const projectEvidence = (value) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -40,15 +40,13 @@ const compactEvidence = (value) => {
         !/^ev_[a-f0-9]{64}$/u.test(value.evidence_id) ||
         !("normalized_result" in value))
         return undefined;
-    const evidence = value;
-    const normalizedResult = evidence.normalized_result;
-    const evidenceId = evidence.evidence_id;
+    const normalizedResult = value.normalized_result;
+    const evidenceId = value.evidence_id;
     if (normalizedResult === undefined || typeof evidenceId !== "string")
         return undefined;
-    const inlineEvidence = Object.fromEntries(Object.entries(evidence).filter(([key]) => key !== "normalized_result"));
     return {
         result: normalizedResult,
         evidence_id: evidenceId,
-        evidence: inlineEvidence,
+        evidence: value,
     };
 };