rea-agents 3.0.0 → 3.1.0

package/dist/server/createServer.js

@@ -1,37 +1,83 @@
 import { randomBytes } from "node:crypto";
 import { CLIENT_CAPABILITIES_META_KEY, createRequestStateCodec, McpServer, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
+import { MANAGED_RUNTIME_DISABLED } from "../application/ManagedRuntimeCorrelationService.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
-import { registerGuidedPrompts } from "./registerPrompts.js";
+import { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
+import { mcpClientMetadata, mcpEnvelopeValue } from "./mcpClientMetadata.js";
+import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
+import { registerApplicationTools } from "./registerApplicationTools.js";
+import { registerArtifactTools } from "./registerArtifactTools.js";
+import { registerBrowserScenarioTool } from "./registerBrowserScenarioTool.js";
+import { registerBrowserTools } from "./registerBrowserTools.js";
+import { registerElectronTools } from "./registerElectronTools.js";
+import { registerEnhancedTools } from "./registerEnhancedTools.js";
 import { registerEvidenceResources } from "./registerEvidenceResources.js";
+import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
+import { registerManagedTools } from "./registerManagedTools.js";
+import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
+import { registerNativeTools } from "./registerNativeTools.js";
+import { registerOfficialTools } from "./registerOfficialTools.js";
+import { registerGuidedPrompts } from "./registerPrompts.js";
+import { registerSessionTools } from "./registerSessionTools.js";
 import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
 import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
-import { installDynamicToolAvailability } from "./DynamicToolAvailability.js";
-const TARGET_FREE_INSTRUCTIONS = "ASAR/JavaScript -> analyze_javascript_application; archive/package -> open_binary(path), then inspect_artifact/inventory_artifact (active target); managed PE/CLI -> inspect_managed_artifact; passive browser/Electron -> list_browser_targets/list_electron_targets; approved browser interaction -> capture_browser_scenario; Node/Electron Inspector -> list_javascript_runtime_targets; native binary/database -> open_binary, then binary_overview. Start with binary_session; call only tools in tools/list. Hidden routes: binary_session detail=capabilities. Use summaries, cite Evidence IDs. Never repeat identical analysis or read full Evidence.";
+const TARGET_FREE_INSTRUCTIONS = "ASAR/JavaScript -> analyze_javascript_application; archive/package -> open_binary(path), then inspect_artifact/inventory_artifact (active target); managed PE/CLI -> inspect_managed_artifact; browser/Electron -> list_browser_targets/list_electron_targets; approved -> capture_browser_scenario/capture_electron_scenario; Node/Electron Inspector -> list_javascript_runtime_targets; native binary/database -> open_binary, then binary_overview. Start with binary_session; use tools/list; capabilities via binary_session. Use summaries, cite Evidence IDs; Never repeat identical analysis or read full Evidence.";
 const ACTIVE_TARGET_INSTRUCTIONS = "REA analyzes the active reverse-engineering target. Start native analysis with binary_overview, then narrow with analyze_function, literal search, callers, callees, and xrefs. Prefer summary views, never repeat an identical call, and read full Evidence only when the task requires it.";
-import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
-import { LazyToolCatalog } from "./LazyToolCatalog.js";
 const installSessionToolAvailability = (server, session, options) => {
     if (session === undefined)
         return undefined;
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
-        processPolicy: options.processPolicy ?? DENY_PROCESS_POLICY,
+        processPolicy: options.processPolicy?.() ?? DENY_PROCESS_POLICY,
         evidenceFilePolicy: options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY,
         investigationInputRoots: options.investigationInputRoots ?? [],
         optionalFeatures: {
             browserObservationEnabled: options.browserObservation !== undefined,
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
+            electronAutomationEnabled: options.electronActiveObservation !== undefined &&
+                options.permissionAuthority !== undefined,
             v8InspectorObservationEnabled: options.javascriptRuntimeObservation !== undefined,
-            javascriptReplayEnabled: options.javascriptReplayPolicy?.enabled ?? false,
-            managedRuntimeEnabled: options.managedRuntimePolicy?.enabled ?? false,
+            javascriptReplayEnabled: options.javascriptReplayPolicy?.().status === "enabled",
+            managedRuntimeEnabled: options.managedRuntimePolicy?.().status === "enabled",
         },
     });
     return {
         policy,
-        controller: installDynamicToolAvailability(server, session, policy),
     };
 };
+const createProcessCaptureElicitation = (stateCodec) => ({
+    stateCodec,
+    supported: (context) => {
+        const envelope = context.mcpReq.envelope;
+        const version = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+        const capabilities = mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY);
+        return (typeof version === "string" &&
+            PROCESS_CAPTURE_ELICITATION_POLICY.protocolVersions.some((supported) => supported === version) &&
+            isRecord(capabilities) &&
+            isRecord(capabilities.elicitation) &&
+            capabilities.elicitation.form !== undefined);
+    },
+    now: Date.now,
+    consumedNonces: new Map(),
+});
+const createMcpServer = (processCaptureStateCodec, session) => new McpServer({
+    name: PRODUCT_IDENTITY.mcpServerKey,
+    version: PRODUCT_IDENTITY.packageVersion,
+}, {
+    capabilities: {
+        resources: { subscribe: true },
+    },
+    inputRequired: {
+        maxRounds: 3,
+        roundTimeoutMs: PROCESS_CAPTURE_ELICITATION_POLICY.roundTimeoutMs,
+    },
+    requestState: { verify: processCaptureStateCodec.verify },
+    instructions: session === undefined
+        ? ACTIVE_TARGET_INSTRUCTIONS
+        : TARGET_FREE_INSTRUCTIONS,
+});
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -45,100 +91,44 @@ export const createServer = (analysis, session, options = {}) => {
         key: randomBytes(32),
         ttlSeconds: PROCESS_CAPTURE_ELICITATION_POLICY.stateTtlSeconds,
     });
-    const server = new McpServer({
-        name: PRODUCT_IDENTITY.mcpServerKey,
-        version: PRODUCT_IDENTITY.packageVersion,
-    }, {
-        capabilities: {
-            tools: { listChanged: true },
-            resources: { listChanged: true, subscribe: true },
-        },
-        inputRequired: {
-            maxRounds: 3,
-            roundTimeoutMs: PROCESS_CAPTURE_ELICITATION_POLICY.roundTimeoutMs,
-        },
-        requestState: { verify: processCaptureStateCodec.verify },
-        instructions: session === undefined
-            ? ACTIVE_TARGET_INSTRUCTIONS
-            : TARGET_FREE_INSTRUCTIONS,
-    });
-    const dynamicTools = installSessionToolAvailability(server, session, options);
+    const server = createMcpServer(processCaptureStateCodec, session);
+    const availability = installSessionToolAvailability(server, session, options);
     server.server.onclose = () => {
         permissionAuthority?.clearSessionGrants();
     };
-    if (dynamicTools !== undefined)
-        server.server.oninitialized = () => server.sendToolListChanged();
-    session?.onAvailabilityChanged?.(() => server.sendToolListChanged());
     registerServerIdentityResource(server, startedAt);
     const toolLogger = logger.child({ layer: "server" });
     const { activeTarget, recordEvidence, recordEvidenceWithUnknown } = createSessionRecorders(server, session);
-    const processCaptureElicitation = {
-        stateCodec: processCaptureStateCodec,
-        supported: (context) => {
-            const envelope = context.mcpReq.envelope;
-            const version = envelope?.[PROTOCOL_VERSION_META_KEY];
-            const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
-            return (typeof version === "string" &&
-                PROCESS_CAPTURE_ELICITATION_POLICY.protocolVersions.some((supported) => supported === version) &&
-                isRecord(capabilities) &&
-                isRecord(capabilities.elicitation) &&
-                capabilities.elicitation.form !== undefined);
-        },
-        now: Date.now,
-        consumedNonces: new Map(),
-    };
-    let optionalProviders;
-    const loadOptionalProviders = () => {
-        optionalProviders ??= options
-            .loadOptionalProviders?.()
-            .catch((cause) => {
-            optionalProviders = undefined;
-            throw cause;
-        });
-        return optionalProviders;
+    const processCaptureElicitation = createProcessCaptureElicitation(processCaptureStateCodec);
+    const toolContext = {
+        server,
+        analysis,
+        session,
+        options,
+        logger: toolLogger,
+        permissionAuthority,
+        activeTarget,
+        recordEvidence,
+        recordEvidenceWithUnknown,
     };
-    const lazyTools = new LazyToolCatalog(server, async (kind) => {
-        const needsObservationProviders = kind === "browser-provider" ||
-            kind === "electron-provider" ||
-            kind === "runtime-provider";
-        const [{ hydrateServerToolFamily }, loadedOptionalProviders] = await Promise.all([
-            import("./hydrateServerTools.js"),
-            needsObservationProviders ? loadOptionalProviders() : undefined,
-        ]);
-        const hydratedOptions = loadedOptionalProviders === undefined
-            ? options
-            : { ...options, ...loadedOptionalProviders };
-        await hydrateServerToolFamily({
-            kind,
-            server,
-            analysis,
-            session,
-            options: hydratedOptions,
-            context: {
-                logger: toolLogger,
-                permissionAuthority,
-                activeTarget,
-                recordEvidence,
-                recordEvidenceWithUnknown,
-                availabilityPolicy: dynamicTools?.policy,
-                startedAt,
-                processCaptureElicitation,
-            },
-        });
-    }, session !== undefined);
-    lazyTools.register();
+    registerBinaryAnalysisTools(toolContext);
+    registerObservationTools(toolContext);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
         registerEvidenceResources(server, session);
+        registerSessionTools(server, session, toolLogger, {
+            ...options,
+            ...(availability === undefined
+                ? {}
+                : { availabilityPolicy: availability.policy }),
+            ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+            startedAt,
+            processCaptureElicitation,
+        });
     }
-    dynamicTools?.controller.synchronize();
-    const close = server.close.bind(server);
-    server.close = async () => {
-        await lazyTools.close();
-        await close();
-    };
     return server;
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const createSessionRecorders = (server, session) => ({
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
@@ -154,15 +144,90 @@ const createSessionRecorders = (server, session) => ({
             return recorded;
         },
 });
+const registerBinaryAnalysisTools = ({ server, analysis, session, options, logger, permissionAuthority, activeTarget, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const recordUnknown = session === undefined
+        ? undefined
+        : (input) => session.recordUnknown(input);
+    const analysisOptions = {
+        logger,
+        activeTarget,
+        recordEvidence,
+        recordUnknown,
+    };
+    registerOfficialTools(server, analysis, analysisOptions);
+    registerEnhancedTools(server, analysis, {
+        ...analysisOptions,
+        analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
+    });
+    const evidenceOptions = { logger, activeTarget, recordEvidence };
+    registerNativeTools(server, analysis, evidenceOptions);
+    registerArtifactTools(server, analysis, {
+        ...evidenceOptions,
+        ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+    });
+    registerManagedTools(server, analysis, {
+        ...evidenceOptions,
+        session,
+    });
+    if (session !== undefined)
+        registerManagedWorkflowTools(server, {
+            logger,
+            recordEvidence,
+            recordEvidenceWithUnknown,
+            session,
+            runtime: {
+                policy: options.managedRuntimePolicy ?? (() => MANAGED_RUNTIME_DISABLED),
+                authority: permissionAuthority,
+            },
+        });
+};
+const registerObservationTools = ({ server, session, options, logger, permissionAuthority, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const common = { logger, permissionAuthority, recordEvidence };
+    registerBrowserTools(server, {
+        ...common,
+        browser: options.browserObservation,
+    });
+    registerBrowserScenarioTool(server, {
+        ...common,
+        provider: options.browserScenarioCapture,
+    });
+    registerElectronTools(server, {
+        ...common,
+        electron: options.electronObservation,
+        electronActive: options.electronActiveObservation,
+    });
+    registerJavaScriptRuntimeObservationTools(server, {
+        ...common,
+        runtime: options.javascriptRuntimeObservation,
+    });
+    registerApplicationTools(server, {
+        logger,
+        recordEvidence,
+        recordEvidenceWithUnknown,
+        evidenceLookup: session === undefined
+            ? undefined
+            : (evidenceId) => session.evidenceById(evidenceId),
+        evidenceFilePolicy: options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY,
+        permissionAuthority,
+        retainCoverageWorkspace: session === undefined
+            ? undefined
+            : (workspace) => session.retainReconstructionCoverageWorkspace(workspace),
+        replay: {
+            policy: options.javascriptReplayPolicy ?? (() => ({ status: "disabled" })),
+            host: options.javascriptReplayHost ?? new SystemJavaScriptReplayHost(),
+            runner: options.javascriptReplayRunner ?? new LinuxJavaScriptReplayRunner(),
+            authority: permissionAuthority,
+        },
+    });
+};
 const registerServerIdentityResource = (server, startedAt) => {
     server.registerResource("server-identity", "rea://server/identity", {
         title: "REA server identity",
         description: "Live package, SDK, protocol, and catalog identity.",
         mimeType: "application/json",
-    }, async (uri) => {
+    }, async (uri, context) => {
         const { createServerIdentity } = await import("../serverIdentity.js");
-        const client = server.server.getClientVersion();
-        const protocolVersion = server.server.getNegotiatedProtocolVersion();
+        const { client, protocolVersion } = mcpClientMetadata(context);
         return {
             contents: [
                 {
@@ -178,4 +243,3 @@ const registerServerIdentityResource = (server, startedAt) => {
         };
     });
 };
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/mcpClientMetadata.js

@@ -0,0 +1,32 @@
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
+/** Client metadata bound to the current SDK request rather than server-global state. */
+export const mcpClientMetadata = (context) => {
+    const envelope = context.mcpReq.envelope;
+    const client = implementation(mcpEnvelopeValue(envelope, CLIENT_INFO_META_KEY));
+    const protocolVersion = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+    return {
+        ...(client === undefined ? {} : { client }),
+        clientFeatures: capabilityFeatures(mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY)),
+        ...(typeof protocolVersion === "string" ? { protocolVersion } : {}),
+    };
+};
+/** Read an SDK-defined metadata key from the SDK's currently opaque envelope type. */
+export const mcpEnvelopeValue = (envelope, key) => (envelope === undefined ? undefined : Reflect.get(envelope, key));
+const implementation = (value) => isRecord(value) &&
+    typeof value.name === "string" &&
+    typeof value.version === "string"
+    ? { name: value.name, version: value.version }
+    : undefined;
+const capabilityFeatures = (value) => {
+    const capabilities = isRecord(value) ? value : {};
+    const elicitation = isRecord(capabilities.elicitation)
+        ? capabilities.elicitation
+        : {};
+    return {
+        elicitation_form: elicitation.form !== undefined,
+        elicitation_url: elicitation.url !== undefined,
+        roots: capabilities.roots !== undefined,
+        sampling: capabilities.sampling !== undefined,
+    };
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/registerApplicationTools/characterization.js

@@ -1,22 +1,18 @@
 import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
+import { mcpProgressReporter } from "../mcpProgress.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordSources } from "./helpers.js";
 const prepareContract = applicationToolContract("prepare_node_characterization");
 const executeContract = applicationToolContract("execute_node_characterization");
 /** Register node runtime characterization prepare and execute tools. */
 export const registerCharacterizationTools = (server, options) => {
     server.registerTool(prepareContract.name, toolRegistrationOptions(prepareContract), async (input, context) => {
-        const parsed = safeParseToolInput(nodeCharacterizationPreparationInputSchema, input, prepareContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, prepareContract);
-        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, parsed.value, {
+        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -31,10 +27,7 @@ export const registerCharacterizationTools = (server, options) => {
         });
     });
     server.registerTool(executeContract.name, toolRegistrationOptions(executeContract), async (input, context) => {
-        const parsed = safeParseToolInput(nodeCharacterizationExecutionInputSchema, input, executeContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, executeContract);
-        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, parsed.value, {
+        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -44,7 +37,7 @@ export const registerCharacterizationTools = (server, options) => {
         const sources = [
             output.transformation_evidence,
             ...output.replay.source_evidence,
-            ...(output.replay.evidence === null ? [] : [output.replay.evidence]),
+            output.replay.evidence,
             output.evidence,
         ].map((item) => parseEvidence(item));
         const recorded = recordSources(options.recordEvidence, sources);

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,21 +1,16 @@
 import { resolveCompareJavaScriptExportShapesRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
 import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareJavaScriptExportShapesRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } 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) => {
-        const parsedInput = safeParseToolInput(compareJavaScriptExportShapesRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const parsed = resolved.value;

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,10 +1,8 @@
-import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { resolveCompareSourceToBundleRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareSourceToBundleRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { sourceToBundleComparisonResultSchema } from "../../domain/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
@@ -12,10 +10,7 @@ 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) => {
-        const parsedInput = safeParseToolInput(compareSourceToBundleRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareSourceToBundleRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareSourceToBundleRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(resolved.value)));

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,21 +1,16 @@
-import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { resolveCompareApplicationVersionsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareApplicationVersionsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } 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) => {
-        const parsedInput = safeParseToolInput(compareApplicationVersionsRequestSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
-        const resolved = resolveCompareApplicationVersionsRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareApplicationVersionsRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, compareContract);
         const parsed = resolved.value;

package/dist/server/registerApplicationTools/controlledReplay.js

@@ -1,29 +1,24 @@
 import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../../domain/javascriptReplay.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { controlledReplayOutputSchema } from "../../domain/javascriptReplay.js";
+import { mcpProgressReporter } from "../mcpProgress.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordSources } from "./helpers.js";
 const replayContract = applicationToolContract("run_controlled_replay");
 /** Register the controlled JavaScript replay tool. */
 export const registerControlledReplayTool = (server, options) => {
     server.registerTool(replayContract.name, toolRegistrationOptions(replayContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(controlledReplayInputSchema, input, replayContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, replayContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, parsed, {
+        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
             return toCallToolResult(result, replayContract);
         const output = controlledReplayOutputSchema.parse(result.value);
-        if (output.evidence !== null) {
+        if (output.phase === "execute") {
             const sourcesRecorded = recordSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
             if (!sourcesRecorded.ok)
                 return toCallToolResult(sourcesRecorded, replayContract);
@@ -32,7 +27,7 @@ export const registerControlledReplayTool = (server, options) => {
                 return toCallToolResult(recorded, replayContract);
         }
         return toCallToolResult(result, replayContract, {
-            evidenceResourcesAvailable: output.evidence !== null && options.recordEvidence !== undefined,
+            evidenceResourcesAvailable: output.phase === "execute" && options.recordEvidence !== undefined,
         });
     });
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -1,15 +1,13 @@
+import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../../application/DeferredFileAuthorization.js";
 import { commitReconstructionCoverage, queryReconstructionCoverage, } from "../../application/ReconstructionCoverageService.js";
 import { readReconstructionCoverageWorkspace } from "../../application/ReconstructionCoverageWorkspaceStore.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../../application/DeferredFileAuthorization.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionCoverageCommitInputSchema, reconstructionCoverageQueryInputSchema, } from "../../application/ReconstructionCoverageService.js";
-import { reconstructionClosureResultSchema } from "../../domain/reconstructionCoverage.js";
 import { AnalysisCapabilityUnavailableError, EvidenceIntegrityError, } from "../../domain/errors.js";
+import { reconstructionClosureResultSchema } from "../../domain/reconstructionCoverage.js";
 import { err } from "../../domain/result.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { coverageWorkspaceUri } from "./helpers.js";
 const commitContract = applicationToolContract("commit_reconstruction_coverage");
 const queryContract = applicationToolContract("query_reconstruction_coverage");
@@ -20,13 +18,10 @@ export const registerCoverageTools = (server, options) => {
 };
 const registerCommitTool = (server, options) => {
     server.registerTool(commitContract.name, toolRegistrationOptions(commitContract), async (input, context) => {
-        const parsed = safeParseToolInput(reconstructionCoverageCommitInputSchema, input, commitContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, commitContract);
         if (options.permissionAuthority === undefined)
             return toCallToolResult(err(new AnalysisCapabilityUnavailableError("rea-reconstruction-coverage", commitContract.name, "workspace permission policy is not configured")), commitContract);
         const authorization = await authorizeFileReadWithDeferredWrite(options.permissionAuthority, {
-            path: parsed.value.workspace_path,
+            path: input.workspace_path,
             readCapability: "investigation_workspace_read",
             writeCapability: "investigation_workspace_write",
             operation: commitContract.name,
@@ -36,17 +31,19 @@ const registerCommitTool = (server, options) => {
         const write = await authorization.value.authorizeWrite();
         if (!write.ok)
             return toCallToolResult(write, commitContract);
-        const result = await logToolExecution(options.logger, commitContract.name, () => commitReconstructionCoverage(parsed.value, options.evidenceFilePolicy, { signal: context.mcpReq.signal }));
+        const result = await logToolExecution(options.logger, commitContract.name, () => commitReconstructionCoverage(input, options.evidenceFilePolicy, {
+            signal: context.mcpReq.signal,
+        }));
         if (!result.ok)
             return toCallToolResult(result, commitContract);
-        options.retainCoverageWorkspace?.(parsed.value.workspace);
+        options.retainCoverageWorkspace?.(input.workspace);
         return toCallToolResult(result, commitContract, {
             resourceLinks: options.retainCoverageWorkspace === undefined
                 ? []
                 : [
                     {
-                        uri: coverageWorkspaceUri(parsed.value.workspace),
-                        name: parsed.value.workspace.workspace_id,
+                        uri: coverageWorkspaceUri(input.workspace),
+                        name: input.workspace.workspace_id,
                         description: "Session-retained reconstruction coverage workspace revision",
                     },
                 ],
@@ -55,23 +52,20 @@ const registerCommitTool = (server, options) => {
 };
 const registerQueryTool = (server, options) => {
     server.registerTool(queryContract.name, toolRegistrationOptions(queryContract), async (input, context) => {
-        const parsed = safeParseToolInput(reconstructionCoverageQueryInputSchema, input, queryContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, queryContract);
         if (options.permissionAuthority === undefined)
             return toCallToolResult(err(new AnalysisCapabilityUnavailableError("rea-reconstruction-coverage", queryContract.name, "workspace permission policy is not configured")), queryContract);
         const authorized = await authorizeRootPermission(options.permissionAuthority, {
             capability: "investigation_workspace_read",
-            roots: [parsed.value.workspace_path],
+            roots: [input.workspace_path],
             access: "read",
             operation: queryContract.name,
         });
         if (!authorized.ok)
             return toCallToolResult(authorized, queryContract);
-        const result = await logToolExecution(options.logger, queryContract.name, () => queryReconstructionCoverage(parsed.value, options.evidenceFilePolicy, Date.now(), { signal: context.mcpReq.signal }));
+        const result = await logToolExecution(options.logger, queryContract.name, () => queryReconstructionCoverage(input, options.evidenceFilePolicy, Date.now(), { signal: context.mcpReq.signal }));
         if (result.ok && options.retainCoverageWorkspace !== undefined) {
             const closure = reconstructionClosureResultSchema.parse(result.value);
-            const loaded = await readReconstructionCoverageWorkspace(parsed.value.workspace_path, options.evidenceFilePolicy);
+            const loaded = await readReconstructionCoverageWorkspace(input.workspace_path, options.evidenceFilePolicy);
             if (!loaded.ok)
                 return toCallToolResult(loaded, queryContract);
             if (loaded.value === null ||

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -1,8 +1,6 @@
 import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstructionObligationLedgerRequest, } from "../../application/ReconstructionObligationLedgerService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionObligationLedgerInputSchema } from "../../domain/reconstructionObligationLedgerSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
@@ -10,10 +8,7 @@ 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) => {
-        const parsed = safeParseToolInput(reconstructionObligationLedgerInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const resolved = resolveReconstructionObligationLedgerRequest(parsed.value);
+        const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(buildReconstructionObligationLedgerEvidenceValidated(resolved.value)));