Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(server): retain session admission through investigation publication

morluto663d07f02cd6
diff --git a/src/server/registerInvestigationTools.ts b/src/server/registerInvestigationTools.ts
index 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.ts
index 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.ts
index 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.ts
index 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");