rea-agents 3.0.0 → 3.2.0

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,27 +1,19 @@
-import { resolveTraceJavaScriptSemanticsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/JavaScriptSemanticTraceService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { traceJavaScriptSemanticsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
-import { recordResult, recordSources } from "./helpers.js";
+import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
 export const registerTraceJavaScriptSemanticsTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsedInput = safeParseToolInput(traceJavaScriptSemanticsRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveTraceJavaScriptSemanticsRequestValidated(parsedInput.value, options.evidenceLookup);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(resolved.value)));
+        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(input)));
         if (!result.ok)
             return toCallToolResult(result, contract);
-        const recorded = recordSources(options.recordEvidence, [
-            resolved.value.application,
+        const recorded = recordSessionEvidenceSources(options.recordEvidence, [
+            input.application,
         ]);
         if (!recorded.ok)
             return toCallToolResult(recorded, contract);

package/dist/server/registerApplicationTools.js

@@ -7,7 +7,6 @@ import { registerControlledReplayTool } from "./registerApplicationTools/control
 import { registerCharacterizationTools } from "./registerApplicationTools/characterization.js";
 import { registerCoverageTools } from "./registerApplicationTools/coverage.js";
 import { registerReconstructionObligationLedgerTool } from "./registerApplicationTools/obligationLedger.js";
-import { registerReconstructionReadinessTool } from "./registerApplicationTools/readiness.js";
 /** Register provider-neutral JavaScript application graph workflows. */
 export const registerApplicationTools = (server, options) => {
     registerTraceFeatureTool(server, options);
@@ -18,6 +17,5 @@ export const registerApplicationTools = (server, options) => {
     registerControlledReplayTool(server, options);
     registerCharacterizationTools(server, options);
     registerReconstructionObligationLedgerTool(server, options);
-    registerReconstructionReadinessTool(server, options);
     registerCoverageTools(server, options);
 };

package/dist/server/registerArtifactComparisonTool.js

@@ -1,44 +1,37 @@
-import { artifactComparisonInputSchema, compareArtifacts, } from "../domain/artifactComparison.js";
-import { createEvidence } from "../domain/evidence.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { compareArtifacts } from "../domain/artifactComparison.js";
+import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(artifactComparisonInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const expected = {
-            operation: "inventory_artifact",
-            predicate: "rea.analysis/v2",
-        };
-        const left = resolveSessionEvidenceIds(session, parsed.left_evidence_ids, expected);
-        if (!left.ok)
-            return toCallToolResult(left, contract);
-        const right = resolveSessionEvidenceIds(session, parsed.right_evidence_ids, expected);
-        if (!right.ok)
-            return toCallToolResult(right, contract);
-        const computed = await runDerivedOperation(context, contract.name, () => compareArtifacts(left.value, right.value, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => {
+            const left = parseEvidence(input.left);
+            const right = parseEvidence(input.right);
+            return { left, right, comparison: compareArtifacts(left, right) };
+        });
         if (!computed.ok)
             return toCallToolResult(computed, contract);
-        const comparison = computed.value;
-        const leftEvidenceIds = parsed.left_evidence_ids;
-        const rightEvidenceIds = parsed.right_evidence_ids;
+        const { left, right, comparison } = computed.value;
+        const sources = [left, right];
+        for (const source of sources) {
+            const recordedSource = session.recordEvidence(source);
+            if (!recordedSource.ok)
+                return toCallToolResult(recordedSource, contract);
+        }
+        const leftEvidenceIds = [left.evidence_id];
+        const rightEvidenceIds = [right.evidence_id];
         const evidence = createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
-            predicateType: "rea.artifact-comparison/v1",
+            predicateType: "rea.artifact-comparison",
             operation: contract.name,
             parameters: {
                 left_evidence_ids: leftEvidenceIds,
                 right_evidence_ids: rightEvidenceIds,
-                offset: parsed.offset,
-                limit: parsed.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -46,26 +39,25 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(parsed, comparison.status)), contract);
+        return toCallToolResult(recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status)), contract);
     });
 };
-const artifactUnknownInput = (input, status) => {
-    if (input.unknown_registry_approved !== true || status === "unchanged")
+const artifactUnknownInput = (left, right, status) => {
+    if (status === "unchanged" || left.evidence_id === right.evidence_id)
         return undefined;
     return {
-        approved: true,
         question: `Artifact comparison is ${status}`,
         severity: status === "unknown" || status === "truncated" ? "high" : "medium",
         domain: "artifact-comparison",
-        supporting_evidence_ids: [...input.left_evidence_ids],
-        contradicting_evidence_ids: [...input.right_evidence_ids],
+        supporting_evidence_ids: [left.evidence_id],
+        contradicting_evidence_ids: [right.evidence_id],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,
         recommended_probes: [
             {
-                operation: "inventory_artifact",
-                rationale: "Capture both complete artifact graphs under equal limits.",
+                operation: "inspect_artifact",
+                rationale: "Inspect both artifacts and compare their complete graphs.",
             },
         ],
         relationships: [],

package/dist/server/registerBrowserScenarioTool.js

@@ -2,24 +2,19 @@ import { captureBrowserScenario } from "../application/BrowserScenarioCaptureSer
 import { BROWSER_SCENARIO_TOOL_CONTRACTS } from "../contracts/browserScenarioToolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register the controlled browser scenario tool even when policy disables it. */
 export const registerBrowserScenarioTool = (server, options) => {
     const [contract] = BROWSER_SCENARIO_TOOL_CONTRACTS;
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsed = safeParseToolInput(browserScenarioSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, options.permissionAuthority, parsed.value, { signal: context.mcpReq.signal }));
+        const scenario = browserScenarioSchema.parse(input);
+        const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, options.permissionAuthority, scenario, { 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({ ok: true, value: result.value }, contract, {
-                evidenceResourcesAvailable: recorded !== undefined,
-            });
+            : toCallToolResult({ ok: true, value: result.value }, contract);
     });
 };

package/dist/server/registerBrowserTools.js

@@ -1,96 +1,51 @@
 import { analyzeWebBundle, captureWebScreenshot, compareWebCaptureEvidence, compareWebScreenshotEvidence, discoverWebMcpTools, inspectWebPage, listBrowserTargets, observeWebSession, } from "../application/BrowserObservationService.js";
 import { BROWSER_TOOL_CONTRACTS } from "../contracts/browserToolContracts.js";
-import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "../domain/browserObservation.js";
 import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
-import { observeWebSessionInputSchema } from "../domain/browserSession.js";
-import { discoverWebMcpToolsInputSchema } from "../domain/webMcpDiscovery.js";
-import { browserCaptureComparisonInputSchema } from "../domain/browserCaptureComparison.js";
-import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } from "../domain/webScreenshot.js";
+import { inspectWebPageInputSchema } from "../domain/browserObservation.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";
 /** Register browser tools even when policy/provider availability denies execution. */
+// 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;
-    registerBrowserTool(server, options, {
-        contract: listContract,
-        schema: listBrowserTargetsInputSchema,
-        execute: (parsed, { signal }) => listBrowserTargets(options.browser, options.permissionAuthority, parsed, {
-            signal,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: inspectContract,
-        schema: inspectWebPageInputSchema,
-        execute: (parsed, { signal, progress }) => inspectWebPage(options.browser, options.permissionAuthority, parsed, {
-            signal,
-            progress,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: analyzeContract,
-        schema: analyzeWebBundleInputSchema,
-        execute: (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, parsed, {
-            signal,
-            progress,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: sessionContract,
-        schema: observeWebSessionInputSchema,
-        execute: (parsed, { signal, progress }) => observeWebSession(options.browser, options.permissionAuthority, parsed, {
-            signal,
-            progress,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: webMcpContract,
-        schema: discoverWebMcpToolsInputSchema,
-        execute: (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, options.permissionAuthority, parsed, {
-            signal,
-            progress,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: captureDiffContract,
-        schema: browserCaptureComparisonInputSchema,
-        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,
-        }),
-    });
-    registerBrowserTool(server, options, {
-        contract: screenshotDiffContract,
-        schema: compareWebScreenshotsInputSchema,
-        execute: (parsed, _context) => compareWebScreenshotEvidence(options.browser, parsed),
-    });
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(options, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, options.permissionAuthority, parsed, {
+        signal,
+    })));
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, options.permissionAuthority, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, analyzeWebBundleInputSchema.parse(parsed), {
+        signal,
+        progress,
+    })));
+    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), (input, context) => runBrowserTool(options, sessionContract, { input, context }, (parsed, { signal, progress }) => observeWebSession(options.browser, options.permissionAuthority, parsed, {
+        signal,
+        progress,
+    })));
+    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), (input, context) => runBrowserTool(options, webMcpContract, { input, context }, (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, options.permissionAuthority, parsed, {
+        signal,
+        progress,
+    })));
+    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), (input, context) => runBrowserTool(options, captureDiffContract, { input, context }, (parsed) => compareWebCaptureEvidence(options.browser, parsed)));
+    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), (input, context) => runBrowserTool(options, screenshotContract, { input, context }, (parsed, { signal, progress }) => captureWebScreenshot(options.browser, options.permissionAuthority, parsed, {
+        signal,
+        progress,
+    })));
+    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), (input, context) => runBrowserTool(options, screenshotDiffContract, { input, context }, (parsed) => 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, 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, spec.contract);
-        return evidenceResult(options, spec.contract, result.value);
-    });
+const runBrowserTool = async (options, contract, request, execute) => {
+    const { input, context } = request;
+    const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
+        signal: context.mcpReq.signal,
+        progress: mcpProgressReporter(context),
+    }));
+    if (!result.ok)
+        return toCallToolResult(result, contract);
+    return evidenceResult(options, contract, result.value);
 };
 const evidenceResult = (options, contract, evidence) => {
     const recorded = options.recordEvidence?.(evidence);
     return recorded !== undefined && !recorded.ok
         ? toCallToolResult(recorded, contract)
-        : toCallToolResult({ ok: true, value: evidence }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        : toCallToolResult({ ok: true, value: evidence }, contract);
 };

package/dist/server/registerBundleComparisonTool.js

@@ -1,41 +1,35 @@
 import { readEvidenceBundle } from "../application/EvidenceBundleFiles.js";
-import { bundleComparisonInputSchema, compareBundles, } from "../domain/bundleComparison.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { compareBundles } from "../domain/bundleComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { ok } from "../domain/result.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register canonical Evidence bundle comparison. */
-export const registerBundleComparisonTool = (server, session, contract, evidenceFilePolicy) => {
+export const registerBundleComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(bundleComparisonInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
         const [left, right] = await Promise.all([
-            readEvidenceBundle(parsed.left_bundle_path, evidenceFilePolicy),
-            readEvidenceBundle(parsed.right_bundle_path, evidenceFilePolicy),
+            readEvidenceBundle(input.left_bundle_path),
+            readEvidenceBundle(input.right_bundle_path),
         ]);
         if (!left.ok)
             return toCallToolResult(left, contract);
         if (!right.ok)
             return toCallToolResult(right, contract);
-        const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, parsed.record_pairs, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, input.record_pairs));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
         const evidence = createEvidence(undefined, BUNDLE_COMPARISON_PROVIDER, {
-            predicateType: "rea.bundle-comparison/v1",
+            predicateType: "rea.bundle-comparison",
             operation: contract.name,
             parameters: {
                 left_bundle_sha256: comparison.left_bundle_sha256,
                 right_bundle_sha256: comparison.right_bundle_sha256,
-                record_pairs: parsed.record_pairs,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                record_pairs: input.record_pairs,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",

package/dist/server/registerCloseLifecycleTool.js

@@ -1,51 +1,29 @@
 import { writeAnalysisSnapshot } from "../application/AnalysisSnapshotFiles.js";
-import { closeBinaryInputSchema } from "../contracts/sessionLifecycleInputs.js";
 import { ok } from "../domain/result.js";
 import { reportLifecycleEnd, reportLifecycleStart, } from "./lifecycleProgress.js";
-import { logToolExecution } from "./toolLogging.js";
-import { toCallToolResult } from "./toolResult.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { permissionFailure } from "./permissionFailure.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register provider cleanup and optional pre-close snapshot persistence. */
-export const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], snapshotFilePolicy, permissionAuthority, }) => {
+export const registerCloseLifecycleTool = ({ server, session, logger, contracts: [, closeContract], }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(closeBinaryInputSchema, input, closeContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, closeContract);
-        const parsed = parsedInput.value;
         const progress = mcpProgressReporter(context);
-        if (parsed.snapshot_path === undefined) {
+        if (input.snapshot_path === undefined) {
             await reportLifecycleStart(progress, closeContract.name);
             const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-            server.sendToolListChanged();
             return toCallToolResult(closed, closeContract);
         }
-        if (permissionAuthority !== undefined) {
-            const authorized = await permissionAuthority.authorize({
-                capability: "snapshot_write",
-                roots: [parsed.snapshot_path],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
-            }, "write");
-            if (!authorized.ok)
-                return toCallToolResult(permissionFailure(authorized), closeContract);
-        }
         const snapshot = session.exportAnalysisSnapshot();
         if (!snapshot.ok)
             return toCallToolResult(snapshot, closeContract);
-        const written = await writeAnalysisSnapshot(snapshot.value, parsed.snapshot_path, parsed.overwrite, snapshotFilePolicy);
+        const written = await writeAnalysisSnapshot(snapshot.value, input.snapshot_path, input.overwrite);
         if (!written.ok)
             return toCallToolResult(written, closeContract);
         await reportLifecycleStart(progress, closeContract.name, "snapshot written; closing provider");
         const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
         await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-        server.sendToolListChanged();
         return closed.ok
             ? toCallToolResult(ok({
                 path: written.value.path,

package/dist/server/registerElectronTools.js

@@ -1,77 +1,41 @@
+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 { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
-import { analyzeJavaScriptApplicationToolInputSchema, ELECTRON_TOOL_CONTRACTS, } from "../contracts/electronToolContracts.js";
-import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
-import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
+import { ELECTRON_TOOL_CONTRACTS } from "../contracts/electronToolContracts.js";
+import { inspectElectronPageInputSchema } from "../domain/electronObservation.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 { summarizeJavaScriptApplicationEvidence } from "./javascriptApplicationResult.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register Electron tools even when provider or permission policy 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] = ELECTRON_TOOL_CONTRACTS;
-    registerElectronTool(server, options, {
-        contract: listContract,
-        schema: listElectronTargetsInputSchema,
-        execute: (parsed, { signal }) => listElectronTargets(options.electron, options.permissionAuthority, parsed, {
-            signal,
-        }),
-    });
-    registerElectronTool(server, options, {
-        contract: inspectContract,
-        schema: inspectElectronPageInputSchema,
-        execute: (parsed, { signal, progress }) => inspectElectronPage(options.electron, options.permissionAuthority, parsed, {
-            signal,
-            progress,
-        }),
-    });
-    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 [listContract, inspectContract, analyzeContract, reconcileContract, activeContract,] = ELECTRON_TOOL_CONTRACTS;
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(options, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, options.permissionAuthority, parsed, {
+        signal,
+    })));
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(options, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
+        const request = inspectElectronPageInputSchema.parse(parsed);
+        return inspectElectronPage(options.electron, options.permissionAuthority, request, { signal, progress });
+    }));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
+    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(options, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
+    server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(options, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, options.permissionAuthority, parsed, { signal, progress })));
 };
-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, 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, spec.contract);
-        return evidenceResult(options, spec.contract, result.value, spec.projectEvidence?.(result.value, parsedInput.value));
-    });
+const runElectronTool = async (options, contract, request, execute) => {
+    const { input, context } = request;
+    const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
+        signal: context.mcpReq.signal,
+        progress: mcpProgressReporter(context),
+    }));
+    if (!result.ok)
+        return toCallToolResult(result, contract);
+    return evidenceResult(options, contract, result.value);
 };
-const evidenceResult = (options, contract, evidence, projection) => {
+const evidenceResult = (options, contract, evidence) => {
     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 }),
-                }),
-        });
+        : toCallToolResult({ ok: true, value: evidence }, contract);
 };