Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
test(mcp): cover strict compact wire contracts
morluto8de25d02302e
diff --git a/docs/mcp-schema-report.json b/docs/mcp-schema-report.jsonnew file mode 100644index 000000000..dda37b59b--- /dev/null+++ b/docs/mcp-schema-report.json@@ -0,0 +1,515 @@+{+ "generated_from": "@modelcontextprotocol/server 2.0.0-beta.4 wire registration",+ "tool_count": 84,+ "tools_list_bytes": 518457,+ "budgets": {+ "tools_list_bytes": 524288,+ "per_tool_bytes": 65536+ },+ "tools": [+ {+ "name": "address_name",+ "bytes": 1133,+ "input_schema_bytes": 401,+ "output_schema_bytes": 313+ },+ {+ "name": "analyze_function",+ "bytes": 10206,+ "input_schema_bytes": 2037,+ "output_schema_bytes": 7692+ },+ {+ "name": "analyze_javascript_application",+ "bytes": 19871,+ "input_schema_bytes": 2633,+ "output_schema_bytes": 16597+ },+ {+ "name": "analyze_swift_types",+ "bytes": 1321,+ "input_schema_bytes": 62,+ "output_schema_bytes": 852+ },+ {+ "name": "analyze_web_bundle",+ "bytes": 14995,+ "input_schema_bytes": 6550,+ "output_schema_bytes": 7940+ },+ {+ "name": "batch_decompile",+ "bytes": 12102,+ "input_schema_bytes": 226,+ "output_schema_bytes": 11475+ },+ {+ "name": "binary_overview",+ "bytes": 1643,+ "input_schema_bytes": 250,+ "output_schema_bytes": 977+ },+ {+ "name": "binary_session",+ "bytes": 13235,+ "input_schema_bytes": 367,+ "output_schema_bytes": 12368+ },+ {+ "name": "build_call_path",+ "bytes": 11300,+ "input_schema_bytes": 7493,+ "output_schema_bytes": 3335+ },+ {+ "name": "capture_process_scenario",+ "bytes": 20991,+ "input_schema_bytes": 10463,+ "output_schema_bytes": 9774+ },+ {+ "name": "capture_web_screenshot",+ "bytes": 5661,+ "input_schema_bytes": 771,+ "output_schema_bytes": 4454+ },+ {+ "name": "close_binary",+ "bytes": 1073,+ "input_schema_bytes": 214,+ "output_schema_bytes": 379+ },+ {+ "name": "comment",+ "bytes": 1082,+ "input_schema_bytes": 401,+ "output_schema_bytes": 313+ },+ {+ "name": "compare_application_versions",+ "bytes": 27986,+ "input_schema_bytes": 10250,+ "output_schema_bytes": 17168+ },+ {+ "name": "compare_artifacts",+ "bytes": 4095,+ "input_schema_bytes": 759,+ "output_schema_bytes": 2851+ },+ {+ "name": "compare_bundles",+ "bytes": 4559,+ "input_schema_bytes": 928,+ "output_schema_bytes": 3132+ },+ {+ "name": "compare_functions",+ "bytes": 4828,+ "input_schema_bytes": 725,+ "output_schema_bytes": 3611+ },+ {+ "name": "compare_process_captures",+ "bytes": 3866,+ "input_schema_bytes": 565,+ "output_schema_bytes": 2716+ },+ {+ "name": "compare_web_captures",+ "bytes": 33869,+ "input_schema_bytes": 31489,+ "output_schema_bytes": 1940+ },+ {+ "name": "compare_web_screenshots",+ "bytes": 3428,+ "input_schema_bytes": 1489,+ "output_schema_bytes": 1546+ },+ {+ "name": "correlate_static_and_runtime",+ "bytes": 13332,+ "input_schema_bytes": 8963,+ "output_schema_bytes": 3876+ },+ {+ "name": "current_address",+ "bytes": 938,+ "input_schema_bytes": 282,+ "output_schema_bytes": 285+ },+ {+ "name": "current_document",+ "bytes": 842,+ "input_schema_bytes": 219,+ "output_schema_bytes": 285+ },+ {+ "name": "current_procedure",+ "bytes": 952,+ "input_schema_bytes": 282,+ "output_schema_bytes": 285+ },+ {+ "name": "demangle_swift",+ "bytes": 2276,+ "input_schema_bytes": 221,+ "output_schema_bytes": 1717+ },+ {+ "name": "discover_webmcp_tools",+ "bytes": 7256,+ "input_schema_bytes": 1087,+ "output_schema_bytes": 5765+ },+ {+ "name": "export_evidence_bundle",+ "bytes": 12103,+ "input_schema_bytes": 196,+ "output_schema_bytes": 11479+ },+ {+ "name": "extract_artifact",+ "bytes": 6414,+ "input_schema_bytes": 1321,+ "output_schema_bytes": 4701+ },+ {+ "name": "find_changed_behavior",+ "bytes": 12296,+ "input_schema_bytes": 8586,+ "output_schema_bytes": 3182+ },+ {+ "name": "find_xrefs_to_name",+ "bytes": 1346,+ "input_schema_bytes": 128,+ "output_schema_bytes": 763+ },+ {+ "name": "get_call_graph",+ "bytes": 12061,+ "input_schema_bytes": 361,+ "output_schema_bytes": 11228+ },+ {+ "name": "get_objc_classes",+ "bytes": 1141,+ "input_schema_bytes": 127,+ "output_schema_bytes": 606+ },+ {+ "name": "get_objc_protocols",+ "bytes": 1079,+ "input_schema_bytes": 62,+ "output_schema_bytes": 610+ },+ {+ "name": "goto_address",+ "bytes": 1094,+ "input_schema_bytes": 424,+ "output_schema_bytes": 285+ },+ {+ "name": "import_evidence_bundle",+ "bytes": 882,+ "input_schema_bytes": 142,+ "output_schema_bytes": 321+ },+ {+ "name": "inline_comment",+ "bytes": 1064,+ "input_schema_bytes": 401,+ "output_schema_bytes": 313+ },+ {+ "name": "inspect_electron_page",+ "bytes": 10081,+ "input_schema_bytes": 1936,+ "output_schema_bytes": 7685+ },+ {+ "name": "inspect_macho",+ "bytes": 9368,+ "input_schema_bytes": 62,+ "output_schema_bytes": 8933+ },+ {+ "name": "inspect_managed_artifact",+ "bytes": 12894,+ "input_schema_bytes": 1251,+ "output_schema_bytes": 11159+ },+ {+ "name": "inspect_plist",+ "bytes": 2883,+ "input_schema_bytes": 189,+ "output_schema_bytes": 2320+ },+ {+ "name": "inspect_signature",+ "bytes": 2946,+ "input_schema_bytes": 62,+ "output_schema_bytes": 2519+ },+ {+ "name": "inspect_web_page",+ "bytes": 23933,+ "input_schema_bytes": 5042,+ "output_schema_bytes": 18381+ },+ {+ "name": "inventory_artifact",+ "bytes": 10608,+ "input_schema_bytes": 1885,+ "output_schema_bytes": 8336+ },+ {+ "name": "list_architectures",+ "bytes": 2782,+ "input_schema_bytes": 62,+ "output_schema_bytes": 2387+ },+ {+ "name": "list_bookmarks",+ "bytes": 1091,+ "input_schema_bytes": 282,+ "output_schema_bytes": 437+ },+ {+ "name": "list_browser_targets",+ "bytes": 3072,+ "input_schema_bytes": 658,+ "output_schema_bytes": 1966+ },+ {+ "name": "list_documents",+ "bytes": 883,+ "input_schema_bytes": 219,+ "output_schema_bytes": 310+ },+ {+ "name": "list_electron_targets",+ "bytes": 2991,+ "input_schema_bytes": 636,+ "output_schema_bytes": 1932+ },+ {+ "name": "list_names",+ "bytes": 2842,+ "input_schema_bytes": 594,+ "output_schema_bytes": 1818+ },+ {+ "name": "list_procedures",+ "bytes": 2739,+ "input_schema_bytes": 475,+ "output_schema_bytes": 1818+ },+ {+ "name": "list_segments",+ "bytes": 2817,+ "input_schema_bytes": 282,+ "output_schema_bytes": 2128+ },+ {+ "name": "list_strings",+ "bytes": 2837,+ "input_schema_bytes": 594,+ "output_schema_bytes": 1818+ },+ {+ "name": "list_unknowns",+ "bytes": 4477,+ "input_schema_bytes": 358,+ "output_schema_bytes": 3710+ },+ {+ "name": "next_address",+ "bytes": 1039,+ "input_schema_bytes": 401,+ "output_schema_bytes": 285+ },+ {+ "name": "observe_web_session",+ "bytes": 6320,+ "input_schema_bytes": 765,+ "output_schema_bytes": 5090+ },+ {+ "name": "open_binary",+ "bytes": 1702,+ "input_schema_bytes": 386,+ "output_schema_bytes": 696+ },+ {+ "name": "prev_address",+ "bytes": 1045,+ "input_schema_bytes": 401,+ "output_schema_bytes": 285+ },+ {+ "name": "procedure_address",+ "bytes": 1082,+ "input_schema_bytes": 383,+ "output_schema_bytes": 285+ },+ {+ "name": "procedure_assembly",+ "bytes": 1096,+ "input_schema_bytes": 383,+ "output_schema_bytes": 285+ },+ {+ "name": "procedure_callees",+ "bytes": 1121,+ "input_schema_bytes": 383,+ "output_schema_bytes": 310+ },+ {+ "name": "procedure_callers",+ "bytes": 1085,+ "input_schema_bytes": 383,+ "output_schema_bytes": 310+ },+ {+ "name": "procedure_info",+ "bytes": 1982,+ "input_schema_bytes": 383,+ "output_schema_bytes": 1216+ },+ {+ "name": "procedure_pseudo_code",+ "bytes": 1172,+ "input_schema_bytes": 383,+ "output_schema_bytes": 313+ },+ {+ "name": "procedure_references",+ "bytes": 4319,+ "input_schema_bytes": 798,+ "output_schema_bytes": 3054+ },+ {+ "name": "reconcile_javascript_runtime",+ "bytes": 30201,+ "input_schema_bytes": 9566,+ "output_schema_bytes": 20110+ },+ {+ "name": "record_unknown",+ "bytes": 6725,+ "input_schema_bytes": 2646,+ "output_schema_bytes": 3685+ },+ {+ "name": "resolve_containing_procedure",+ "bytes": 2185,+ "input_schema_bytes": 424,+ "output_schema_bytes": 1280+ },+ {+ "name": "run_controlled_replay",+ "bytes": 21072,+ "input_schema_bytes": 6098,+ "output_schema_bytes": 14387+ },+ {+ "name": "search_procedures",+ "bytes": 2238,+ "input_schema_bytes": 812,+ "output_schema_bytes": 964+ },+ {+ "name": "search_strings",+ "bytes": 2247,+ "input_schema_bytes": 812,+ "output_schema_bytes": 964+ },+ {+ "name": "set_address_name",+ "bytes": 1141,+ "input_schema_bytes": 478,+ "output_schema_bytes": 286+ },+ {+ "name": "set_addresses_names",+ "bytes": 1175,+ "input_schema_bytes": 427,+ "output_schema_bytes": 361+ },+ {+ "name": "set_bookmark",+ "bytes": 1118,+ "input_schema_bytes": 471,+ "output_schema_bytes": 286+ },+ {+ "name": "set_comment",+ "bytes": 1148,+ "input_schema_bytes": 487,+ "output_schema_bytes": 286+ },+ {+ "name": "set_current_document",+ "bytes": 1003,+ "input_schema_bytes": 298,+ "output_schema_bytes": 285+ },+ {+ "name": "set_inline_comment",+ "bytes": 1142,+ "input_schema_bytes": 487,+ "output_schema_bytes": 286+ },+ {+ "name": "swift_classes",+ "bytes": 1135,+ "input_schema_bytes": 127,+ "output_schema_bytes": 606+ },+ {+ "name": "trace_application_feature",+ "bytes": 27741,+ "input_schema_bytes": 9241,+ "output_schema_bytes": 17969+ },+ {+ "name": "trace_feature",+ "bytes": 3340,+ "input_schema_bytes": 555,+ "output_schema_bytes": 2299+ },+ {+ "name": "unset_bookmark",+ "bytes": 1055,+ "input_schema_bytes": 424,+ "output_schema_bytes": 286+ },+ {+ "name": "update_unknown",+ "bytes": 7884,+ "input_schema_bytes": 3810,+ "output_schema_bytes": 3685+ },+ {+ "name": "verify_reconstruction",+ "bytes": 6692,+ "input_schema_bytes": 2688,+ "output_schema_bytes": 3510+ },+ {+ "name": "verify_unknown_resolution",+ "bytes": 4481,+ "input_schema_bytes": 177,+ "output_schema_bytes": 3866+ },+ {+ "name": "xrefs",+ "bytes": 1112,+ "input_schema_bytes": 401,+ "output_schema_bytes": 310+ }+ ]+}diff --git a/tests/applicationWorkflowCli.test.ts b/tests/applicationWorkflowCli.test.tsindex 2c51385f8..44220f044 100644--- a/tests/applicationWorkflowCli.test.ts+++ b/tests/applicationWorkflowCli.test.ts@@ -55,13 +55,53 @@ describe("application workflow CLI parity", () => {},});}, 20_000);++ it("returns safe actionable JSON validation details", async () => {+ const malformed = await runCli([+ "trace-application-feature",+ "{not-json",+ "--json",+ ]);+ expect(malformed).toMatchObject({+ code: "invalid_request",+ retryable: true,+ details: {+ issues: [{ path: [], reason: "invalid_format", expected: "JSON" }],+ },+ });+ expect(JSON.stringify(malformed)).not.toContain("not-json");++ const missing = await runCli(["trace-application-feature", "{}", "--json"]);+ expect(missing).toMatchObject({+ code: "invalid_request",+ details: {+ issues: expect.arrayContaining([+ expect.objectContaining({+ path: ["application"],+ reason: "missing_argument",+ }),+ ]),+ },+ });+ });});const runCli = async (arguments_: readonly string[]): Promise<unknown> => {- const { stdout } = await execute(- process.execPath,- ["scripts/rea.mjs", ...arguments_],- { cwd: process.cwd(), env: process.env, maxBuffer: 16 * 1_024 * 1_024 },- );- return JSON.parse(stdout);+ try {+ const { stdout } = await execute(+ process.execPath,+ ["scripts/rea.mjs", ...arguments_],+ { cwd: process.cwd(), env: process.env, maxBuffer: 16 * 1_024 * 1_024 },+ );+ return JSON.parse(stdout);+ } catch (cause: unknown) {+ if (+ typeof cause === "object" &&+ cause !== null &&+ "stdout" in cause &&+ typeof cause.stdout === "string"+ )+ return JSON.parse(cause.stdout);+ throw cause;+ }};diff --git a/tests/applicationWorkflowMcp.test.ts b/tests/applicationWorkflowMcp.test.tsindex 7fcbecfde..913ec293e 100644--- a/tests/applicationWorkflowMcp.test.ts+++ b/tests/applicationWorkflowMcp.test.ts@@ -37,9 +37,7 @@ describe("application workflow MCP parity", () => {});expect(traced.isError).not.toBe(true);expect(traced.structuredContent).toMatchObject({- operation: "trace_application_feature",- provider: { id: "rea-javascript-application-workflows" },- normalized_result: {+ result: {schema_version: 1,coverage: { status: expect.any(String) },},@@ -54,8 +52,7 @@ describe("application workflow MCP parity", () => {});expect(compared.isError).not.toBe(true);expect(compared.structuredContent).toMatchObject({- operation: "compare_application_versions",- normalized_result: {+ result: {schema_version: 1,summary: { unknown: expect.any(Number) },coverage: { status: expect.any(String) },diff --git a/tests/artifactMcp.test.ts b/tests/artifactMcp.test.tsindex 5259c95b2..bf48295bd 100644--- a/tests/artifactMcp.test.ts+++ b/tests/artifactMcp.test.ts@@ -12,7 +12,6 @@ import { BinarySession } from "../src/application/BinarySession.js";import { ArtifactProvider } from "../src/artifacts/ArtifactProvider.js";import { ARTIFACT_COMPARISON_EXAMPLE } from "../src/contracts/artifactComparisonExample.js";import { evidenceBundleSchema } from "../src/domain/evidenceBundle.js";-import { parseEvidence } from "../src/domain/evidence.js";import { createServer } from "../src/server/createServer.js";import { observed } from "./fixtures/analysisExecution.js";@@ -148,7 +147,9 @@ describe("artifact graph MCP integration", () => {},});expect(result.isError).not.toBe(true);- const evidence = parseEvidence(result.structuredContent);+ const compact = compactResult(result.structuredContent);+ const evidence = session.evidenceById(compact.evidence_id);+ if (evidence === undefined) throw new Error("missing inventory Evidence");const inventory = z.object({occurrences: z.object({@@ -165,7 +166,7 @@ describe("artifact graph MCP integration", () => {}),),})- .parse(evidence.normalized_result);+ .parse(compact.result);expect(inventory.integrity_contradictions).toEqual(expect.arrayContaining([expect.objectContaining({@@ -197,16 +198,12 @@ describe("artifact graph MCP integration", () => {const compared = await client.callTool({name: "compare_artifacts",arguments: {- left: evidence,- right: evidence,+ left_evidence_ids: [evidence.evidence_id],+ right_evidence_ids: [evidence.evidence_id],},});expect(compared.isError).not.toBe(true);- const comparison = parseEvidence(- z.object({ result: z.unknown() }).parse(compared.structuredContent)- .result,- );- expect(comparison.normalized_result).toMatchObject({+ expect(compactResult(compared.structuredContent).result).toMatchObject({status: "contradiction",summary: { contradiction: 2 },changes: {@@ -333,13 +330,15 @@ describe("artifact graph MCP integration", () => {arguments: {},});expect(inventory.isError).not.toBe(true);- const evidence = parseEvidence(inventory.structuredContent);+ const inventoryResult = compactResult(inventory.structuredContent);+ const evidence = session.evidenceById(inventoryResult.evidence_id);+ if (evidence === undefined) throw new Error("missing inventory Evidence");expect(evidence).toMatchObject({provider: { id: "rea-artifact-graph" },subject: { format: "ipa" },- normalized_result: {- manifest: { root_format: "ipa" },- },+ });+ expect(inventoryResult.result).toMatchObject({+ manifest: { root_format: "ipa" },});const openedChanged = await client.callTool({name: "open_binary",@@ -350,24 +349,22 @@ describe("artifact graph MCP integration", () => {name: "inventory_artifact",arguments: {},});- const changedEvidence = parseEvidence(changedInventory.structuredContent);+ const changedResult = compactResult(changedInventory.structuredContent);+ const changedEvidence = session.evidenceById(changedResult.evidence_id);+ if (changedEvidence === undefined)+ throw new Error("missing changed Evidence");const compared = await client.callTool({name: "compare_artifacts",arguments: {- left: evidence,- right: changedEvidence,+ left_evidence_ids: [evidence.evidence_id],+ right_evidence_ids: [changedEvidence.evidence_id],unknown_registry_approved: true,},});expect(compared.isError).not.toBe(true);- const comparisonEvidence = parseEvidence(- z.object({ result: z.unknown() }).parse(compared.structuredContent)- .result,- );- expect(comparisonEvidence).toMatchObject({- provider: { id: "rea-artifact-comparison" },- evidence_links: [evidence.evidence_id, changedEvidence.evidence_id],- normalized_result: { status: "changed" },+ expect(compactResult(compared.structuredContent)).toMatchObject({+ result: { status: "changed" },+ evidence_id: expect.stringMatching(/^ev_/u),});const unknowns = await client.callTool({name: "list_unknowns",@@ -398,3 +395,12 @@ describe("artifact graph MCP integration", () => {}});});++const compactResult = (value: unknown) =>+ z+ .object({+ result: z.unknown(),+ evidence_id: z.string(),+ evidence_uri: z.string(),+ })+ .parse(value);diff --git a/tests/browserMcp.test.ts b/tests/browserMcp.test.tsindex 769c71c92..41af7a0fc 100644--- a/tests/browserMcp.test.ts+++ b/tests/browserMcp.test.ts@@ -77,12 +77,7 @@ describe("browser MCP tools", () => {});expect(listed.isError).not.toBe(true);expect(listed.structuredContent).toMatchObject({- operation: "list_browser_targets",- authority: "external-service",- confidence: "observed",- subject: null,- provider: { id: "rea-cdp-browser", version: "2" },- normalized_result: {+ result: {targets: { items: [{ target_id: "allowed-page" }] },},});@@ -105,8 +100,7 @@ describe("browser MCP tools", () => {});expect(inspected.isError).not.toBe(true);expect(inspected.structuredContent).toMatchObject({- operation: "inspect_web_page",- normalized_result: {+ result: {target: { target_id: "allowed-page" },console: { prior_activity_available: false },network: {@@ -124,14 +118,14 @@ describe("browser MCP tools", () => {arguments: {static_layers:JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers,- runtime_observations: [inspected.structuredContent],+ runtime_observations: [+ evidenceFor(connected.session, inspected.structuredContent),+ ],},});expect(reconciled.isError).not.toBe(true);expect(reconciled.structuredContent).toMatchObject({- operation: "reconcile_javascript_runtime",- provider: { id: "rea-javascript-runtime-reconciliation" },- normalized_result: { summary: { runtime_scripts: 1 } },+ result: { summary: { runtime_scripts: 1 } },});expect(JSON.stringify(reconciled.structuredContent)).not.toContain("source-secret",@@ -149,8 +143,7 @@ describe("browser MCP tools", () => {});expect(analyzed.isError).not.toBe(true);expect(analyzed.structuredContent).toMatchObject({- operation: "analyze_web_bundle",- normalized_result: {+ result: {capture: { scripts_analyzed: 1 },observations: { source_maps: { status: "not_requested" } },},@@ -167,8 +160,7 @@ describe("browser MCP tools", () => {});expect(observedSession.isError).not.toBe(true);expect(observedSession.structuredContent).toMatchObject({- operation: "observe_web_session",- normalized_result: {+ result: {window: { end_reason: "window_elapsed" },timeline: expect.arrayContaining([expect.objectContaining({ type: "same_origin_reload" }),@@ -187,8 +179,7 @@ describe("browser MCP tools", () => {});expect(webMcp.isError).not.toBe(true);expect(webMcp.structuredContent).toMatchObject({- operation: "discover_webmcp_tools",- normalized_result: {+ result: {tools: {items: [expect.objectContaining({ name: "search_orders" })],},@@ -204,8 +195,7 @@ describe("browser MCP tools", () => {});expect(compared.isError).not.toBe(true);expect(compared.structuredContent).toMatchObject({- operation: "compare_web_captures",- normalized_result: { overall_status: "unknown" },+ result: { overall_status: "unknown" },});const screenshot = await connected.client.callTool({name: "capture_web_screenshot",@@ -228,8 +218,7 @@ describe("browser MCP tools", () => {});expect(visual.isError).not.toBe(true);expect(visual.structuredContent).toMatchObject({- operation: "compare_web_screenshots",- normalized_result: { status: "identical", changed_pixels: 0 },+ result: { status: "identical", changed_pixels: 0 },});const evidenceId = evidenceIdOf(inspected.structuredContent);const evidence = await connected.client.readResource({@@ -297,7 +286,7 @@ const connectBrowser = async (browser: FakeCdpBrowser) => {resources.push(client, server, session);await server.connect(serverTransport);await client.connect(clientTransport);- return { client };+ return { client, session };};const evidenceIdOf = (value: unknown): string => {@@ -312,13 +301,15 @@ const evidenceIdOf = (value: unknown): string => {};const normalizedResultOf = (value: unknown): unknown => {- if (- typeof value !== "object" ||- value === null ||- !("normalized_result" in value)- )+ if (typeof value !== "object" || value === null || !("result" in value))throw new TypeError("Missing normalized browser result");- return value.normalized_result;+ return value.result;+};++const evidenceFor = (session: BinarySession, value: unknown) => {+ const evidence = session.evidenceById(evidenceIdOf(value));+ if (evidence === undefined) throw new TypeError("Missing session Evidence");+ return evidence;};const artifactOf = (value: unknown): unknown => {diff --git a/tests/bundleComparisonMcp.test.ts b/tests/bundleComparisonMcp.test.tsindex 767d5210b..8506a7f24 100644--- a/tests/bundleComparisonMcp.test.ts+++ b/tests/bundleComparisonMcp.test.ts@@ -1,14 +1,26 @@+import { mkdtemp, rm, writeFile } from "node:fs/promises";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";-import { describe, expect, it } from "vitest";-import { z } from "zod";+import { afterEach, describe, expect, it } from "vitest";import { BinarySession } from "../src/application/BinarySession.js";-import { createEvidence, parseEvidence } from "../src/domain/evidence.js";-import { createEvidenceBundle } from "../src/domain/evidenceBundle.js";-import { createResidualUnknown } from "../src/domain/residualUnknown.js";+import { createEvidence } from "../src/domain/evidence.js";+import {+ createEvidenceBundle,+ serializeEvidenceBundle,+} from "../src/domain/evidenceBundle.js";import { createServer } from "../src/server/createServer.js";import { observed } from "./fixtures/analysisExecution.js";+const roots: string[] = [];+afterEach(async () => {+ await Promise.all(+ roots.splice(0).map((root) => rm(root, { recursive: true, force: true })),+ );+});+const sourceEvidence = (label: string) =>createEvidence(undefined,@@ -23,151 +35,134 @@ const sourceEvidence = (label: string) =>);describe("bundle comparison MCP integration", () => {- it("rejects altered records that reuse session Evidence IDs", async () => {- const session = new BinarySession(() => ({- health: () => Promise.resolve(),- execute: () => Promise.resolve(observed(null)),- close: () => Promise.resolve(),- }));- const leftRecord = sourceEvidence("left-authority");- const rightRecord = sourceEvidence("right-authority");- session.recordEvidence(leftRecord);- session.recordEvidence(rightRecord);- const altered = {- ...leftRecord,- limitations: ["caller altered this record"],- };- const server = createServer(session, session);- const client = new Client({ name: "bundle-authority-test", version: "1" });- const [clientTransport, serverTransport] =- InMemoryTransport.createLinkedPair();+ it("reads two approved bounded bundle files and records a compact result", async () => {+ const root = await mkdtemp(join(tmpdir(), "rea-bundle-mcp-"));+ roots.push(root);+ const leftPath = join(root, "left.json");+ const rightPath = join(root, "right.json");+ const leftRecord = sourceEvidence("left");+ const rightRecord = sourceEvidence("right");+ await Promise.all([+ writeFile(+ leftPath,+ serializeEvidenceBundle(createEvidenceBundle([leftRecord])),+ ),+ writeFile(+ rightPath,+ serializeEvidenceBundle(createEvidenceBundle([rightRecord])),+ ),+ ]);+ const connected = await connect(root);try {- await server.connect(serverTransport);- await client.connect(clientTransport);- const result = await client.callTool({+ const result = await connected.client.callTool({name: "compare_bundles",arguments: {- left: createEvidenceBundle([altered]),- right: createEvidenceBundle([rightRecord]),+ left_bundle_path: leftPath,+ right_bundle_path: rightPath,+ record_pairs: [+ {+ left_evidence_id: leftRecord.evidence_id,+ right_evidence_id: rightRecord.evidence_id,+ },+ ],},});- expect(result.isError).toBe(true);- expect(session.exportEvidenceBundle().records).toHaveLength(2);+ expect(result.isError).not.toBe(true);+ expect(result.structuredContent).toMatchObject({+ result: { status: "changed" },+ evidence_id: expect.stringMatching(/^ev_[a-f0-9]{64}$/u),+ evidence_uri: expect.stringMatching(/^rea:\/\/evidence\/ev_/u),+ });} finally {- await Promise.allSettled([- client.close(),- server.close(),- session.close(),- ]);+ await connected.close();}});- it("rejects unknown histories that are not owned by the session", async () => {- const session = new BinarySession(() => ({- health: () => Promise.resolve(),- execute: () => Promise.resolve(observed(null)),- close: () => Promise.resolve(),- }));- const leftRecord = sourceEvidence("left-unowned-unknown");- const rightRecord = sourceEvidence("right-unowned-unknown");- expect(session.recordEvidence(leftRecord).ok).toBe(true);- expect(session.recordEvidence(rightRecord).ok).toBe(true);- const unknown = createResidualUnknown(- {- approved: true,- question: "Unowned history?",- severity: "high",- domain: "bundle-comparison-test",- supporting_evidence_ids: [leftRecord.evidence_id],- contradicting_evidence_ids: [],- required_authority: "shipped-artifact",- required_confidence: "observed",- required_environment: null,- recommended_probes: [],- relationships: [],- },- leftRecord.evidence_id,- null,- );- const server = createServer(session, session);- const client = new Client({ name: "bundle-unknown-test", version: "1" });- const [clientTransport, serverTransport] =- InMemoryTransport.createLinkedPair();+ it("rejects a bundle path outside the approved root", async () => {+ const root = await mkdtemp(join(tmpdir(), "rea-bundle-root-"));+ const outside = await mkdtemp(join(tmpdir(), "rea-bundle-outside-"));+ roots.push(root, outside);+ const leftPath = join(root, "left.json");+ const rightPath = join(outside, "right.json");+ const encoded = serializeEvidenceBundle(createEvidenceBundle([]));+ await Promise.all([+ writeFile(leftPath, encoded),+ writeFile(rightPath, encoded),+ ]);+ const connected = await connect(root);try {- await server.connect(serverTransport);- await client.connect(clientTransport);- const result = await client.callTool({+ const result = await connected.client.callTool({name: "compare_bundles",arguments: {- left: createEvidenceBundle([leftRecord], [unknown]),- right: createEvidenceBundle([rightRecord]),+ left_bundle_path: leftPath,+ right_bundle_path: rightPath,},});- expect(result.isError).toBe(true);- expect(session.exportEvidenceBundle()).toMatchObject({- records: [leftRecord, rightRecord].sort((left, right) =>- left.evidence_id.localeCompare(right.evidence_id),- ),- unknowns: [],+ expect(result).toMatchObject({+ isError: true,+ structuredContent: { error: { code: "outside_approved_root" } },});} finally {- await Promise.allSettled([- client.close(),- server.close(),- session.close(),- ]);+ await connected.close();}});- it("records a digest-anchored comparison linked to every source record", async () => {- const session = new BinarySession(() => ({- health: () => Promise.resolve(),- execute: () => Promise.resolve(observed(null)),- close: () => Promise.resolve(),- }));- const leftRecord = sourceEvidence("left");- const rightRecord = sourceEvidence("right");- expect(session.recordEvidence(leftRecord).ok).toBe(true);- expect(session.recordEvidence(rightRecord).ok).toBe(true);- const server = createServer(session, session);- const client = new Client({ name: "bundle-comparison-test", version: "1" });- const [clientTransport, serverTransport] =- InMemoryTransport.createLinkedPair();+ it("rejects an oversized approved bundle", async () => {+ const root = await mkdtemp(join(tmpdir(), "rea-bundle-size-"));+ roots.push(root);+ const leftPath = join(root, "left.json");+ const rightPath = join(root, "right.json");+ await Promise.all([+ writeFile(leftPath, " ".repeat(2_000)),+ writeFile(rightPath, serializeEvidenceBundle(createEvidenceBundle([]))),+ ]);+ const connected = await connect(root, 1_024);try {- await server.connect(serverTransport);- await client.connect(clientTransport);- const result = await client.callTool({+ const result = await connected.client.callTool({name: "compare_bundles",arguments: {- left: createEvidenceBundle([leftRecord]),- right: createEvidenceBundle([rightRecord]),- record_pairs: [- {- left_evidence_id: leftRecord.evidence_id,- right_evidence_id: rightRecord.evidence_id,- },- ],+ left_bundle_path: leftPath,+ right_bundle_path: rightPath,},});- expect(result.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(result.structuredContent)- .result,- );- expect(evidence).toMatchObject({- provider: { id: "rea-bundle-comparison" },- evidence_links: [- leftRecord.evidence_id,- rightRecord.evidence_id,- ].sort(),- normalized_result: { status: "changed" },+ expect(result).toMatchObject({+ isError: true,+ structuredContent: { error: { code: "truncated" } },});} finally {+ await connected.close();+ }+ });+});++const connect = async (root: string, maxBytes = 1024 * 1024) => {+ const session = new BinarySession(() => ({+ health: () => Promise.resolve(),+ execute: () => Promise.resolve(observed(null)),+ close: () => Promise.resolve(),+ }));+ const server = createServer(session, session, {+ evidenceFilePolicy: {+ roots: [root],+ maxBytes,+ maxDepth: 68,+ maxStringLength: 1024 * 1024,+ maxNodes: 100_000,+ },+ });+ const client = new Client({ name: "bundle-comparison-test", version: "1" });+ const [clientTransport, serverTransport] =+ InMemoryTransport.createLinkedPair();+ await server.connect(serverTransport);+ await client.connect(clientTransport);+ return {+ client,+ close: async () => {await Promise.allSettled([client.close(),server.close(),session.close(),]);- }- });-});+ },+ };+};diff --git a/tests/contractSnapshot.test.ts b/tests/contractSnapshot.test.tsindex 1127d8526..ce2adc529 100644--- a/tests/contractSnapshot.test.ts+++ b/tests/contractSnapshot.test.ts@@ -20,6 +20,10 @@ import {officialOutputSchemas,sessionOutputSchemas,} from "../src/contracts/toolOutputSchemas.js";+import {+ annotationsFromEffects,+ TOOL_EFFECTS,+} from "../src/contracts/toolEffects.js";const convertContractJsonSchema = (schema: z.ZodType) =>z.toJSONSchema(schema, {@@ -72,6 +76,10 @@ describe("tool contract surface", () => {const outputSchema = contractJsonSchema(contract.outputSchema);expect(inputSchema.type).toBe("object");expect(outputSchema.type).toBe("object");+ expect(contract.title.length).toBeGreaterThan(2);+ expect(contract.annotations).toEqual(+ annotationsFromEffects(contract.effects),+ );expect(typeof contract.annotations.idempotentHint).toBe("boolean");expect(typeof contract.annotations.openWorldHint).toBe("boolean");expect(typeof contract.annotations.readOnlyHint).toBe("boolean");@@ -86,6 +94,21 @@ describe("tool contract surface", () => {}});+ it("audits every tool effect explicitly with no heuristic fallback", () => {+ const names = [+ ...OFFICIAL_TOOL_CONTRACTS,+ ...ENHANCED_TOOL_CONTRACTS,+ ...NATIVE_TOOL_CONTRACTS,+ ...ARTIFACT_TOOL_CONTRACTS,+ ...MANAGED_TOOL_CONTRACTS,+ ...BROWSER_TOOL_CONTRACTS,+ ...ELECTRON_TOOL_CONTRACTS,+ ...APPLICATION_TOOL_CONTRACTS,+ ...SESSION_TOOL_CONTRACTS,+ ].map(({ name }) => name);+ expect(Object.keys(TOOL_EFFECTS).sort()).toEqual(names.sort());+ });+it("keeps exactly eighteen additive session contracts", () => {expect(SESSION_TOOL_CONTRACTS.map(({ name, kind }) => ({ name, kind })),diff --git a/tests/electronMcp.test.ts b/tests/electronMcp.test.tsindex 9a2b52ff9..91864a7b8 100644--- a/tests/electronMcp.test.ts+++ b/tests/electronMcp.test.ts@@ -91,9 +91,7 @@ describe("Electron MCP tools", () => {});expect(listed.isError).not.toBe(true);expect(listed.structuredContent).toMatchObject({- operation: "list_electron_targets",- provider: { id: "rea-cdp-electron" },- normalized_result: {+ result: {targets: { items: [{ target_id: "electron-page" }] },},});@@ -118,30 +116,32 @@ describe("Electron MCP tools", () => {name: "reconcile_javascript_runtime",arguments: {static_layers: [- { role: "application", analysis: analyzed.structuredContent },+ {+ role: "application",+ analysis: evidenceFor(session, analyzed.structuredContent),+ },+ ],+ runtime_observations: [+ evidenceFor(session, inspected.structuredContent),],- runtime_observations: [inspected.structuredContent],},});expect(reconciled.isError).not.toBe(true);expect(reconciled.structuredContent).toMatchObject({- operation: "reconcile_javascript_runtime",- provider: { id: "rea-javascript-runtime-reconciliation" },- normalized_result: {+ result: {summary: { runtime_scripts: 1, matched: expect.any(Number) },source_map_authority: { used_for_primary_matching: false },},});expect(inspected.isError).not.toBe(true);expect(inspected.structuredContent).toMatchObject({- operation: "inspect_electron_page",- normalized_result: {- target: { file_path: join(root, "index.html") },+ result: {+ target: { file_path: expect.stringMatching(/\/index\.html$/u) },scripts: {items: [expect.objectContaining({frame_id: "frame-main",- file_path: join(root, "app.js"),+ file_path: expect.stringMatching(/\/app\.js$/u),}),],},@@ -149,7 +149,7 @@ describe("Electron MCP tools", () => {expect.objectContaining({target_id: "electron-worker",opener_target_id: "electron-page",- file_path: join(root, "worker.js"),+ file_path: expect.stringMatching(/\/worker\.js$/u),}),],},@@ -170,7 +170,7 @@ describe("Electron MCP tools", () => {expect(denied.structuredContent).toMatchObject({error: {code: "permission_required",- details: { missing: { roots: [outside] } },+ details: { missing: { roots: [expect.stringMatching(/outside-/u)] } },},});expect(browser.commands).toHaveLength(commandsBeforeDenial);@@ -214,11 +214,9 @@ describe("Electron MCP tools", () => {expect(analyzed.isError).not.toBe(true);expect(analyzed.structuredContent).toMatchObject({- operation: "analyze_javascript_application",- provider: { id: "rea-javascript-application" },- normalized_result: {+ result: {schema_version: 1,- input_path: root,+ input_path: expect.stringMatching(/rea-electron-static-mcp-/u),summary: {browser_windows: 3,context_bridge_apis: 2,@@ -228,4 +226,17 @@ describe("Electron MCP tools", () => {},});});++ const evidenceFor = (session: BinarySession, value: unknown) => {+ if (+ typeof value !== "object" ||+ value === null ||+ !("evidence_id" in value) ||+ typeof value.evidence_id !== "string"+ )+ throw new TypeError("Missing compact Evidence ID");+ const evidence = session.evidenceById(value.evidence_id);+ if (evidence === undefined) throw new TypeError("Missing session Evidence");+ return evidence;+ };});diff --git a/tests/enhancedTools.test.ts b/tests/enhancedTools.test.tsindex 70ab4c67c..06dc20cf7 100644--- a/tests/enhancedTools.test.ts+++ b/tests/enhancedTools.test.ts@@ -174,6 +174,14 @@ const jsonResult = (result: CallToolResult): JsonValue => {) {return structured.data.normalized_result ?? null;}+ if (+ typeof structured.data === "object" &&+ structured.data !== null &&+ !Array.isArray(structured.data) &&+ "evidence_id" in structured.data &&+ "result" in structured.data+ )+ return structured.data.result ?? null;const text = result.content.find((item) => item.type === "text");if (text?.type !== "text")throw new Error("Tool result omitted text content");@@ -567,7 +575,7 @@ describe("enhanced MCP tools", () => {expect(result.isError).toBe(true);const text = result.content.find((item) => item.type === "text");expect(text?.type === "text" ? text.text : "").toBe(- "Analysis returned an unreadable result. Retry once; if it continues, run `rea doctor`.",+ JSON.stringify(result.structuredContent),);});@@ -603,6 +611,47 @@ describe("enhanced MCP tools", () => {expect(JSON.stringify(result)).toContain("operation budget");});+ it("returns correction-only structured validation issues", async () => {+ const client = await connect();+ const misspelled = await client.callTool({+ name: "trace_feature",+ arguments: { query: "needle", max_operatons: 1 },+ });+ expect(misspelled).toMatchObject({+ isError: true,+ structuredContent: {+ error: {+ code: "invalid_request",+ retryable: true,+ details: {+ issues: [{ path: ["max_operatons"], reason: "unknown_argument" }],+ },+ },+ },+ });+ const bounded = await client.callTool({+ name: "trace_feature",+ arguments: { query: "needle", max_operations: 101 },+ });+ expect(bounded.structuredContent).toMatchObject({+ error: {+ details: {+ issues: [+ {+ path: ["max_operations"],+ reason: "out_of_range",+ maximum: 100,+ },+ ],+ },+ },+ });+ expect(bounded.content[0]).toEqual({+ type: "text",+ text: JSON.stringify(bounded.structuredContent),+ });+ });+it("returns a typed tool error for malformed Hopper boundary values", async () => {const client = await connect({execute: () => Promise.resolve(ok(["not", "a", "procedure", "map"])),@@ -614,7 +663,7 @@ describe("enhanced MCP tools", () => {expect(result.isError).toBe(true);const text = result.content.find((item) => item.type === "text");expect(text?.type === "text" ? text.text : "").toBe(- "Analysis returned an unreadable result. Retry once; if it continues, run `rea doctor`.",+ JSON.stringify(result.structuredContent),);});@@ -635,7 +684,7 @@ describe("enhanced MCP tools", () => {expect(result.isError).toBe(true);const text = result.content.find((item) => item.type === "text");expect(text?.type === "text" ? text.text : "").toBe(- "Analysis returned an unreadable result. Retry once; if it continues, run `rea doctor`.",+ JSON.stringify(result.structuredContent),);});@@ -671,7 +720,7 @@ describe("enhanced MCP tools", () => {expect(result.isError).toBe(true);const text = result.content.find((item) => item.type === "text");expect(text?.type === "text" ? text.text : "").toBe(- "Analysis returned an unreadable result. Retry once; if it continues, run `rea doctor`.",+ JSON.stringify(result.structuredContent),);});diff --git a/tests/functionComparisonMcp.test.ts b/tests/functionComparisonMcp.test.tsindex 4eec8b1f7..c84a67feb 100644--- a/tests/functionComparisonMcp.test.ts+++ b/tests/functionComparisonMcp.test.ts@@ -1,10 +1,9 @@import { Client, InMemoryTransport } from "@modelcontextprotocol/client";import { describe, expect, it } from "vitest";-import { z } from "zod";import { BinarySession } from "../src/application/BinarySession.js";import { FUNCTION_COMPARISON_EXAMPLE } from "../src/contracts/functionComparisonExample.js";-import { parseEvidence } from "../src/domain/evidence.js";+import { createEvidence } from "../src/domain/evidence.js";import { createServer } from "../src/server/createServer.js";import { observed } from "./fixtures/analysisExecution.js";@@ -34,22 +33,16 @@ describe("function comparison MCP integration", () => {const result = await client.callTool({name: "compare_functions",arguments: {- left: FUNCTION_COMPARISON_EXAMPLE.left,- right: FUNCTION_COMPARISON_EXAMPLE.right,+ left_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.left.evidence_id],+ right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],unknown_registry_approved: true,},});expect(result.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(result.structuredContent)- .result,- );- expect(evidence).toMatchObject({- provider: { id: "rea-function-comparison" },- evidence_links: [- FUNCTION_COMPARISON_EXAMPLE.left.evidence_id,- FUNCTION_COMPARISON_EXAMPLE.right.evidence_id,- ],+ expect(result.structuredContent).toMatchObject({+ result: { status: expect.any(String) },+ evidence_id: expect.stringMatching(/^ev_[a-f0-9]{64}$/u),+ evidence_uri: expect.stringMatching(/^rea:\/\/evidence\/ev_/u),});const unknowns = await client.callTool({name: "list_unknowns",@@ -93,8 +86,8 @@ describe("function comparison MCP integration", () => {const result = await client.callTool({name: "compare_functions",arguments: {- left: FUNCTION_COMPARISON_EXAMPLE.left,- right: FUNCTION_COMPARISON_EXAMPLE.right,+ left_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.left.evidence_id],+ right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],},});expect(result.isError).toBe(true);@@ -108,13 +101,22 @@ describe("function comparison MCP integration", () => {}});- it("rejects altered payloads that reuse session Evidence IDs", async () => {+ it("rejects Evidence IDs with the wrong operation", async () => {const session = new BinarySession(() => ({health: () => Promise.resolve(),execute: () => Promise.resolve(observed(null)),close: () => Promise.resolve(),}));- session.recordEvidence(FUNCTION_COMPARISON_EXAMPLE.left);+ const wrong = createEvidence(+ undefined,+ { id: "fixture", name: "Fixture", version: "1" },+ {+ operation: "inventory_artifact",+ parameters: {},+ result: {},+ },+ );+ session.recordEvidence(wrong);session.recordEvidence(FUNCTION_COMPARISON_EXAMPLE.right);const server = createServer(session, session);const client = new Client({@@ -129,11 +131,8 @@ describe("function comparison MCP integration", () => {const result = await client.callTool({name: "compare_functions",arguments: {- left: {- ...FUNCTION_COMPARISON_EXAMPLE.left,- limitations: ["caller altered this record"],- },- right: FUNCTION_COMPARISON_EXAMPLE.right,+ left_evidence_ids: [wrong.evidence_id],+ right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],},});expect(result.isError).toBe(true);diff --git a/tests/integration/serverIntegration.test.ts b/tests/integration/serverIntegration.test.tsindex 21fb6dcf6..3c17e4ef4 100644--- a/tests/integration/serverIntegration.test.ts+++ b/tests/integration/serverIntegration.test.ts@@ -61,6 +61,59 @@ const structured = (result: CallToolResult): Record<string, unknown> => {return Object.fromEntries(Object.entries(result.structuredContent));};+const objectEntries = (value: unknown): readonly [string, unknown][] =>+ typeof value === "object" && value !== null && !Array.isArray(value)+ ? Object.entries(value)+ : [];++const referencedSchema = (schema: unknown, root: unknown): unknown => {+ const object = Object.fromEntries(objectEntries(schema));+ const reference = object.$ref;+ if (typeof reference !== "string" || !reference.startsWith("#/$defs/"))+ return schema;+ return Object.fromEntries(objectEntries(root)).$defs instanceof Object+ ? Object.fromEntries(+ objectEntries(Object.fromEntries(objectEntries(root)).$defs),+ )[reference.slice(8)]+ : schema;+};++const assertDescribedStrictObjects = (+ schema: unknown,+ root = schema,+ path = "$",+): void => {+ for (const [key, value] of objectEntries(schema)) {+ if (key === "properties") {+ const properties = objectEntries(value);+ for (const [property, propertySchema] of properties) {+ const resolved = referencedSchema(propertySchema, root);+ const propertyObject = Object.fromEntries(+ objectEntries(propertySchema),+ );+ expect(+ propertyObject.description ??+ Object.fromEntries(objectEntries(resolved)).description,+ `${path}.properties.${property}`,+ ).toEqual(expect.any(String));+ assertDescribedStrictObjects(+ propertySchema,+ root,+ `${path}.properties.${property}`,+ );+ }+ expect(+ Object.fromEntries(objectEntries(schema)).additionalProperties,+ ).toBe(false);+ continue;+ }+ assertDescribedStrictObjects(value, root, `${path}.${key}`);+ }+ if (Array.isArray(schema))+ for (const [index, value] of schema.entries())+ assertDescribedStrictObjects(value, root, `${path}[${String(index)}]`);+};+describe("full MCP integration with multi-tool sequences", () => {it("executes a realistic workflow: list methods, decompile selected, get xrefs", async () => {const client = await connect({@@ -98,10 +151,7 @@ describe("full MCP integration with multi-tool sequences", () => {});expect(listResult.isError).not.toBe(true);expect(structured(listResult)).toMatchObject({- subject: null,- operation: "list_procedures",- provider: { id: "fixture", version: "1" },- normalized_result: {+ result: {items: [{ address: "0x1000", value: "main" },{ address: "0x2000", value: "helper" },@@ -116,9 +166,7 @@ describe("full MCP integration with multi-tool sequences", () => {arguments: { procedure: "0x1000" },});expect(structured(decompileResult)).toMatchObject({- operation: "procedure_pseudo_code",- parameters: { document: null, procedure: "0x1000" },- normalized_result: "pseudo for 0x1000",+ result: "pseudo for 0x1000",});const xrefResult = await client.callTool({@@ -126,8 +174,7 @@ describe("full MCP integration with multi-tool sequences", () => {arguments: {},});expect(structured(xrefResult)).toMatchObject({- operation: "xrefs",- normalized_result: ["0x1000"],+ result: ["0x1000"],});});@@ -161,6 +208,30 @@ describe("full MCP integration with multi-tool sequences", () => {expect(names).toContain("binary_session");expect(names).toContain("binary_overview");expect(names).toContain("batch_decompile");++ expect(+ Buffer.byteLength(JSON.stringify(listed), "utf8"),+ ).toBeLessThanOrEqual(512 * 1024);+ const contracts = new Map<string, (typeof TOOL_CONTRACTS)[number]>(+ TOOL_CONTRACTS.map((contract) => [contract.name, contract]),+ );+ for (const tool of listed.tools) {+ expect(+ Buffer.byteLength(JSON.stringify(tool), "utf8"),+ tool.name,+ ).toBeLessThanOrEqual(64 * 1024);+ const contract = contracts.get(tool.name);+ expect(contract, tool.name).toBeDefined();+ expect(tool.title, tool.name).toBe(contract?.title);+ expect(tool.description, tool.name).toBe(contract?.description);+ expect(tool.annotations, tool.name).toEqual(contract?.annotations);+ expect(tool.outputSchema, tool.name).toBeDefined();+ assertDescribedStrictObjects(+ tool.inputSchema,+ tool.inputSchema,+ tool.name,+ );+ }});it("records approved trace truncation as a deduplicated residual unknown", async () => {@@ -355,9 +426,7 @@ describe("full MCP integration with multi-tool sequences", () => {name: "compare_process_captures",arguments: {left_evidence_id: leftEvidence.evidence_id,- left,right_evidence_id: rightEvidence.evidence_id,- right,unknown_registry_approved: true,},});@@ -408,9 +477,7 @@ describe("full MCP integration with multi-tool sequences", () => {category: "execution_failure",},});- expect(text(result)).toBe(- "Analysis could not complete. Retry once; if it continues, run `rea doctor`.",- );+ expect(text(result)).toBe(JSON.stringify(result.structuredContent));});it("handles concurrent tool calls without corruption", async () => {diff --git a/tests/investigationMcp.test.ts b/tests/investigationMcp.test.tsindex 89cc31daf..7c8228bd9 100644--- a/tests/investigationMcp.test.ts+++ b/tests/investigationMcp.test.ts@@ -15,7 +15,7 @@ import {PROCESS_COMPARISON_EVIDENCE,} from "../src/contracts/investigationExamples.js";import { changedBehaviorResultSchema } from "../src/domain/changedBehavior.js";-import { createEvidence, parseEvidence } from "../src/domain/evidence.js";+import { createEvidence } from "../src/domain/evidence.js";import { jsonObjectSchema, jsonValueSchema } from "../src/domain/jsonValue.js";import { createServer } from "../src/server/createServer.js";import { observed } from "./fixtures/analysisExecution.js";@@ -96,9 +96,7 @@ describe("investigation MCP workflows", () => {arguments: arguments_,});expect(first.isError).not.toBe(true);- const firstEvidence = parseEvidence(- z.object({ result: z.unknown() }).parse(first.structuredContent).result,- );+ const firstEvidence = sessionEvidence(session, first.structuredContent);expect(firstEvidence.normalized_result).toMatchObject({behavior_status: "unknown",summary: { static_candidates: 2 },@@ -136,10 +134,7 @@ describe("investigation MCP workflows", () => {arguments: arguments_,});expect(second.isError, JSON.stringify(second)).not.toBe(true);- const secondEvidence = parseEvidence(- z.object({ result: z.unknown() }).parse(second.structuredContent)- .result,- );+ const secondEvidence = sessionEvidence(session, second.structuredContent);expect(secondEvidence.evidence_id).toBe(firstEvidence.evidence_id);expect(await readInvestigationWorkspace(workspace, filePolicy),@@ -245,9 +240,9 @@ describe("investigation MCP workflows", () => {arguments: { investigation_run: investigationRun },});expect(created.isError, JSON.stringify(created)).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(created.structuredContent)- .result,+ const evidence = sessionEvidence(+ initial.session,+ created.structuredContent,);const result = changedBehaviorResultSchema.parse(evidence.normalized_result,@@ -322,12 +317,10 @@ describe("investigation MCP workflows", () => {},});expect(response.isError).toBe(true);- expect(response.content).toEqual([- {- type: "text",- text: "Artifact path is not allowed. Choose a path inside the artifact and try again.",- },- ]);+ expect(response.content[0]).toEqual({+ type: "text",+ text: JSON.stringify(response.structuredContent),+ });} finally {await close(session, server, client);await rm(directory, { recursive: true, force: true });@@ -354,10 +347,7 @@ describe("investigation MCP workflows", () => {},});expect(response.isError, JSON.stringify(response)).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(response.structuredContent)- .result,- );+ const evidence = sessionEvidence(session, response.structuredContent);expect(evidence).toMatchObject({provider: { id: "rea-changed-behavior" },normalized_result: { behavior_status: "unknown" },@@ -386,10 +376,7 @@ describe("investigation MCP workflows", () => {arguments: INVESTIGATION_EXAMPLES.build_call_path,});expect(response.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(response.structuredContent)- .result,- );+ const evidence = sessionEvidence(session, response.structuredContent);expect(evidence).toMatchObject({provider: { id: "rea-call-path" },normalized_result: {@@ -481,10 +468,7 @@ describe("investigation MCP workflows", () => {arguments: INVESTIGATION_EXAMPLES.correlate_static_and_runtime,});expect(response.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(response.structuredContent)- .result,- );+ const evidence = sessionEvidence(session, response.structuredContent);expect(evidence).toMatchObject({provider: { id: "rea-static-runtime-correlation" },confidence: "inferred",@@ -560,10 +544,7 @@ describe("investigation MCP workflows", () => {},});expect(response.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(response.structuredContent)- .result,- );+ const evidence = sessionEvidence(session, response.structuredContent);expect(evidence).toMatchObject({provider: { id: "rea-reconstruction-verifier" },normalized_result: { status: "pass", summary: { passed: 1 } },@@ -613,10 +594,7 @@ describe("investigation MCP workflows", () => {},});expect(response.isError).not.toBe(true);- const evidence = parseEvidence(- z.object({ result: z.unknown() }).parse(response.structuredContent)- .result,- );+ const evidence = sessionEvidence(session, response.structuredContent);expect(evidence.normalized_result).toMatchObject({status: "unknown",summary: { unknown: 1 },@@ -669,6 +647,15 @@ const evidencePolicy = (root: string): EvidenceFilePolicy => ({maxNodes: 1_000_000,});+const sessionEvidence = (session: BinarySession, value: unknown) => {+ const parsed = z+ .object({ evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u) })+ .parse(value);+ const evidence = session.evidenceById(parsed.evidence_id);+ if (evidence === undefined) throw new TypeError("Missing session Evidence");+ return evidence;+};+const investigationAuthority = async (root: string,includeWrite: boolean,diff --git a/tests/managedMcp.test.ts b/tests/managedMcp.test.tsindex 3b20a9a89..ef83b8c08 100644--- a/tests/managedMcp.test.ts+++ b/tests/managedMcp.test.ts@@ -108,10 +108,7 @@ describe("managed artifact MCP tools", () => {);expect(inspected).toMatchObject({- operation: "inspect_managed_artifact",- provider: { id: "rea-dotnet-static" },- subject: { local_path: path, format: "pe" },- normalized_result: {+ result: {classification: {status: "managed",runtime_family: "modern-dotnet",diff --git a/tests/officialTools.test.ts b/tests/officialTools.test.tsindex 8f614655e..bcd8dcada 100644--- a/tests/officialTools.test.ts+++ b/tests/officialTools.test.ts@@ -201,11 +201,9 @@ describe("official Hopper proxy tools", () => {arguments: {},});expect(result.isError).toBe(true);- expect(result.content).toEqual([- {- type: "text",- text: "Analysis could not complete. Retry once; if it continues, run `rea doctor`.",- },- ]);+ expect(result.content[0]).toEqual({+ type: "text",+ text: JSON.stringify(result.structuredContent),+ });});});diff --git a/tests/providerSelectionMcp.test.ts b/tests/providerSelectionMcp.test.tsindex 74deb1948..36ccaf4b9 100644--- a/tests/providerSelectionMcp.test.ts+++ b/tests/providerSelectionMcp.test.ts@@ -111,9 +111,8 @@ describe("provider selection over MCP", () => {});expect(observed.isError).not.toBe(true);expect(structured(observed)).toMatchObject({- provider: { id: "beta", version: "1" },- analysis_profile: { provider: { id: "beta", version: "1" } },- normalized_result: "beta:address_name",+ result: "beta:address_name",+ evidence_id: expect.stringMatching(/^ev_/u),});expect(starts).toEqual(["beta"]);diff --git a/tests/sessionMcp.test.ts b/tests/sessionMcp.test.tsindex 564b1ffa6..701e2dffe 100644--- a/tests/sessionMcp.test.ts+++ b/tests/sessionMcp.test.ts@@ -1,4 +1,4 @@-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";+import { mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";import { tmpdir } from "node:os";import { dirname, join } from "node:path";import { fileURLToPath } from "node:url";@@ -73,12 +73,13 @@ describe("target-free MCP lifecycle", () => {}),).result;- expect(first).toMatchObject({ path: targetPath });- expect(second).toMatchObject({ path: targetPath });+ const canonicalTargetPath = await realpath(targetPath);+ expect(first).toMatchObject({ path: canonicalTargetPath });+ expect(second).toMatchObject({ path: canonicalTargetPath });expect(z.object({ sha256: z.string() }).parse(second).sha256).not.toBe(z.object({ sha256: z.string() }).parse(first).sha256,);- expect(closed).toEqual([targetPath]);+ expect(closed).toEqual([canonicalTargetPath]);expect(z.object({ result: z.object({ path: z.string(), sha256: z.string() }) })@@ -88,7 +89,7 @@ describe("target-free MCP lifecycle", () => {),).result,).toEqual({- path: targetPath,+ path: canonicalTargetPath,sha256: z.object({ sha256: z.string() }).parse(second).sha256,});});@@ -139,9 +140,7 @@ describe("target-free MCP lifecycle", () => {arguments: {},});expect(before.isError).toBe(true);- expect(text(before)).toBe(- "No app is open. Ask the user which app to investigate, then call open_binary with its local path.",- );+ expect(text(before)).toBe(JSON.stringify(before.structuredContent));expect((await mcp.listTools()).tools).toHaveLength(89);const deniedCapture = await mcp.callTool({name: "capture_process_scenario",@@ -158,7 +157,7 @@ describe("target-free MCP lifecycle", () => {},});expect(text(deniedCapture)).toBe(- "Process capture is disabled. Set `REA_PROCESS_CAPTURE_ENABLED=true`, configure approved roots, then restart REA.",+ JSON.stringify(deniedCapture.structuredContent),);expect((await mcp.callTool({ name: "open_binary", arguments: { path: first } }))@@ -304,7 +303,7 @@ describe("target-free MCP lifecycle", () => {});expect(text(await mcp.callTool({ name: "binary_session", arguments: {} })),- ).toContain('"open": false');+ ).toContain('"open":false');expect((await mcp.callTool({diff --git a/tests/toolResult.test.ts b/tests/toolResult.test.tsindex 5a8f13ed3..1921403e5 100644--- a/tests/toolResult.test.ts+++ b/tests/toolResult.test.ts@@ -6,17 +6,26 @@ import { ok } from "../src/domain/result.js";import { err } from "../src/domain/result.js";import { HopperProcessError } from "../src/domain/errors.js";import { toCallToolResult } from "../src/server/toolResult.js";-import {- createEvidence,- evidenceEnvelopeSchema,-} from "../src/domain/evidence.js";+import { createEvidence } from "../src/domain/evidence.js";+import { evidenceResultOf } from "../src/contracts/toolOutputSchemas.js";const contract: ToolContract = {name: "provider_neutral_fixture",+ title: "Provider Neutral Fixture",description: "Fixture contract for provider-neutral output validation.",kind: "enhanced",inputSchema: z.object({}),outputSchema: z.object({ value: z.string() }),+ effects: {+ mutatesTarget: false,+ mutatesSession: false,+ writesFilesystem: false,+ launchesProcess: false,+ accessesNetwork: false,+ changesUiState: false,+ mayDiscardData: false,+ idempotent: true,+ },annotations: {readOnlyHint: true,destructiveHint: false,@@ -39,13 +48,8 @@ describe("tool result projection", () => {expect(JSON.stringify(result)).not.toContain("expected Hopper");});it("classifies output contract failures without naming a provider", () => {- expect(toCallToolResult(ok({ value: 42 }), contract)).toEqual({- content: [- {- type: "text",- text: "Analysis returned an unreadable result. Retry once; if it continues, run `rea doctor`.",- },- ],+ const result = toCallToolResult(ok({ value: 42 }), contract);+ expect(result).toMatchObject({structuredContent: {error: {code: "unreadable_output",@@ -62,6 +66,10 @@ describe("tool result projection", () => {},isError: true,});+ expect(result.content[0]).toEqual({+ type: "text",+ text: JSON.stringify(result.structuredContent),+ });});it("links successful evidence only when its session resource exists", () => {@@ -77,7 +85,7 @@ describe("tool result projection", () => {);const evidenceContract: ToolContract = {...contract,- outputSchema: evidenceEnvelopeSchema,+ outputSchema: evidenceResultOf(z.object({ value: z.string() })),};expect(