rea-agents 2.5.0 → 3.1.0

package/dist/server/registerApplicationTools/coverage.js

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

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -1,8 +1,6 @@
 import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstructionObligationLedgerRequest, } from "../../application/ReconstructionObligationLedgerService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionObligationLedgerInputSchema } from "../../domain/reconstructionObligationLedgerSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
@@ -10,10 +8,7 @@ const contract = applicationToolContract("build_reconstruction_obligation_ledger
 /** Register conservative reconstruction-obligation generation and closure. */
 export const registerReconstructionObligationLedgerTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = safeParseToolInput(reconstructionObligationLedgerInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const resolved = resolveReconstructionObligationLedgerRequest(parsed.value);
+        const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(buildReconstructionObligationLedgerEvidenceValidated(resolved.value)));

package/dist/server/registerApplicationTools/readiness.js

@@ -1,9 +1,7 @@
 import { evaluateReconstructionReadinessValidated, resolveReconstructionReadinessRequest, } from "../../application/ReconstructionReadinessService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionReadinessInputSchema } from "../../domain/reconstructionReadinessSchemas.js";
 import { reconstructionReadinessReportSchema } from "../../domain/reconstructionReadinessSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { recordSources } from "./helpers.js";
@@ -11,10 +9,7 @@ const contract = applicationToolContract("evaluate_reconstruction_readiness");
 /** Register deterministic public-contract reconstruction conformance. */
 export const registerReconstructionReadinessTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = safeParseToolInput(reconstructionReadinessInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const resolved = resolveReconstructionReadinessRequest(parsed.value);
+        const resolved = resolveReconstructionReadinessRequest(input);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionReadinessValidated(resolved.value)));

package/dist/server/registerApplicationTools/traceFeature.js

@@ -1,20 +1,15 @@
-import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { resolveTraceApplicationFeatureRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { traceApplicationFeatureEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { traceApplicationFeatureRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
 const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
 export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
-        const parsedInput = safeParseToolInput(traceApplicationFeatureRequestSchema, input, traceContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, traceContract);
-        const resolved = resolveTraceApplicationFeatureRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveTraceApplicationFeatureRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, traceContract);
         const parsed = resolved.value;

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -1,8 +1,6 @@
 import { resolveTraceJavaScriptSemanticsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.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";
@@ -11,10 +9,7 @@ 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);
+        const resolved = resolveTraceJavaScriptSemanticsRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(resolved.value)));

package/dist/server/registerArtifactComparisonTool.js

@@ -1,44 +1,40 @@
-import { artifactComparisonInputSchema, compareArtifacts, } from "../domain/artifactComparison.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { compareArtifacts } from "../domain/artifactComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { resolveSessionEvidenceIds } from "./sessionEvidence.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);
+        const left = resolveSessionEvidenceIds(session, input.left_evidence_ids, expected);
         if (!left.ok)
             return toCallToolResult(left, contract);
-        const right = resolveSessionEvidenceIds(session, parsed.right_evidence_ids, expected);
+        const right = resolveSessionEvidenceIds(session, input.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, () => compareArtifacts(left.value, right.value, input.offset, input.limit));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
-        const leftEvidenceIds = parsed.left_evidence_ids;
-        const rightEvidenceIds = parsed.right_evidence_ids;
+        const leftEvidenceIds = input.left_evidence_ids;
+        const rightEvidenceIds = input.right_evidence_ids;
         const evidence = createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
             predicateType: "rea.artifact-comparison/v1",
             operation: contract.name,
             parameters: {
                 left_evidence_ids: leftEvidenceIds,
                 right_evidence_ids: rightEvidenceIds,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -46,7 +42,7 @@ 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(input, comparison.status)), contract);
     });
 };
 const artifactUnknownInput = (input, status) => {

package/dist/server/registerBrowserScenarioTool.js

@@ -1,18 +1,13 @@
 import { captureBrowserScenario } from "../application/BrowserScenarioCaptureService.js";
 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 result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, options.permissionAuthority, input, { signal: context.mcpReq.signal }));
         if (!result.ok)
             return toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);

package/dist/server/registerBrowserTools.js

@@ -1,90 +1,48 @@
 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 { 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, parsed, {
+        signal,
+        progress,
+    })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, options.permissionAuthority, 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);

package/dist/server/registerBundleComparisonTool.js

@@ -1,29 +1,25 @@
 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) => {
     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, evidenceFilePolicy),
+            readEvidenceBundle(input.right_bundle_path, evidenceFilePolicy),
         ]);
         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, input.offset, input.limit));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
@@ -33,9 +29,9 @@ export const registerBundleComparisonTool = (server, session, contract, evidence
             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,
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",

package/dist/server/registerCloseLifecycleTool.js

@@ -1,37 +1,30 @@
 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, }) => {
     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],
+                roots: [input.snapshot_path],
                 executables: [],
                 environment_names: [],
                 network: "none",
                 mount: false,
-                operation_identity: `close_binary:snapshot:${parsed.snapshot_path}`,
+                operation_identity: `close_binary:snapshot:${input.snapshot_path}`,
             }, "write");
             if (!authorized.ok)
                 return toCallToolResult(permissionFailure(authorized), closeContract);
@@ -39,13 +32,12 @@ export const registerCloseLifecycleTool = ({ server, session, logger, contracts:
         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, snapshotFilePolicy);
         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,63 +1,46 @@
+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 { summarizeJavaScriptApplicationEvidence } from "./javascriptApplicationResult.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 }),
+    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 }, (parsed, { signal, progress }) => inspectElectronPage(options.electron, options.permissionAuthority, parsed, {
+        signal,
+        progress,
+    })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, {
+        input,
+        context,
         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)),
-    });
+    }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(options.permissionAuthority, 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, projectEvidence } = 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, projectEvidence?.(result.value, input));
 };
 const evidenceResult = (options, contract, evidence, projection) => {
     const recorded = options.recordEvidence?.(evidence);