Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(server): retain session admission through investigation publication
morluto663d07f02cd6
diff --git a/src/server/registerInvestigationTools.ts b/src/server/registerInvestigationTools.tsindex 02e1c52d0..cf02243a6 100644--- a/src/server/registerInvestigationTools.ts+++ b/src/server/registerInvestigationTools.ts@@ -25,6 +25,8 @@ import {applicationValidatedInputSchema,toolRegistrationOptions,} from "./toolRegistrationOptions.js";+import { withAdmittedAnalysis } from "./analysisAdmission.js";+import { runAdmittedToolOperation } from "./admittedToolOperation.js";import { verifyReconstruction } from "../domain/reconstructionVerification.js";/** Register Evidence-composed differential investigation workflows. */@@ -32,20 +34,24 @@ export const registerInvestigationTools = (server: EvidenceMcpServer,session: BinarySessionPort,): void => {+ const admission = withAdmittedAnalysis({ kind: "session", session });registerChangedBehavior(server,session,+ admission,toolContract("find_changed_behavior"),);- registerCallPath(server, session, toolContract("build_call_path"));+ registerCallPath(server, session, admission, toolContract("build_call_path"));registerStaticRuntime(server,session,+ admission,toolContract("correlate_static_and_runtime"),);registerReconstruction(server,session,+ admission,toolContract("verify_reconstruction"),);};@@ -53,6 +59,7 @@ export const registerInvestigationTools = (const registerChangedBehavior = (server: EvidenceMcpServer,session: BinarySessionPort,+ admission: ReturnType<typeof withAdmittedAnalysis>,contract: ReturnType<typeof toolContract<"find_changed_behavior">>,): void => {const registration = toolRegistrationOptions(contract);@@ -62,223 +69,281 @@ const registerChangedBehavior = (...registration,inputSchema: applicationValidatedInputSchema(registration.inputSchema),},- async (input, context) => {- const computed = await runDerivedOperation(context, contract.name, () =>- findChangedBehavior(input),- );- if (!computed.ok)- return server.delivery.toCallToolResult(computed, contract);- const { result, comparisonEvidenceIds } = computed.value;- const closure = evidenceClosure(session, result.evidence_links);- if (!closure.ok)- return server.delivery.toCallToolResult(closure, contract);- const links = closure.value;- const evidence = createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {- predicateType: "rea.changed-behavior",- operation: contract.name,- parameters: {- comparison_evidence_ids: [...comparisonEvidenceIds],- },- result: jsonValueSchema.parse(result),- confidence: "derived",- authority: "analyst-inference",- limitations: result.limitations,- evidenceLinks: links,- });- const recorded = recordWorkflowEvidence(- session,- evidence,- isIncomplete(result.behavior_status),- {- question:- "Did both versions behave the same under a complete controlled replay?",- domain: "changed-behavior",- requiredAuthority: "controlled-replay",- requiredConfidence: "observed",- probes: [+ async (input, context) =>+ runAdmittedToolOperation(+ server,+ admission,+ contract.name,+ context.mcpReq.signal,+ async () => {+ const computed = await runDerivedOperation(+ context,+ contract.name,+ () => findChangedBehavior(input),+ );+ if (!computed.ok)+ return server.delivery.toCallToolResult(computed, contract);+ const { result, comparisonEvidenceIds } = computed.value;+ const closure = evidenceClosure(session, result.evidence_links);+ if (!closure.ok)+ return server.delivery.toCallToolResult(closure, contract);+ const links = closure.value;+ const evidence = createEvidence(+ undefined,+ CHANGED_BEHAVIOR_PROVIDER,+ {+ predicateType: "rea.changed-behavior",+ operation: contract.name,+ parameters: {+ comparison_evidence_ids: [...comparisonEvidenceIds],+ },+ result: jsonValueSchema.parse(result),+ confidence: "derived",+ authority: "analyst-inference",+ limitations: result.limitations,+ evidenceLinks: links,+ },+ );+ const recorded = recordWorkflowEvidence(+ session,+ evidence,+ isIncomplete(result.behavior_status),{- operation: "capture_process_scenario",- rationale:- "Capture both versions under the same bounded scenario and environment.",+ question:+ "Did both versions behave the same under a complete controlled replay?",+ domain: "changed-behavior",+ requiredAuthority: "controlled-replay",+ requiredConfidence: "observed",+ probes: [+ {+ operation: "capture_process_scenario",+ rationale:+ "Capture both versions under the same bounded scenario and environment.",+ },+ ],},- ],+ );+ return server.delivery.toEvidenceToolResult(+ evidence,+ contract,+ recorded,+ );},- );- return server.delivery.toEvidenceToolResult(evidence, contract, recorded);- },+ ),);};const registerCallPath = (server: EvidenceMcpServer,session: BinarySessionPort,+ admission: ReturnType<typeof withAdmittedAnalysis>,contract: ReturnType<typeof toolContract<"build_call_path">>,): void => {server.registerTool(contract.name,toolRegistrationOptions(contract),- async (input, context) => {- const closure = evidenceClosure(- session,- functionEvidenceIds(input.functions),- );- if (!closure.ok)- return server.delivery.toCallToolResult(closure, contract);- const links = closure.value;- const computed = await runDerivedOperation(context, contract.name, () =>- buildCallPath(input),- );- if (!computed.ok)- return server.delivery.toCallToolResult(computed, contract);- const result = computed.value;- const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {- predicateType: "rea.call-path",- operation: contract.name,- parameters: {- start: input.start.address,- goal: input.goal.address,- },- result: jsonValueSchema.parse(result),- confidence: "derived",- authority: "analyst-inference",- limitations: result.limitations,- evidenceLinks: links,- });- const recorded = recordWorkflowEvidence(- session,- evidence,- result.status === "unknown",- {- question:- "Can the requested call path be established from complete analysis?",- domain: "call-path",- requiredAuthority: "shipped-artifact",- requiredConfidence: "derived",- probes: [+ async (input, context) =>+ runAdmittedToolOperation(+ server,+ admission,+ contract.name,+ context.mcpReq.signal,+ async () => {+ const closure = evidenceClosure(+ session,+ functionEvidenceIds(input.functions),+ );+ if (!closure.ok)+ return server.delivery.toCallToolResult(closure, contract);+ const links = closure.value;+ const computed = await runDerivedOperation(+ context,+ contract.name,+ () => buildCallPath(input),+ );+ if (!computed.ok)+ return server.delivery.toCallToolResult(computed, contract);+ const result = computed.value;+ const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {+ predicateType: "rea.call-path",+ operation: contract.name,+ parameters: {+ start: input.start.address,+ goal: input.goal.address,+ },+ result: jsonValueSchema.parse(result),+ confidence: "derived",+ authority: "analyst-inference",+ limitations: result.limitations,+ evidenceLinks: links,+ });+ const recorded = recordWorkflowEvidence(+ session,+ evidence,+ result.status === "unknown",{- operation: "analyze_function",- rationale:- "Collect complete callee dossiers for the reported frontier addresses.",+ question:+ "Can the requested call path be established from complete analysis?",+ domain: "call-path",+ requiredAuthority: "shipped-artifact",+ requiredConfidence: "derived",+ probes: [+ {+ operation: "analyze_function",+ rationale:+ "Collect complete callee dossiers for the reported frontier addresses.",+ },+ ],},- ],+ );+ return server.delivery.toEvidenceToolResult(+ evidence,+ contract,+ recorded,+ );},- );- return server.delivery.toEvidenceToolResult(evidence, contract, recorded);- },+ ),);};const registerStaticRuntime = (server: EvidenceMcpServer,session: BinarySessionPort,+ admission: ReturnType<typeof withAdmittedAnalysis>,contract: ReturnType<typeof toolContract<"correlate_static_and_runtime">>,): void => {server.registerTool(contract.name,toolRegistrationOptions(contract),- async (input, context) => {- const closure = evidenceClosure(- session,- comparisonClosure([- ...input.static_comparisons,- ...input.runtime_comparisons,- ]),- );- if (!closure.ok)- return server.delivery.toCallToolResult(closure, contract);- const links = closure.value;- const computed = await runDerivedOperation(context, contract.name, () =>- correlateStaticAndRuntime(input),- );- if (!computed.ok)- return server.delivery.toCallToolResult(computed, contract);- const result = computed.value;- const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {- predicateType: "rea.static-runtime-correlation",- operation: contract.name,- parameters: {- mapping_count: input.mappings.length,- },- result: jsonValueSchema.parse(result),- confidence: "inferred",- authority: "analyst-inference",- limitations: result.limitations,- evidenceLinks: links,- });- return server.delivery.toEvidenceToolResult(- evidence,- contract,- recordWorkflowEvidence(- session,- evidence,- result.status === "unknown" || result.status === "truncated",- {- question:- "Does runtime behavior match the available static analysis?",- domain: "static-runtime-correlation",- requiredAuthority: null,- requiredConfidence: "derived",- probes: [+ async (input, context) =>+ runAdmittedToolOperation(+ server,+ admission,+ contract.name,+ context.mcpReq.signal,+ async () => {+ const closure = evidenceClosure(+ session,+ comparisonClosure([+ ...input.static_comparisons,+ ...input.runtime_comparisons,+ ]),+ );+ if (!closure.ok)+ return server.delivery.toCallToolResult(closure, contract);+ const links = closure.value;+ const computed = await runDerivedOperation(+ context,+ contract.name,+ () => correlateStaticAndRuntime(input),+ );+ if (!computed.ok)+ return server.delivery.toCallToolResult(computed, contract);+ const result = computed.value;+ const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {+ predicateType: "rea.static-runtime-correlation",+ operation: contract.name,+ parameters: {+ mapping_count: input.mappings.length,+ },+ result: jsonValueSchema.parse(result),+ confidence: "inferred",+ authority: "analyst-inference",+ limitations: result.limitations,+ evidenceLinks: links,+ });+ return server.delivery.toEvidenceToolResult(+ evidence,+ contract,+ recordWorkflowEvidence(+ session,+ evidence,+ result.status === "unknown" || result.status === "truncated",{- operation: "capture_process_scenario",- rationale:- "Repeat runtime observations and complete the mapped static comparison Evidence.",+ question:+ "Does runtime behavior match the available static analysis?",+ domain: "static-runtime-correlation",+ requiredAuthority: null,+ requiredConfidence: "derived",+ probes: [+ {+ operation: "capture_process_scenario",+ rationale:+ "Repeat runtime observations and complete the mapped static comparison Evidence.",+ },+ ],},- ],- },- ),- );- },+ ),+ );+ },+ ),);};const registerReconstruction = (server: EvidenceMcpServer,session: BinarySessionPort,+ admission: ReturnType<typeof withAdmittedAnalysis>,contract: ReturnType<typeof toolContract<"verify_reconstruction">>,): void => {server.registerTool(contract.name,toolRegistrationOptions(contract),- async (input, context) => {- const owned = session.exportEvidenceBundle();- const computed = await runDerivedOperation(context, contract.name, () =>- verifyReconstruction(input.specification, owned),- );- if (!computed.ok)- return server.delivery.toCallToolResult(computed, contract);- const result = computed.value;- const closure = evidenceClosure(session, result.evidence_links);- if (!closure.ok)- return server.delivery.toCallToolResult(closure, contract);- const links = closure.value;- const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {- predicateType: "rea.reconstruction-verification",- operation: contract.name,- parameters: {- specification_sha256: result.specification_sha256,- claim_ids: input.specification.claims.map(({ claim_id: id }) => id),+ async (input, context) =>+ runAdmittedToolOperation(+ server,+ admission,+ contract.name,+ context.mcpReq.signal,+ async () => {+ const owned = session.exportEvidenceBundle();+ const computed = await runDerivedOperation(+ context,+ contract.name,+ () => verifyReconstruction(input.specification, owned),+ );+ if (!computed.ok)+ return server.delivery.toCallToolResult(computed, contract);+ const result = computed.value;+ const closure = evidenceClosure(session, result.evidence_links);+ if (!closure.ok)+ return server.delivery.toCallToolResult(closure, contract);+ const links = closure.value;+ const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {+ predicateType: "rea.reconstruction-verification",+ operation: contract.name,+ parameters: {+ specification_sha256: result.specification_sha256,+ claim_ids: input.specification.claims.map(+ ({ claim_id: id }) => id,+ ),+ },+ result: jsonValueSchema.parse(result),+ confidence: "derived",+ authority: "analyst-inference",+ limitations: result.limitations,+ evidenceLinks: links,+ });+ return server.delivery.toEvidenceToolResult(+ evidence,+ contract,+ recordWorkflowEvidence(+ session,+ evidence,+ result.status === "unknown",+ {+ question:+ "Does the reconstruction satisfy every declared claim?",+ domain: "reconstruction-verification",+ requiredAuthority: null,+ requiredConfidence: "derived",+ probes: result.recommended_probes.map(+ ({ operation, rationale }) => ({ operation, rationale }),+ ),+ },+ ),+ );},- result: jsonValueSchema.parse(result),- confidence: "derived",- authority: "analyst-inference",- limitations: result.limitations,- evidenceLinks: links,- });- return server.delivery.toEvidenceToolResult(- evidence,- contract,- recordWorkflowEvidence(session, evidence, result.status === "unknown", {- question: "Does the reconstruction satisfy every declared claim?",- domain: "reconstruction-verification",- requiredAuthority: null,- requiredConfidence: "derived",- probes: result.recommended_probes.map(({ operation, rationale }) => ({- operation,- rationale,- })),- }),- );- },+ ),);};diff --git a/src/server/runDerivedOperation.test.ts b/src/server/runDerivedOperation.test.tsindex 5fc511f47..dabec6cf1 100644--- a/src/server/runDerivedOperation.test.ts+++ b/src/server/runDerivedOperation.test.ts@@ -1,6 +1,9 @@import { describe, expect, it } from "vitest";-import { runDerivedOperation } from "./runDerivedOperation.js";+import {+ runDerivedOperation,+ type DerivedOperationContext,+} from "./runDerivedOperation.js";import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";const context = (@@ -55,6 +58,34 @@ describe("derived MCP operation boundary", () => {});});+ it("lets cancellation win while terminal progress delivery is pending", async () => {+ const controller = new AbortController();+ let terminalReached = false;+ const notifications: DerivedOperationContext = {+ mcpReq: {+ ...context(controller).mcpReq,+ notify: async (notification) => {+ if (notification.params?.message === "complete: Completed compare") {+ terminalReached = true;+ await Promise.resolve();+ controller.abort();+ }+ },+ },+ };+ const result = await runDerivedOperation(+ notifications,+ "compare",+ () => "must-not-publish",+ );++ expect(terminalReached).toBe(true);+ expect(result).toMatchObject({+ ok: false,+ error: { _tag: "AnalysisCancelledError", operation: "compare" },+ });+ });+it("emits bounded monotonic progress with one terminal state", async () => {const controller = new AbortController();const notifications: Array<{diff --git a/src/server/runDerivedOperation.ts b/src/server/runDerivedOperation.tsindex bc0c7ef9d..f34a2b21e 100644--- a/src/server/runDerivedOperation.ts+++ b/src/server/runDerivedOperation.ts@@ -70,5 +70,7 @@ export const runDerivedOperation = async <Value>(message: `Completed ${operation}`,terminal: true,});+ if (context.mcpReq.signal.aborted)+ return err(new AnalysisCancelledError(operation));return ok(value);};diff --git a/tests/boundary/mcp/investigationAnalysisMcp.test.ts b/tests/boundary/mcp/investigationAnalysisMcp.test.tsindex 18e3166ac..d35cc8a35 100644--- a/tests/boundary/mcp/investigationAnalysisMcp.test.ts+++ b/tests/boundary/mcp/investigationAnalysisMcp.test.ts@@ -4,6 +4,7 @@ import { Client, InMemoryTransport } from "@modelcontextprotocol/client";import { expect, it } from "vitest";import {+ createDeferred,createBinarySessionTargets,createTestBinarySession,} from "../../fixtures/binarySession.js";@@ -118,6 +119,88 @@ it("builds exact-address paths with qualified callees and dossier citations", as}});+it("keeps call-path publication ahead of close_binary record draining", async () => {+ const session = createTestBinarySession(() => ({+ health: () => Promise.resolve(),+ execute: () => Promise.resolve(observed(null)),+ close: () => Promise.resolve(resultOk(null)),+ }));+ const server = createServer({ kind: "session", session });+ const client = new Client({ name: "investigation-close-race", version: "1" });+ const [clientTransport, serverTransport] =+ InMemoryTransport.createLinkedPair();+ const preparationReached = createDeferred<void>();+ const closeReached = createDeferred<void>();+ const releasePreparation = createDeferred<void>();+ const send = serverTransport.send.bind(serverTransport);+ serverTransport.send = async (message, options) => {+ await send(message, options);+ if (+ "method" in message &&+ message.method === "notifications/progress" &&+ "params" in message &&+ typeof message.params === "object" &&+ message.params !== null &&+ "message" in message.params+ ) {+ if (message.params.message === "prepare: Preparing build_call_path") {+ preparationReached.resolve();+ await releasePreparation.promise;+ } else if (message.params.message === "close_binary: started") {+ closeReached.resolve();+ }+ }+ };+ await server.connect(serverTransport);+ await client.connect(clientTransport);+ const settlementOrder: string[] = [];+ try {+ const input = INVESTIGATION_EXAMPLES.build_call_path;+ for (const evidence of input.functions)+ expect(session.recordEvidence(evidence).ok).toBe(true);++ const request = client+ .callTool(+ { name: "build_call_path", arguments: input },+ { onprogress: () => undefined },+ )+ .then((response) => {+ settlementOrder.push("build_call_path");+ return response;+ });+ await preparationReached.promise;++ let closeSettled = false;+ const closing = client+ .callTool(+ { name: "close_binary", arguments: {} },+ { onprogress: () => undefined },+ )+ .then((response) => {+ closeSettled = true;+ settlementOrder.push("close_binary");+ return response;+ });+ await closeReached.promise;+ expect(closeSettled).toBe(false);++ releasePreparation.resolve();+ const [response, closed] = await Promise.all([request, closing]);+ expect(response.isError, JSON.stringify(response)).not.toBe(true);+ expect(closed.isError, JSON.stringify(closed)).not.toBe(true);+ expect(settlementOrder).toEqual(["build_call_path", "close_binary"]);+ const evidence = inlineEvidence(response.structuredContent);+ expect(evidence).toMatchObject({+ provider: { id: "rea-call-path" },+ evidence_links: input.functions.map(({ evidence_id }) => evidence_id),+ });+ expect(session.exportEvidenceBundle().records).toHaveLength(0);+ } finally {+ releasePreparation.resolve();+ await close(session, server, client);+ }+}, 10_000);+const dossierWithCallees = (addresses: readonly string[]) => {const base = FUNCTION_COMPARISON_EXAMPLE.left;if (base.subject === null) throw new Error("missing dossier subject");