rea-agents 4.1.0 → 6.0.0

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,8 +1,8 @@
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
+import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,8 +1,8 @@
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareSourceToBundleEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { sourceToBundleComparisonResultSchema } from "../../domain/sourceToBundleComparisonSchemas.js";
+import { sourceToBundleComparisonResultSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,8 +1,8 @@
 import { resolvePairedEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { compareApplicationVersionsEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
+import { applicationVersionComparisonResultSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerApplicationTools/projectMobileApplicationGraph.js

@@ -0,0 +1,43 @@
+import { projectAndroidApplicationEvidence } from "../../application/android/AndroidApplicationService.js";
+import { projectAppleApplicationEvidence } from "../../application/apple/AppleApplicationService.js";
+import { APPLICATION_TOOL_CONTRACTS, applicationToolContract, } from "../../contracts/applicationToolContracts.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
+import { logToolExecution } from "../toolLogging.js";
+import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { toCallToolResult } from "../toolResult.js";
+import { recordResult } from "./helpers.js";
+/** Register execution-free Android and Apple inventory projection tools. */
+export const registerProjectMobileApplicationGraphTools = (server, options) => {
+    registerProjection({
+        server,
+        options,
+        contract: applicationToolContract("project_android_application_graph"),
+        project: projectAndroidApplicationEvidence,
+    });
+    registerProjection({
+        server,
+        options,
+        contract: applicationToolContract("project_apple_application_graph"),
+        project: projectAppleApplicationEvidence,
+    });
+};
+const registerProjection = (context) => {
+    const { server, options, contract, project } = context;
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(project(input)));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, inventoryEvidenceSources(input));
+        if (!recordedSources.ok)
+            return toCallToolResult(recordedSources, contract);
+        return recordResult(options, contract, result.value);
+    });
+};
+const inventoryEvidenceSources = (input) => {
+    if (typeof input !== "object" ||
+        input === null ||
+        !("inventory_evidence" in input) ||
+        !Array.isArray(input.inventory_evidence))
+        return [];
+    return input.inventory_evidence;
+};

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,6 +1,6 @@
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
+import { traceApplicationFeatureEvidenceValidated } from "../../application/javascript/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,6 +1,6 @@
 import { resolveApplicationEvidenceRequest } from "../../application/EvidenceInputResolver.js";
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/JavaScriptSemanticTraceService.js";
+import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/javascript/JavaScriptSemanticTraceService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";

package/dist/server/registerApplicationTools.js

@@ -5,6 +5,7 @@ import { registerCompareSourceToBundleTool } from "./registerApplicationTools/co
 import { registerCompareJavaScriptExportShapesTool } from "./registerApplicationTools/compareExportShapes.js";
 import { registerCoverageTools } from "./registerApplicationTools/coverage.js";
 import { registerReconstructionObligationLedgerTool } from "./registerApplicationTools/obligationLedger.js";
+import { registerProjectMobileApplicationGraphTools } from "./registerApplicationTools/projectMobileApplicationGraph.js";
 /** Register provider-neutral JavaScript application graph workflows. */
 export const registerApplicationTools = (server, options) => {
     registerTraceFeatureTool(server, options);
@@ -14,4 +15,5 @@ export const registerApplicationTools = (server, options) => {
     registerCompareJavaScriptExportShapesTool(server, options);
     registerReconstructionObligationLedgerTool(server, options);
     registerCoverageTools(server, options);
+    registerProjectMobileApplicationGraphTools(server, options);
 };

package/dist/server/registerBinaryDiagnosticsTools.js

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

package/dist/server/registerBrowserScenarioTool.js

@@ -1,14 +1,18 @@
+import { optionalProviderUnavailable, } from "../application/OptionalObservationProviders.js";
+import { err } from "../domain/result.js";
 import { captureBrowserScenario } from "../application/BrowserScenarioCaptureService.js";
-import { BROWSER_SCENARIO_TOOL_CONTRACTS } from "../contracts/browserScenarioToolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register the browser scenario tool with execution-time provider diagnostics. */
 export const registerBrowserScenarioTool = (server, options) => {
-    const [contract] = BROWSER_SCENARIO_TOOL_CONTRACTS;
+    const contract = toolContract("capture_browser_scenario");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const scenario = browserScenarioSchema.parse(input);
+        if (options.loadFailure !== undefined)
+            return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
         const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, scenario, {
             signal: context.mcpReq.signal,
         }));

package/dist/server/registerBrowserTools.js

@@ -1,5 +1,7 @@
+import { optionalProviderUnavailable, } from "../application/OptionalObservationProviders.js";
+import { err } from "../domain/result.js";
 import { analyzeWebBundle, captureWebScreenshot, compareWebCaptureEvidence, compareWebScreenshotEvidence, discoverWebMcpTools, inspectWebPage, listBrowserTargets, observeWebSession, } from "../application/BrowserObservationService.js";
-import { BROWSER_TOOL_CONTRACTS } from "../contracts/browserToolContracts.js";
+import { toolContract } from "../contracts/toolContracts.js";
 import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
 import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
@@ -9,7 +11,14 @@ import { toCallToolResult } from "./toolResult.js";
 /** Register browser tools with execution-time provider diagnostics. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerBrowserTools = (server, options) => {
-    const [listContract, inspectContract, analyzeContract, sessionContract, webMcpContract, captureDiffContract, screenshotContract, screenshotDiffContract,] = BROWSER_TOOL_CONTRACTS;
+    const listContract = toolContract("list_browser_targets");
+    const inspectContract = toolContract("inspect_web_page");
+    const analyzeContract = toolContract("analyze_web_bundle");
+    const sessionContract = toolContract("observe_web_session");
+    const webMcpContract = toolContract("discover_webmcp_tools");
+    const captureDiffContract = toolContract("compare_web_captures");
+    const screenshotContract = toolContract("capture_web_screenshot");
+    const screenshotDiffContract = toolContract("compare_web_screenshots");
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(options, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, parsed, {
         signal,
     })));
@@ -35,6 +44,8 @@ export const registerBrowserTools = (server, options) => {
 };
 const runBrowserTool = async (options, contract, request, execute) => {
     const { input, context } = request;
+    if (options.loadFailure !== undefined)
+        return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),

package/dist/server/registerCloseLifecycleTool.js

@@ -1,4 +1,4 @@
-import { writeAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
+import { writeAnalysisSnapshot } from "../application/binary/AnalysisSnapshotFiles.js";
 import { ok } from "../domain/result.js";
 import { reportLifecycleEnd, reportLifecycleStart, } from "./lifecycleProgress.js";
 import { mcpProgressReporter } from "./mcpProgress.js";

package/dist/server/registerElectronTools.js

@@ -1,9 +1,11 @@
-import { captureElectronScenario } from "../application/ElectronActiveObservationService.js";
-import { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
-import { analyzeJavaScriptApplicationValidated } from "../application/JavaScriptApplicationService.js";
-import { reconcileJavaScriptRuntimeEvidenceValidated } from "../application/JavaScriptRuntimeReconciliationService.js";
-import { ELECTRON_TOOL_CONTRACTS } from "../contracts/electronToolContracts.js";
-import { inspectElectronPageInputSchema } from "../domain/electronObservation.js";
+import { optionalProviderUnavailable, } from "../application/OptionalObservationProviders.js";
+import { err } from "../domain/result.js";
+import { captureElectronScenario } from "../application/javascript/ElectronActiveObservationService.js";
+import { inspectElectronPage, listElectronTargets, } from "../application/javascript/ElectronObservationService.js";
+import { analyzeJavaScriptApplicationValidated } from "../application/javascript/JavaScriptApplicationService.js";
+import { reconcileJavaScriptRuntimeEvidenceValidated } from "../application/javascript/JavaScriptRuntimeReconciliationService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { inspectElectronPageInputSchema } from "../domain/javascript/electronObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -11,7 +13,11 @@ import { toCallToolResult } from "./toolResult.js";
 /** Register Electron tools even when a provider is absent. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerElectronTools = (server, options) => {
-    const [listContract, inspectContract, analyzeContract, reconcileContract, activeContract,] = ELECTRON_TOOL_CONTRACTS;
+    const listContract = toolContract("list_electron_targets");
+    const inspectContract = toolContract("inspect_electron_page");
+    const analyzeContract = toolContract("analyze_javascript_application");
+    const reconcileContract = toolContract("reconcile_javascript_runtime");
+    const activeContract = toolContract("capture_electron_scenario");
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(options, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, parsed, {
         signal,
     })));
@@ -31,6 +37,14 @@ export const registerElectronTools = (server, options) => {
 };
 const runElectronTool = async (options, contract, request, execute) => {
     const { input, context } = request;
+    const failure = contract.name === "capture_electron_scenario"
+        ? options.activeLoadFailure
+        : contract.name === "list_electron_targets" ||
+            contract.name === "inspect_electron_page"
+            ? options.observationLoadFailure
+            : undefined;
+    if (failure !== undefined)
+        return toCallToolResult(err(optionalProviderUnavailable(failure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),

package/dist/server/registerEvidenceTools.js

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

package/dist/server/registerEvmTools.js

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

package/dist/server/registerJavaScriptRecoveryTool.js

@@ -0,0 +1,17 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind optional recovery to its exact named contract without acquiring an engine. */
+export const registerJavaScriptRecoveryTool = (server, service, logger, recordEvidence) => {
+    const contract = toolContract("recover_javascript_sources");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const result = await logToolExecution(logger, contract.name, () => service.recover(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -1,12 +1,15 @@
-import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/JavaScriptRuntimeObservationService.js";
-import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "../contracts/javascriptRuntimeObservationToolContracts.js";
-import { observeJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeObservation.js";
+import { optionalProviderUnavailable, } from "../application/OptionalObservationProviders.js";
+import { err } from "../domain/result.js";
+import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/javascript/JavaScriptRuntimeObservationService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { observeJavaScriptRuntimeInputSchema } from "../domain/javascript/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 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;
+    const listContract = toolContract("list_javascript_runtime_targets");
+    const observeContract = toolContract("observe_javascript_runtime");
     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);
@@ -15,6 +18,8 @@ export const registerJavaScriptRuntimeObservationTools = (server, options) => {
 };
 const runRuntimeTool = async (options, contract, request, execute) => {
     const { input, context } = request;
+    if (options.loadFailure !== undefined)
+        return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, context.mcpReq.signal));
     if (!result.ok)
         return toCallToolResult(result, contract);

package/dist/server/registerManagedTools.js

@@ -1,9 +1,9 @@
-import { MANAGED_TOOL_CONTRACTS } from "../contracts/managedToolContracts.js";
+import { MANAGED_TOOL_CONTRACTS } from "../contracts/managed/managedToolContracts.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { err } from "../domain/result.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
-import { runManagedProviderExecution } from "../application/DirectAnalysis.js";
-import { isManagedToolName } from "../contracts/managedToolContracts.js";
+import { runManagedProviderExecution } from "../composition/directAnalysis.js";
+import { isManagedToolName } from "../contracts/managed/managedToolContracts.js";
 /** Register execution-free managed PE/CLI inspection. */
 export const registerManagedTools = (server, analysis, options) => {
     let selectedManagedPath;

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -1,6 +1,6 @@
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareManagedMembersEvidenceValidated } from "../../application/ManagedMemberComparisonService.js";
-import { managedMemberComparisonResultSchema } from "../../domain/managedMemberComparison.js";
+import { compareManagedMembersEvidenceValidated } from "../../application/managed/ManagedMemberComparisonService.js";
+import { managedMemberComparisonResultSchema } from "../../domain/managed/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerManagedWorkflowTools/contract.js

@@ -1,4 +1,4 @@
-import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "../../contracts/managedWorkflowToolContracts.js";
+import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "../../contracts/managed/managedWorkflowToolContracts.js";
 export function managedWorkflowContract(name) {
     const found = MANAGED_WORKFLOW_TOOL_CONTRACTS.find((candidate) => candidate.name === name);
     if (found === undefined)

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -1,4 +1,4 @@
-import { importManagedReconstructionEvidenceValidated } from "../../application/ManagedReconstructionService.js";
+import { importManagedReconstructionEvidenceValidated } from "../../application/managed/ManagedReconstructionService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -1,5 +1,5 @@
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { projectManagedApplicationGraphEvidence } from "../../application/ManagedApplicationGraphService.js";
+import { projectManagedApplicationGraphEvidence } from "../../application/managed/ManagedApplicationGraphService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,6 +1,6 @@
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { verifyManagedNativeBoundariesEvidence } from "../../application/ManagedNativeVerificationService.js";
-import { managedNativeVerificationResultSchema } from "../../domain/managedNativeVerification.js";
+import { verifyManagedNativeBoundariesEvidence } from "../../application/managed/ManagedNativeVerificationService.js";
+import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerification.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";

package/dist/server/registerNativeTools.js

@@ -1,4 +1,4 @@
-import { NATIVE_TOOL_CONTRACTS } from "../contracts/nativeToolContracts.js";
+import { NATIVE_TOOL_CONTRACTS } from "../contracts/native/nativeToolContracts.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
 /** Register provider-neutral static inspection operations. */
 export const registerNativeTools = (server, analysis, options) => {

package/dist/server/registerProcessComparisonTool.js

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

package/dist/server/registerPrompts.js

@@ -39,7 +39,11 @@ const promptArgumentsSchema = (contract, completion) => {
     return z.object(shape);
 };
 const argumentSchema = (argument, completion) => {
-    const value = z.string().trim().min(1).describe(argument.description);
+    const value = z
+        .string()
+        .min(1)
+        .refine((value) => value.trim().length > 0)
+        .describe(argument.description);
     const kind = argument.completion;
     const completed = kind === undefined
         ? value

package/dist/server/registerRecordedCrashTools.js

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

package/dist/server/registerSessionTools.js

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

package/dist/server/registerWebModuleTool.js

@@ -0,0 +1,17 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind the module relationship workflow to its exact canonical contract. */
+export const registerWebModuleTool = (server, service, logger, recordEvidence) => {
+    const contract = toolContract("trace_web_module_imports");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const result = await logToolExecution(logger, contract.name, () => service.trace(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerWebNetworkCaptureTool.js

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

package/dist/server/registerWebRuntimeTools.js

@@ -0,0 +1,31 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { mcpProgressReporter } from "./mcpProgress.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind distinct runtime operations to named contracts and the session's Evidence owner. */
+export const registerWebRuntimeTools = (server, service, logger, recordEvidence) => {
+    const execution = toolContract("observe_web_execution");
+    const listeners = toolContract("inspect_web_event_listeners");
+    server.registerTool(execution.name, toolRegistrationOptions(execution), async (input, context) => {
+        const result = await logToolExecution(logger, execution.name, () => service.observe(input, {
+            signal: context.mcpReq.signal,
+            progress: mcpProgressReporter(context),
+        }));
+        if (!result.ok)
+            return toCallToolResult(result, execution);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, execution)
+            : toCallToolResult(result, execution);
+    });
+    server.registerTool(listeners.name, toolRegistrationOptions(listeners), async (input, context) => {
+        const result = await logToolExecution(logger, listeners.name, () => service.inspect(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, listeners);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, listeners)
+            : toCallToolResult(result, listeners);
+    });
+};

package/dist/server/registerWebScriptTool.js

@@ -0,0 +1,18 @@
+import { exportWebScriptsValidated } from "../application/WebScriptExportService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Register local script export without requiring a live browser provider. */
+export const registerWebScriptTool = (server, options) => {
+    const contract = toolContract("export_web_scripts");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const result = await logToolExecution(options.logger, contract.name, () => exportWebScriptsValidated(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = options.recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/registerWebSourceLocationTool.js

@@ -0,0 +1,17 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
+/** Bind source point tracing to its exact named contract and session Evidence owner. */
+export const registerWebSourceLocationTool = (server, service, logger, recordEvidence) => {
+    const contract = toolContract("trace_web_source_location");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const result = await logToolExecution(logger, contract.name, () => service.trace(input, { signal: context.mcpReq.signal }));
+        if (!result.ok)
+            return toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return recorded !== undefined && !recorded.ok
+            ? toCallToolResult(recorded, contract)
+            : toCallToolResult(result, contract);
+    });
+};

package/dist/server/sessionAvailabilityPolicy.js

@@ -1,14 +1,29 @@
 import { platform } from "node:process";
 /** Select configured availability reporting or the target-free defaults. */
-export const sessionAvailabilityPolicy = (configured, defaults) => configured ??
-    (() => ({
-        processCaptureEnabled: platform !== "win32",
-        firmwareInspectionEnabled: defaults.optionalFeatures?.firmwareInspectionEnabled ?? false,
-        firmwareExtractionEnabled: defaults.optionalFeatures?.firmwareExtractionEnabled ?? false,
-        androidAnalysisEnabled: defaults.optionalFeatures?.androidAnalysisEnabled ?? false,
-        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,
-    }));
+export const sessionAvailabilityPolicy = (configured, defaults) => {
+    const policy = configured ??
+        (() => ({
+            evmInterfaceEnabled: defaults.optionalFeatures?.evmInterfaceEnabled ?? false,
+            processCaptureEnabled: platform !== "win32",
+            recordedCrashEnabled: defaults.optionalFeatures?.recordedCrashEnabled ?? false,
+            binaryLayoutEnabled: defaults.optionalFeatures?.binaryLayoutEnabled ?? false,
+            firmwareInspectionEnabled: defaults.optionalFeatures?.firmwareInspectionEnabled ?? false,
+            firmwareExtractionEnabled: defaults.optionalFeatures?.firmwareExtractionEnabled ?? false,
+            androidAnalysisEnabled: defaults.optionalFeatures?.androidAnalysisEnabled ?? false,
+            javascriptRecoveryEnabled: defaults.optionalFeatures?.javascriptRecoveryEnabled ?? false,
+            webModuleResolutionEnabled: defaults.optionalFeatures?.webModuleResolutionEnabled ?? false,
+            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,
+        }));
+    return () => ({
+        ...policy(),
+        ...(defaults.optionalProviderLoadFailures === undefined
+            ? {}
+            : {
+                optionalProviderLoadFailures: defaults.optionalProviderLoadFailures,
+            }),
+    });
+};