rea-agents 1.7.0 → 2.0.0

package/dist/replay/SystemJavaScriptReplayHost.js

@@ -0,0 +1,182 @@
+import { constants } from "node:fs";
+import { mkdtemp, open, readFile, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { digestBytes } from "../application/JavaScriptReplayPlanning.js";
+import { buildLinuxX64ReplaySeccomp, linuxX64ReplaySeccompDigest, } from "./LinuxSeccompPolicy.js";
+import { resolveLinuxRuntimeClosure } from "./LinuxRuntimeClosure.js";
+const VERSION_OUTPUT_LIMIT = 16 * 1024;
+/** Production planning host for descriptor-backed reads and fail-closed probes. */
+export class SystemJavaScriptReplayHost {
+    async readSource(path, maximumBytes) {
+        const canonicalPath = await realpath(path);
+        const handle = await open(canonicalPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const metadata = await handle.stat();
+            if (!metadata.isFile() || metadata.size > maximumBytes)
+                throw new RangeError(`Replay source exceeds its declared limit: ${canonicalPath}`);
+            const bytes = await handle.readFile();
+            return { canonicalPath, bytes };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async identifyExecutable(path, versionArguments) {
+        const canonicalPath = await realpath(path);
+        const metadata = await stat(canonicalPath);
+        if (!metadata.isFile())
+            throw new TypeError(`Replay executable is not a file: ${canonicalPath}`);
+        const [bytes, version] = await Promise.all([
+            readFile(canonicalPath),
+            capture(canonicalPath, versionArguments, VERSION_OUTPUT_LIMIT),
+        ]);
+        return {
+            path: canonicalPath,
+            version: version.trim(),
+            sha256: digestBytes(bytes),
+        };
+    }
+    identifyWorker() {
+        return this.identifyExecutable(fileURLToPath(new URL("./JavaScriptReplayWorker.js", import.meta.url)), []);
+    }
+    identifyRuntimeClosure(nodePath) {
+        return resolveLinuxRuntimeClosure(nodePath);
+    }
+    seccompDigest() {
+        return linuxX64ReplaySeccompDigest();
+    }
+    async probe(policy) {
+        if (process.platform !== "linux" || process.arch !== "x64")
+            throw new TypeError("Controlled replay requires Linux x86_64 in v1");
+        const bwrapMetadata = await stat(policy.bubblewrapPath);
+        if ((bwrapMetadata.mode & 0o4000) !== 0)
+            throw new TypeError("Setuid Bubblewrap is not admitted by replay policy");
+        if ((await readFile("/sys/fs/cgroup/cgroup.controllers", "utf8")).trim()
+            .length === 0)
+            throw new TypeError("Controlled replay requires delegated cgroup v2");
+        const directory = await mkdtemp(join(tmpdir(), "rea-replay-probe-"));
+        const filterPath = join(directory, "seccomp.bpf");
+        await writeFile(filterPath, buildLinuxX64ReplaySeccomp(), { mode: 0o600 });
+        const filter = await open(filterPath, "r");
+        try {
+            await run(policy.bubblewrapPath, [
+                "--unshare-all",
+                "--unshare-user",
+                "--disable-userns",
+                "--new-session",
+                "--die-with-parent",
+                "--cap-drop",
+                "ALL",
+                "--ro-bind",
+                "/usr",
+                "/usr",
+                "--ro-bind",
+                "/lib",
+                "/lib",
+                "--ro-bind-try",
+                "/lib64",
+                "/lib64",
+                "--proc",
+                "/proc",
+                "--dev",
+                "/dev",
+                "--seccomp",
+                "3",
+                "--",
+                "/usr/bin/true",
+            ], ["ignore", "pipe", "pipe", filter.fd]);
+            await runExpectFailure(policy.bubblewrapPath, [
+                "--unshare-all",
+                "--unshare-user",
+                "--disable-userns",
+                "--new-session",
+                "--die-with-parent",
+                "--cap-drop",
+                "ALL",
+                "--ro-bind",
+                "/usr",
+                "/usr",
+                "--ro-bind",
+                "/lib",
+                "/lib",
+                "--ro-bind-try",
+                "/lib64",
+                "/lib64",
+                "--proc",
+                "/proc",
+                "--dev",
+                "/dev",
+                "--seccomp",
+                "3",
+                "--",
+                "/usr/bin/unshare",
+                "--mount",
+                "/usr/bin/true",
+            ], ["ignore", "pipe", "pipe", filter.fd]);
+            await run(policy.systemdRunPath, [
+                "--user",
+                "--pipe",
+                "--wait",
+                "--service-type=exec",
+                "--quiet",
+                "--property=MemoryMax=16777216",
+                "--property=MemorySwapMax=0",
+                "--property=TasksMax=2",
+                "--",
+                "/usr/bin/true",
+            ]);
+        }
+        finally {
+            await filter.close();
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}
+const capture = async (executable, arguments_, maximumBytes) => {
+    if (arguments_.length === 0)
+        return "content-addressed-worker-v1";
+    const result = await collect(executable, arguments_, maximumBytes);
+    if (result.code !== 0)
+        throw new TypeError(`Replay executable probe failed: ${executable}`);
+    return result.stdout.length > 0 ? result.stdout : result.stderr;
+};
+const run = async (executable, arguments_, stdio) => {
+    const result = await collect(executable, arguments_, VERSION_OUTPUT_LIMIT, stdio);
+    if (result.code !== 0)
+        throw new TypeError(`Replay feature probe failed (${String(result.code)}): ${executable}: ${result.stderr.trim()}`);
+};
+const runExpectFailure = async (executable, arguments_, stdio) => {
+    const result = await collect(executable, arguments_, VERSION_OUTPUT_LIMIT, stdio);
+    if (result.code === 0)
+        throw new TypeError(`Replay denial probe unexpectedly succeeded: ${executable}`);
+};
+const collect = async (executable, arguments_, maximumBytes, stdio = ["ignore", "pipe", "pipe"]) => new Promise((resolve, reject) => {
+    const child = spawn(executable, [...arguments_], { stdio });
+    const timeout = setTimeout(() => child.kill("SIGKILL"), 5_000);
+    timeout.unref();
+    let stdout = "";
+    let stderr = "";
+    const retain = (current, chunk) => {
+        const remaining = Math.max(0, maximumBytes - Buffer.byteLength(current));
+        return current + chunk.subarray(0, remaining).toString("utf8");
+    };
+    if (child.stdout !== null)
+        child.stdout.on("data", (chunk) => {
+            stdout = retain(stdout, chunk);
+        });
+    if (child.stderr !== null)
+        child.stderr.on("data", (chunk) => {
+            stderr = retain(stderr, chunk);
+        });
+    child.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+    });
+    child.once("close", (code) => {
+        clearTimeout(timeout);
+        resolve({ code, stdout, stderr });
+    });
+});

package/dist/server/createServer.js

@@ -5,12 +5,17 @@ import { registerOfficialTools } from "./registerOfficialTools.js";
 import { registerSessionTools } from "./registerSessionTools.js";
 import { registerNativeTools } from "./registerNativeTools.js";
 import { registerArtifactTools } from "./registerArtifactTools.js";
+import { registerManagedTools } from "./registerManagedTools.js";
+import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
 import { silentLogger } from "../logger.js";
 import { registerGuidedPrompts } from "./registerPrompts.js";
 import { registerEvidenceResources } from "./registerEvidenceResources.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { registerBrowserTools } from "./registerBrowserTools.js";
 import { registerElectronTools } from "./registerElectronTools.js";
+import { registerApplicationTools } from "./registerApplicationTools.js";
+import { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -66,6 +71,14 @@ export const createServer = (analysis, session, options = {}) => {
                 server.sendResourceListChanged();
             return recorded;
         };
+    const recordEvidenceWithUnknown = session === undefined
+        ? undefined
+        : (evidence, input) => {
+            const recorded = session.recordEvidenceWithUnknown(evidence, input);
+            if (recorded.ok)
+                server.sendResourceListChanged();
+            return recorded;
+        };
     registerOfficialTools(server, analysis, {
         logger: toolLogger,
         activeTarget,
@@ -96,6 +109,26 @@ export const createServer = (analysis, session, options = {}) => {
             ? {}
             : { permissionAuthority: options.permissionAuthority }),
     });
+    registerManagedTools(server, analysis, {
+        logger: toolLogger,
+        activeTarget,
+        recordEvidence,
+    });
+    if (session !== undefined)
+        registerManagedWorkflowTools(server, {
+            logger: toolLogger,
+            recordEvidence,
+            recordEvidenceWithUnknown,
+            session,
+            runtime: {
+                policy: options.managedRuntimePolicy ?? {
+                    enabled: false,
+                    roots: [],
+                    executablePath: "/usr/bin/dotnet",
+                },
+                authority: options.permissionAuthority,
+            },
+        });
     registerBrowserTools(server, {
         logger: toolLogger,
         browser: options.browserObservation,
@@ -108,6 +141,25 @@ export const createServer = (analysis, session, options = {}) => {
         permissionAuthority: options.permissionAuthority,
         recordEvidence,
     });
+    registerApplicationTools(server, {
+        logger: toolLogger,
+        recordEvidence,
+        recordEvidenceWithUnknown,
+        replay: {
+            policy: options.javascriptReplayPolicy ?? {
+                enabled: false,
+                roots: [],
+                nodePath: process.execPath,
+                bubblewrapPath: "/usr/bin/bwrap",
+                systemdRunPath: "/usr/bin/systemd-run",
+                systemctlPath: "/usr/bin/systemctl",
+                shellPath: "/usr/bin/bash",
+            },
+            host: options.javascriptReplayHost ?? new SystemJavaScriptReplayHost(),
+            runner: options.javascriptReplayRunner ?? new LinuxJavaScriptReplayRunner(),
+            authority: options.permissionAuthority,
+        },
+    });
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
         registerEvidenceResources(server, session);

package/dist/server/registerApplicationTools.js

@@ -0,0 +1,115 @@
+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";
+/** 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,
+    });
+};

package/dist/server/registerArtifactComparisonTool.js

@@ -2,27 +2,35 @@ import { artifactComparisonInputSchema, compareArtifacts, } from "../domain/arti
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
-import { resolveSessionEvidence } from "./sessionEvidence.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";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsed = artifactComparisonInputSchema.parse(input);
-        const left = resolveSessionEvidence(session, parsed.left);
+        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 = resolveSessionEvidence(session, parsed.right);
+        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));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
-        const leftEvidenceIds = evidenceIds(parsed.left);
-        const rightEvidenceIds = evidenceIds(parsed.right);
+        const leftEvidenceIds = parsed.left_evidence_ids;
+        const rightEvidenceIds = parsed.right_evidence_ids;
         const evidence = createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
             predicateType: "rea.artifact-comparison/v1",
             operation: contract.name,
@@ -49,8 +57,8 @@ const artifactUnknownInput = (input, status) => {
         question: `Artifact comparison is ${status}`,
         severity: status === "unknown" || status === "truncated" ? "high" : "medium",
         domain: "artifact-comparison",
-        supporting_evidence_ids: evidenceIds(input.left),
-        contradicting_evidence_ids: evidenceIds(input.right),
+        supporting_evidence_ids: [...input.left_evidence_ids],
+        contradicting_evidence_ids: [...input.right_evidence_ids],
         required_authority: "shipped-artifact",
         required_confidence: "observed",
         required_environment: null,
@@ -63,4 +71,3 @@ const artifactUnknownInput = (input, status) => {
         relationships: [],
     };
 };
-const evidenceIds = (input) => (Array.isArray(input) ? input : [input]).map(({ evidence_id: id }) => id);

package/dist/server/registerBrowserTools.js

@@ -9,19 +9,26 @@ import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } fr
 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";
 /** 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 parsed = listBrowserTargetsInputSchema.parse(input);
+        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);
     });
     server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), async (input, context) => {
-        const parsed = inspectWebPageInputSchema.parse(input);
+        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),
@@ -31,7 +38,10 @@ export const registerBrowserTools = (server, options) => {
         return evidenceResult(options, inspectContract, result.value);
     });
     server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), async (input, context) => {
-        const parsed = analyzeWebBundleInputSchema.parse(input);
+        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),
@@ -41,7 +51,10 @@ export const registerBrowserTools = (server, options) => {
         return evidenceResult(options, analyzeContract, result.value);
     });
     server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), async (input, context) => {
-        const parsed = observeWebSessionInputSchema.parse(input);
+        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),
@@ -51,7 +64,10 @@ export const registerBrowserTools = (server, options) => {
         return evidenceResult(options, sessionContract, result.value);
     });
     server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), async (input, context) => {
-        const parsed = discoverWebMcpToolsInputSchema.parse(input);
+        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),
@@ -61,14 +77,20 @@ export const registerBrowserTools = (server, options) => {
         return evidenceResult(options, webMcpContract, result.value);
     });
     server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), async (input) => {
-        const parsed = compareWebCapturesInputSchema.parse(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);
     });
     server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), async (input, context) => {
-        const parsed = captureWebScreenshotInputSchema.parse(input);
+        const parsedInput = safeParseToolInput(captureWebScreenshotInputSchema, input, screenshotContract.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, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
@@ -78,7 +100,10 @@ export const registerBrowserTools = (server, options) => {
         return evidenceResult(options, screenshotContract, result.value);
     });
     server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), async (input) => {
-        const parsed = compareWebScreenshotsInputSchema.parse(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);

package/dist/server/registerBundleComparisonTool.js

@@ -1,31 +1,29 @@
+import { readEvidenceBundle } from "../application/EvidenceBundleFiles.js";
 import { bundleComparisonInputSchema, compareBundles, } from "../domain/bundleComparison.js";
 import { createEvidence } from "../domain/evidence.js";
-import { EvidenceIntegrityError } from "../domain/errors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
+import { ok } from "../domain/result.js";
 import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toCallToolResult } from "./toolResult.js";
-import { isSessionEvidence } from "./sessionEvidence.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
 /** Register canonical Evidence bundle comparison. */
-export const registerBundleComparisonTool = (server, session, contract) => {
+export const registerBundleComparisonTool = (server, session, contract, evidenceFilePolicy) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsed = bundleComparisonInputSchema.parse(input);
-        const sourceIds = [
-            ...new Set([
-                ...parsed.left.records.map(({ evidence_id: id }) => id),
-                ...parsed.right.records.map(({ evidence_id: id }) => id),
-            ]),
-        ].sort();
-        if ([...parsed.left.records, ...parsed.right.records].some((evidence) => !isSessionEvidence(session, evidence)))
-            return toCallToolResult(err(new EvidenceIntegrityError("Bundle comparison input Evidence is not present in this session")), contract);
-        const ownedUnknownDigests = new Set(session
-            .exportEvidenceBundle()
-            .unknowns.map(({ revision_digest: digest }) => digest));
-        if ([...parsed.left.unknowns, ...parsed.right.unknowns].some(({ revision_digest: digest }) => !ownedUnknownDigests.has(digest)))
-            return toCallToolResult(err(new EvidenceIntegrityError("Bundle comparison input unknown history is not present in this session")), contract);
-        const computed = await runDerivedOperation(context, contract.name, () => compareBundles(parsed.left, parsed.right, parsed.record_pairs, parsed.offset, parsed.limit));
+        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),
+        ]);
+        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));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
@@ -43,7 +41,6 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             confidence: "derived",
             authority: "analyst-inference",
             limitations: comparison.limitations,
-            evidenceLinks: sourceIds,
         });
         const recorded = session.recordEvidence(evidence);
         return toCallToolResult(recorded.ok ? ok(evidence) : recorded, contract);