rea-agents 2.0.0 → 2.2.0

package/dist/server/registerApplicationTools.js

@@ -1,115 +1,13 @@
-import { compareApplicationVersionsEvidenceValidated, traceApplicationFeatureEvidenceValidated, } from "../application/JavaScriptApplicationWorkflowService.js";
-import { runControlledReplayValidated, } from "../application/JavaScriptReplayService.js";
-import { APPLICATION_TOOL_CONTRACTS } from "../contracts/applicationToolContracts.js";
-import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { applicationVersionComparisonResultSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
-import { parseEvidence } from "../domain/evidence.js";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../domain/javascriptReplay.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 { registerTraceFeatureTool } from "./registerApplicationTools/traceFeature.js";
+import { registerCompareApplicationVersionsTool } from "./registerApplicationTools/compareVersions.js";
+import { registerControlledReplayTool } from "./registerApplicationTools/controlledReplay.js";
+import { registerCharacterizationTools } from "./registerApplicationTools/characterization.js";
+import { registerCoverageTools } from "./registerApplicationTools/coverage.js";
 /** Register provider-neutral JavaScript application graph workflows. */
 export const registerApplicationTools = (server, options) => {
-    const [traceContract, compareContract, replayContract] = APPLICATION_TOOL_CONTRACTS;
-    server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
-        const parsedInput = safeParseToolInput(traceApplicationFeatureInputSchema, input, traceContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, traceContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
-        if (!result.ok)
-            return toCallToolResult(result, traceContract);
-        const sources = [parsed.application, ...parsed.native_observations];
-        const recorded = recordSources(options.recordEvidence, sources);
-        if (!recorded.ok)
-            return toCallToolResult(recorded, traceContract);
-        return recordResult(options, traceContract, result.value);
-    });
-    server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareApplicationVersionsInputSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
-        if (!result.ok)
-            return toCallToolResult(result, compareContract);
-        const sources = [
-            parsed.left,
-            parsed.right,
-            ...parsed.left_native_observations,
-            ...parsed.right_native_observations,
-        ];
-        const recorded = recordSources(options.recordEvidence, sources);
-        if (!recorded.ok)
-            return toCallToolResult(recorded, compareContract);
-        const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
-        const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, compareContract, result.value, parsed.unknown_registry_approved === true && unknown);
-    });
-    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, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, replayContract);
-        const output = controlledReplayOutputSchema.parse(result.value);
-        if (output.evidence !== null) {
-            const sourcesRecorded = recordSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
-            if (!sourcesRecorded.ok)
-                return toCallToolResult(sourcesRecorded, replayContract);
-            const recorded = options.recordEvidence?.(parseEvidence(output.evidence));
-            if (recorded !== undefined && !recorded.ok)
-                return toCallToolResult(recorded, replayContract);
-        }
-        return toCallToolResult(result, replayContract, {
-            evidenceResourcesAvailable: output.evidence !== null && options.recordEvidence !== undefined,
-        });
-    });
-};
-const recordSources = (recordEvidence, sources) => {
-    for (const source of sources) {
-        const recorded = recordEvidence?.(source);
-        if (recorded !== undefined && !recorded.ok)
-            return recorded;
-    }
-    return { ok: true, value: null };
-};
-const recordResult = (options, contract, evidence, recordUnknown = false) => {
-    const recorded = recordUnknown
-        ? options.recordEvidenceWithUnknown?.(evidence, {
-            approved: true,
-            question: "Which application entities remain unmatched or ambiguous across these versions?",
-            severity: "medium",
-            domain: "application-version-comparison",
-            supporting_evidence_ids: [evidence.evidence_id],
-            contradicting_evidence_ids: [],
-            required_authority: "shipped-artifact",
-            required_confidence: "observed",
-            required_environment: null,
-            recommended_probes: [
-                {
-                    operation: "analyze_javascript_application",
-                    rationale: "Repeat static reconstruction with complete artifacts and source maps when available.",
-                },
-                {
-                    operation: "reconcile_javascript_runtime",
-                    rationale: "Add approved passive runtime Evidence without promoting it to static fact.",
-                },
-            ],
-            relationships: [],
-        })
-        : options.recordEvidence?.(evidence);
-    if (recorded !== undefined && !recorded.ok)
-        return toCallToolResult(recorded, contract);
-    return toCallToolResult({ ok: true, value: evidence }, contract, {
-        evidenceResourcesAvailable: recorded !== undefined,
-    });
+    registerTraceFeatureTool(server, options);
+    registerCompareApplicationVersionsTool(server, options);
+    registerControlledReplayTool(server, options);
+    registerCharacterizationTools(server, options);
+    registerCoverageTools(server, options);
 };

package/dist/server/registerBrowserTools.js

@@ -14,100 +14,76 @@ import { mcpProgressReporter } from "./mcpProgress.js";
 /** Register browser tools even when policy/provider availability denies execution. */
 export const registerBrowserTools = (server, options) => {
     const [listContract, inspectContract, analyzeContract, sessionContract, webMcpContract, captureDiffContract, screenshotContract, screenshotDiffContract,] = BROWSER_TOOL_CONTRACTS;
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(listBrowserTargetsInputSchema, input, listContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, listContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, listContract.name, () => listBrowserTargets(options.browser, options.permissionAuthority, parsed, { signal: context.mcpReq.signal }));
-        if (!result.ok)
-            return toCallToolResult(result, listContract);
-        return evidenceResult(options, listContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: listContract,
+        schema: listBrowserTargetsInputSchema,
+        execute: (parsed, { signal }) => listBrowserTargets(options.browser, options.permissionAuthority, parsed, {
+            signal,
+        }),
     });
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(inspectWebPageInputSchema, input, inspectContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, inspectContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, inspectContract.name, () => inspectWebPage(options.browser, options.permissionAuthority, parsed, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, inspectContract);
-        return evidenceResult(options, inspectContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: inspectContract,
+        schema: inspectWebPageInputSchema,
+        execute: (parsed, { signal, progress }) => inspectWebPage(options.browser, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(analyzeWebBundleInputSchema, input, analyzeContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, analyzeContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, analyzeContract.name, () => analyzeWebBundle(options.browser, options.permissionAuthority, parsed, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, analyzeContract);
-        return evidenceResult(options, analyzeContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: analyzeContract,
+        schema: analyzeWebBundleInputSchema,
+        execute: (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(observeWebSessionInputSchema, input, sessionContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, sessionContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, sessionContract.name, () => observeWebSession(options.browser, options.permissionAuthority, parsed, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, sessionContract);
-        return evidenceResult(options, sessionContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: sessionContract,
+        schema: observeWebSessionInputSchema,
+        execute: (parsed, { signal, progress }) => observeWebSession(options.browser, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(discoverWebMcpToolsInputSchema, input, webMcpContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, webMcpContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, webMcpContract.name, () => discoverWebMcpTools(options.browser, options.permissionAuthority, parsed, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, webMcpContract);
-        return evidenceResult(options, webMcpContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: webMcpContract,
+        schema: discoverWebMcpToolsInputSchema,
+        execute: (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareWebCapturesInputSchema, input, captureDiffContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, captureDiffContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, captureDiffContract.name, () => compareWebCaptureEvidence(options.browser, parsed));
-        if (!result.ok)
-            return toCallToolResult(result, captureDiffContract);
-        return evidenceResult(options, captureDiffContract, result.value);
+    registerBrowserTool(server, options, {
+        contract: captureDiffContract,
+        schema: compareWebCapturesInputSchema,
+        execute: (parsed, _context) => compareWebCaptureEvidence(options.browser, parsed),
+    });
+    registerBrowserTool(server, options, {
+        contract: screenshotContract,
+        schema: captureWebScreenshotInputSchema,
+        execute: (parsed, { signal, progress }) => captureWebScreenshot(options.browser, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(captureWebScreenshotInputSchema, input, screenshotContract.name);
+    registerBrowserTool(server, options, {
+        contract: screenshotDiffContract,
+        schema: compareWebScreenshotsInputSchema,
+        execute: (parsed, _context) => compareWebScreenshotEvidence(options.browser, parsed),
+    });
+};
+const registerBrowserTool = (server, options, spec) => {
+    server.registerTool(spec.contract.name, toolRegistrationOptions(spec.contract), async (input, context) => {
+        const parsedInput = safeParseToolInput(spec.schema, input, spec.contract.name);
         if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, screenshotContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, screenshotContract.name, () => captureWebScreenshot(options.browser, options.permissionAuthority, parsed, {
+            return toCallToolResult(parsedInput, spec.contract);
+        const result = await logToolExecution(options.logger, spec.contract.name, () => spec.execute(parsedInput.value, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
-            return toCallToolResult(result, screenshotContract);
-        return evidenceResult(options, screenshotContract, result.value);
-    });
-    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareWebScreenshotsInputSchema, input, screenshotDiffContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, screenshotDiffContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, screenshotDiffContract.name, () => compareWebScreenshotEvidence(options.browser, parsed));
-        if (!result.ok)
-            return toCallToolResult(result, screenshotDiffContract);
-        return evidenceResult(options, screenshotDiffContract, result.value);
+            return toCallToolResult(result, spec.contract);
+        return evidenceResult(options, spec.contract, result.value);
     });
 };
 const evidenceResult = (options, contract, evidence) => {

package/dist/server/registerElectronTools.js

@@ -1,78 +1,77 @@
 import { analyzeJavaScriptApplicationValidated } from "../application/JavaScriptApplicationService.js";
 import { reconcileJavaScriptRuntimeEvidenceValidated } from "../application/JavaScriptRuntimeReconciliationService.js";
 import { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
-import { ELECTRON_TOOL_CONTRACTS } from "../contracts/electronToolContracts.js";
+import { analyzeJavaScriptApplicationToolInputSchema, ELECTRON_TOOL_CONTRACTS, } from "../contracts/electronToolContracts.js";
 import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
-import { analyzeJavaScriptApplicationInputSchema } from "../domain/javascriptApplicationAnalysis.js";
 import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.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 { summarizeJavaScriptApplicationEvidence } from "./javascriptApplicationResult.js";
 /** Register Electron tools even when provider or permission policy is absent. */
 export const registerElectronTools = (server, options) => {
     const [listContract, inspectContract, analyzeContract, reconcileContract] = ELECTRON_TOOL_CONTRACTS;
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(listElectronTargetsInputSchema, input, listContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, listContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, listContract.name, () => listElectronTargets(options.electron, options.permissionAuthority, parsed, { signal: context.mcpReq.signal }));
-        if (!result.ok)
-            return toCallToolResult(result, listContract);
-        return evidenceResult(options, listContract, result.value);
+    registerElectronTool(server, options, {
+        contract: listContract,
+        schema: listElectronTargetsInputSchema,
+        execute: (parsed, { signal }) => listElectronTargets(options.electron, options.permissionAuthority, parsed, {
+            signal,
+        }),
     });
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(inspectElectronPageInputSchema, input, inspectContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, inspectContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, inspectContract.name, () => inspectElectronPage(options.electron, options.permissionAuthority, parsed, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, inspectContract);
-        return evidenceResult(options, inspectContract, result.value);
+    registerElectronTool(server, options, {
+        contract: inspectContract,
+        schema: inspectElectronPageInputSchema,
+        execute: (parsed, { signal, progress }) => inspectElectronPage(options.electron, options.permissionAuthority, parsed, {
+            signal,
+            progress,
+        }),
     });
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(analyzeJavaScriptApplicationInputSchema, input, analyzeContract.name);
+    registerElectronTool(server, options, {
+        contract: analyzeContract,
+        schema: analyzeJavaScriptApplicationToolInputSchema,
+        execute: (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(options.permissionAuthority, parsed, { signal, progress }),
+        projectEvidence: (evidence, parsed) => {
+            const summary = summarizeJavaScriptApplicationEvidence(evidence);
+            return parsed.detail === "full"
+                ? { structured: evidence.normalized_result, text: summary }
+                : { structured: summary };
+        },
+    });
+    registerElectronTool(server, options, {
+        contract: reconcileContract,
+        schema: reconcileJavaScriptRuntimeInputSchema,
+        execute: (parsed, _context) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed)),
+    });
+};
+const registerElectronTool = (server, options, spec) => {
+    server.registerTool(spec.contract.name, toolRegistrationOptions(spec.contract), async (input, context) => {
+        const parsedInput = safeParseToolInput(spec.schema, input, spec.contract.name);
         if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, analyzeContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, analyzeContract.name, () => analyzeJavaScriptApplicationValidated(options.permissionAuthority, parsed, {
+            return toCallToolResult(parsedInput, spec.contract);
+        const result = await logToolExecution(options.logger, spec.contract.name, () => spec.execute(parsedInput.value, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
-            return toCallToolResult(result, analyzeContract);
-        return evidenceResult(options, analyzeContract, result.value);
-    });
-    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), async (input) => {
-        const parsedInput = safeParseToolInput(reconcileJavaScriptRuntimeInputSchema, input, reconcileContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, reconcileContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, reconcileContract.name, () => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed)));
-        if (!result.ok)
-            return toCallToolResult(result, reconcileContract);
-        for (const source of [
-            ...parsed.static_layers.map(({ analysis }) => analysis),
-            ...parsed.runtime_observations,
-        ]) {
-            const recorded = options.recordEvidence?.(source);
-            if (recorded !== undefined && !recorded.ok)
-                return toCallToolResult(recorded, reconcileContract);
-        }
-        return evidenceResult(options, reconcileContract, result.value);
+            return toCallToolResult(result, spec.contract);
+        return evidenceResult(options, spec.contract, result.value, spec.projectEvidence?.(result.value, parsedInput.value));
     });
 };
-const evidenceResult = (options, contract, evidence) => {
+const evidenceResult = (options, contract, evidence, projection) => {
     const recorded = options.recordEvidence?.(evidence);
     return recorded !== undefined && !recorded.ok
         ? toCallToolResult(recorded, contract)
         : toCallToolResult({ ok: true, value: evidence }, contract, {
             evidenceResourcesAvailable: recorded !== undefined,
+            ...(projection === undefined
+                ? {}
+                : {
+                    evidenceResultProjection: projection.structured,
+                    ...(projection.text === undefined
+                        ? {}
+                        : { evidenceTextProjection: projection.text }),
+                }),
         });
 };

package/dist/server/registerEnhancedTools.js

@@ -1,10 +1,9 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
-import { enhancedToolNameSchema } from "../contracts/enhancedInputs.js";
+import { enhancedInputSchemas, enhancedToolNameSchema, } from "../contracts/enhancedInputs.js";
 import { ENHANCED_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
 import { toCallToolResult } from "./toolResult.js";
 import { logToolExecution } from "./toolLogging.js";
 import { createEvidence } from "../domain/evidence.js";
-import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
 import { AnalysisInputError, UnknownRegistryError } from "../domain/errors.js";
 import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
@@ -83,50 +82,43 @@ const registerEnhancedTool = (server, services, contract, registration) => {
     });
 };
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
+const ENHANCED_INPUT_PARSERS = {
+    swift_classes: (input) => safeParseToolInput(enhancedInputSchemas.swift_classes, input, "swift_classes"),
+    get_objc_classes: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_classes, input, "get_objc_classes"),
+    get_objc_protocols: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_protocols, input, "get_objc_protocols"),
+    batch_decompile: (input) => safeParseToolInput(enhancedInputSchemas.batch_decompile, input, "batch_decompile"),
+    get_call_graph: (input) => safeParseToolInput(enhancedInputSchemas.get_call_graph, input, "get_call_graph"),
+    analyze_swift_types: (input) => safeParseToolInput(enhancedInputSchemas.analyze_swift_types, input, "analyze_swift_types"),
+    find_xrefs_to_name: (input) => safeParseToolInput(enhancedInputSchemas.find_xrefs_to_name, input, "find_xrefs_to_name"),
+    binary_overview: (input) => safeParseToolInput(enhancedInputSchemas.binary_overview, input, "binary_overview"),
+    analyze_function: (input) => safeParseToolInput(enhancedInputSchemas.analyze_function, input, "analyze_function"),
+    trace_feature: (input) => safeParseToolInput(enhancedInputSchemas.trace_feature, input, "trace_feature"),
+};
 const parseEnhancedCall = (name, input) => {
     switch (name) {
-        case "swift_classes": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.swift_classes, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "get_objc_classes": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.get_objc_classes, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "get_objc_protocols": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.get_objc_protocols, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "batch_decompile": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.batch_decompile, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "get_call_graph": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.get_call_graph, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "analyze_swift_types": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.analyze_swift_types, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "find_xrefs_to_name": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.find_xrefs_to_name, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "binary_overview": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.binary_overview, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "analyze_function": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.analyze_function, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
-        case "trace_feature": {
-            const parsed = safeParseToolInput(enhancedInputSchemas.trace_feature, input, name);
-            return parsed.ok ? ok({ name, input: parsed.value }) : parsed;
-        }
+        case "swift_classes":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.swift_classes(input), (value) => ({ name, input: value }));
+        case "get_objc_classes":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_classes(input), (value) => ({ name, input: value }));
+        case "get_objc_protocols":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_protocols(input), (value) => ({ name, input: value }));
+        case "batch_decompile":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.batch_decompile(input), (value) => ({ name, input: value }));
+        case "get_call_graph":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_call_graph(input), (value) => ({ name, input: value }));
+        case "analyze_swift_types":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_swift_types(input), (value) => ({ name, input: value }));
+        case "find_xrefs_to_name":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_xrefs_to_name(input), (value) => ({ name, input: value }));
+        case "binary_overview":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.binary_overview(input), (value) => ({ name, input: value }));
+        case "analyze_function":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_function(input), (value) => ({ name, input: value }));
+        case "trace_feature":
+            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_feature(input), (value) => ({ name, input: value }));
     }
 };
+const mapEnhancedCall = (parsed, project) => parsed.ok ? ok(project(parsed.value)) : parsed;
 const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown, }) => {
     if (name !== "trace_feature" ||
         input.unknown_registry_approved !== true ||

package/dist/server/registerEvidenceResources.js

@@ -1,9 +1,50 @@
 import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
+import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
 const evidenceUri = (evidenceId) => `rea://evidence/${evidenceId}`;
 /** Expose immutable session-owned Evidence v2 records as MCP resources. */
 export const registerEvidenceResources = (server, session) => {
+    registerReconstructionCoverageResource(server, session);
+    registerInvestigationWorkspaceResource(server, session);
+    registerSessionEvidenceResource(server, session);
+    registerActiveResidualUnknownsResource(server, session);
+    registerAnalysisSnapshotResource(server, session);
+    registerArtifactPageResource(server, session);
+    registerFunctionDossierResource(server, session);
+    registerEvidenceSectionResource(server, session);
+    registerJavaScriptApplicationGraphResource(server, session);
+    registerResidualUnknownResource(server, session);
+};
+const registerReconstructionCoverageResource = (server, session) => {
+    server.registerResource("reconstruction-coverage-revision", new ResourceTemplate("rea://reconstruction-coverage/{workspaceId}/revision/{revision}", {
+        list: () => ({
+            resources: session
+                .reconstructionCoverageWorkspaces()
+                .map((workspace) => ({
+                uri: coverageWorkspaceUri(workspace.workspace_id, workspace.revision),
+                name: `${workspace.workspace_id} revision ${String(workspace.revision)}`,
+                title: `${workspace.name} coverage revision ${String(workspace.revision)}`,
+                description: "Immutable evidence-backed reconstruction coverage workspace revision.",
+                mimeType: "application/json",
+            })),
+        }),
+    }), {
+        title: "Reconstruction coverage revision",
+        description: "Canonical CAS-linked surfaces, owners, claims, verifiers, evidence, and completion boundaries.",
+        mimeType: "application/json",
+    }, (uri, variables) => {
+        const workspaceId = stringVariable(variables.workspaceId, uri.href);
+        const revisionText = stringVariable(variables.revision, uri.href);
+        if (!/^\d+$/u.test(revisionText))
+            throw new ResourceNotFoundError(uri.href);
+        const workspace = session.reconstructionCoverageWorkspace(workspaceId, Number(revisionText));
+        if (workspace === undefined)
+            throw new ResourceNotFoundError(uri.href);
+        return jsonResource(uri.href, workspace);
+    });
+};
+const registerInvestigationWorkspaceResource = (server, session) => {
     server.registerResource("investigation-workspace-revision", new ResourceTemplate("rea://workspace/{workspaceId}/revision/{revision}", {
         list: () => ({
             resources: session.investigationWorkspaces().map((workspace) => ({
@@ -40,6 +81,8 @@ export const registerEvidenceResources = (server, session) => {
             throw new ResourceNotFoundError(uri.href);
         return jsonResource(uri.href, workspace);
     });
+};
+const registerSessionEvidenceResource = (server, session) => {
     server.registerResource("session-evidence", new ResourceTemplate("rea://evidence/{evidenceId}", {
         list: () => ({
             resources: session.exportEvidenceBundle().records.map((evidence) => ({
@@ -77,11 +120,15 @@ export const registerEvidenceResources = (server, session) => {
             ],
         };
     });
+};
+const registerActiveResidualUnknownsResource = (server, session) => {
     server.registerResource("active-residual-unknowns", "rea://unknowns/active", {
         title: "Active residual unknowns",
         description: "Current unresolved session-owned residual unknown heads.",
         mimeType: "application/json",
     }, (uri) => jsonResource(uri.href, session.listUnknowns().filter(({ status }) => status !== "resolved")));
+};
+const registerAnalysisSnapshotResource = (server, session) => {
     server.registerResource("analysis-snapshot", new ResourceTemplate("rea://snapshot/{snapshotDigest}", {
         list: () => {
             const snapshot = session.exportAnalysisSnapshot();
@@ -111,6 +158,8 @@ export const registerEvidenceResources = (server, session) => {
             throw new ResourceNotFoundError(uri.href);
         return jsonResource(uri.href, snapshot.value);
     });
+};
+const registerArtifactPageResource = (server, session) => {
     server.registerResource("artifact-page", new ResourceTemplate("rea://artifact/{manifestId}/{collection}", {
         list: undefined,
         complete: {
@@ -143,6 +192,8 @@ export const registerEvidenceResources = (server, session) => {
             limitations: evidence.limitations,
         });
     });
+};
+const registerFunctionDossierResource = (server, session) => {
     server.registerResource("function-dossier", new ResourceTemplate("rea://function/{targetSha256}/{address}", {
         list: undefined,
     }), {
@@ -161,6 +212,8 @@ export const registerEvidenceResources = (server, session) => {
             throw new ResourceNotFoundError(uri.href);
         return jsonResource(uri.href, evidence);
     });
+};
+const registerEvidenceSectionResource = (server, session) => {
     server.registerResource("evidence-section", new ResourceTemplate("rea://evidence/{evidenceId}/section/{section}", {
         list: undefined,
         complete: {
@@ -191,6 +244,8 @@ export const registerEvidenceResources = (server, session) => {
             value,
         });
     });
+};
+const registerResidualUnknownResource = (server, session) => {
     server.registerResource("residual-unknown", new ResourceTemplate("rea://unknown/{unknownId}", {
         list: () => ({
             resources: session.listUnknowns().map((unknown) => ({
@@ -224,6 +279,7 @@ export const registerEvidenceResources = (server, session) => {
         return jsonResource(uri.href, { current: unknown, history });
     });
 };
+const coverageWorkspaceUri = (workspaceId, revision) => `rea://reconstruction-coverage/${workspaceId}/revision/${String(revision)}`;
 const workspaceUri = (workspaceId, revision) => `rea://workspace/${workspaceId}/revision/${String(revision)}`;
 const EVIDENCE_SECTIONS = [
     "result",