Skip to content

armgit / rea

Public Imported from GitHub
0

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

perf(evidence): reuse authenticated comparisons through aggregation

morluto26bffb94bf80
diff --git a/src/domain/changedBehavior.test.ts b/src/domain/changedBehavior.test.ts
index cc19c4c50..6d99e828f 100644
--- a/src/domain/changedBehavior.test.ts
+++ b/src/domain/changedBehavior.test.ts
@@ -22,6 +22,9 @@ const source = (digit: string): Evidence =>
const left = source("1");
const right = source("2");
+const aggregate = (comparisons: readonly unknown[]) =>
+ findChangedBehavior({ comparisons });
+
const comparison = (
operation: "compare_process_captures" | "compare_artifacts",
result: JsonValue,
@@ -136,9 +139,9 @@ const expectInvalidSummary = (result: ChangedBehaviorResult): void => {
describe("changed behavior", () => {
it("accepts process comparison Evidence", () => {
- const result = findChangedBehavior([
+ const result = aggregate([
comparison("compare_process_captures", processResult()),
- ]);
+ ]).result;
expect(result.behavior_status).toBe("observed_unchanged");
});
@@ -152,7 +155,7 @@ describe("changed behavior", () => {
}),
);
- expect(findChangedBehavior([evidence])).toMatchObject({
+ expect(aggregate([evidence]).result).toMatchObject({
behavior_status: "observed_changed",
summary: { observed_changes: 2 },
findings: {
@@ -172,7 +175,7 @@ describe("changed behavior", () => {
"compare_process_captures",
processResult({ status: "changed", terminal: "changed" }),
);
- const result = findChangedBehavior([evidence]);
+ const result = aggregate([evidence]).result;
expect(changedBehaviorResultSchema.parse(result)).toMatchObject({
behavior_status: "observed_changed",
summary: { observed_changes: 1, static_candidates: 0 },
@@ -193,7 +196,7 @@ describe("changed behavior", () => {
it("keeps static differences as candidates, never runtime observations", () => {
const evidence = comparison("compare_artifacts", artifactResult());
- const result = findChangedBehavior([evidence]);
+ const result = aggregate([evidence]).result;
expect(result).toMatchObject({
behavior_status: "unknown",
summary: { observed_changes: 0, static_candidates: 1 },
@@ -217,17 +220,17 @@ describe("changed behavior", () => {
"compare_process_captures",
processResult({ status: "unknown", exit: "unknown" }),
);
- const result = findChangedBehavior([changed, unknown]);
+ const result = aggregate([changed, unknown]).result;
expect(result).toMatchObject({
behavior_status: "unknown",
findings: { items: expect.any(Array) },
});
- expect(findChangedBehavior([changed, unknown])).toEqual(result);
+ expect(aggregate([changed, unknown]).result).toEqual(result);
});
it("uses complete inline artifact deltas as static candidates", () => {
const complete = comparison("compare_artifacts", artifactResult());
- expect(findChangedBehavior([complete]).findings.items).toEqual(
+ expect(aggregate([complete]).result.findings.items).toEqual(
expect.arrayContaining([
expect.objectContaining({ dimension: "artifact:main.js" }),
]),
@@ -236,7 +239,7 @@ describe("changed behavior", () => {
it("rejects bundles, duplicate comparisons, and malformed exact results", () => {
const valid = comparison("compare_process_captures", processResult());
- expect(() => findChangedBehavior([valid, valid])).toThrow(
+ expect(() => aggregate([valid, valid])).toThrow(
/duplicate comparison Evidence/u,
);
const bundle = createEvidence(
@@ -252,25 +255,25 @@ describe("changed behavior", () => {
evidenceLinks: [left.evidence_id, right.evidence_id],
},
);
- expect(() => findChangedBehavior([bundle])).toThrow(
+ expect(() => aggregate([bundle])).toThrow(
/requires process, artifact, or function/u,
);
const malformed = comparison("compare_process_captures", {
status: "unchanged",
});
- expect(() => findChangedBehavior([malformed])).toThrow();
+ expect(() => aggregate([malformed])).toThrow();
const contradictory = comparison(
"compare_process_captures",
processResult({ status: "unchanged", terminal: "changed" }),
);
- expect(() => findChangedBehavior([contradictory])).toThrow(
+ expect(() => aggregate([contradictory])).toThrow(
/contradicts its dimensions/u,
);
const danglingNested = comparison(
"compare_artifacts",
artifactResult([`ev_${"f".repeat(64)}`, right.evidence_id]),
);
- expect(() => findChangedBehavior([danglingNested])).toThrow(
+ expect(() => aggregate([danglingNested])).toThrow(
/outside its top-level closure/u,
);
});
@@ -299,10 +302,15 @@ describe("changed behavior aggregation", () => {
),
);
- const result = findChangedBehavior(comparisons);
+ const result = aggregate(comparisons);
- expect(result.summary.observed_changes).toBe(comparisons.length);
- expect(result.evidence_links).toHaveLength(comparisons.length * 201 + 2);
- expect(result.findings.items[0]?.evidence_links).toHaveLength(203);
+ expect(result.result.summary.observed_changes).toBe(comparisons.length);
+ expect(result.result.evidence_links).toHaveLength(
+ comparisons.length * 201 + 2,
+ );
+ expect(result.result.findings.items[0]?.evidence_links).toHaveLength(203);
+ expect(result.comparisonEvidenceIds).toEqual(
+ comparisons.map(({ evidence_id }) => evidence_id),
+ );
});
});
diff --git a/src/domain/changedBehavior.ts b/src/domain/changedBehavior.ts
index b785cdd23..56e9b6ad9 100644
--- a/src/domain/changedBehavior.ts
+++ b/src/domain/changedBehavior.ts
@@ -91,6 +91,22 @@ export const changedBehaviorResultSchema = z
export type ChangedBehaviorResult = z.infer<typeof changedBehaviorResultSchema>;
type Finding = z.infer<typeof findingSchema>;
type RuntimeStatus = z.infer<typeof processCaptureComparisonSchema>["status"];
+type ParsedComparison =
+ | {
+ readonly operation: "compare_process_captures";
+ readonly evidence: Evidence;
+ readonly result: z.infer<typeof processCaptureComparisonSchema>;
+ }
+ | {
+ readonly operation: "compare_functions";
+ readonly evidence: Evidence;
+ readonly result: z.infer<typeof functionComparisonResultSchema>;
+ }
+ | {
+ readonly operation: "compare_artifacts";
+ readonly evidence: Evidence;
+ readonly result: z.infer<typeof artifactComparisonResultSchema>;
+ };
const EXPECTED_PROVIDERS = {
compare_process_captures: {
@@ -117,24 +133,37 @@ const acceptsPredicate = (
): boolean => expected.some((predicate) => predicate === actual);
/** Find observed runtime changes and separately report static change candidates. */
-export const findChangedBehavior = (
- comparisonsInput: unknown,
-): ChangedBehaviorResult => {
- const parsedInput = changedBehaviorInputSchema.parse({
- comparisons: comparisonsInput,
- });
- const comparisons = parsedInput.comparisons;
+interface FoundChangedBehavior {
+ readonly result: ChangedBehaviorResult;
+ /** Authenticated IDs retained from the comparisons used to compute result. */
+ readonly comparisonEvidenceIds: readonly string[];
+}
+
+export const findChangedBehavior = (input: unknown): FoundChangedBehavior => {
+ // The public input schema remains available to clients; this internal
+ // admission only checks the list shape because parseEvidence below owns
+ // validation and authentication of each retained Evidence item.
+ const { comparisons } = z
+ .strictObject({ comparisons: z.array(z.unknown()).min(1) })
+ .parse(input);
const evidence = comparisons.map(parseComparisonEvidence);
assertUnique(
- evidence.map(({ evidence_id: id }) => id),
+ evidence.map(({ evidence: { evidence_id: id } }) => id),
"comparison Evidence",
);
const findings = evidence.flatMap(findingsFor).sort(compareFindings);
- const runtimeStatuses = evidence.flatMap(runtimeStatus);
+ const runtimeStatuses = evidence.flatMap((comparison) =>
+ comparison.operation === "compare_process_captures"
+ ? [comparison.result.status]
+ : [],
+ );
const links = uniqueSorted(
- evidence.flatMap((item) => [item.evidence_id, ...item.evidence_links]),
+ evidence.flatMap(({ evidence: item }) => [
+ item.evidence_id,
+ ...item.evidence_links,
+ ]),
);
- return changedBehaviorResultSchema.parse({
+ const result = changedBehaviorResultSchema.parse({
behavior_status: behaviorStatus(runtimeStatuses),
summary: {
observed_changes: count(findings, "observed_change"),
@@ -147,7 +176,7 @@ export const findChangedBehavior = (
},
evidence_links: links,
limitations: uniqueSorted([
- ...evidence.flatMap(({ limitations }) => limitations),
+ ...evidence.flatMap(({ evidence: item }) => item.limitations),
...(evidence.some(
({ operation }) => operation !== "compare_process_captures",
)
@@ -160,9 +189,15 @@ export const findChangedBehavior = (
: []),
]),
});
+ return {
+ result,
+ comparisonEvidenceIds: evidence.map(
+ ({ evidence: { evidence_id } }) => evidence_id,
+ ),
+ };
};
-const parseComparisonEvidence = (input: unknown): Evidence => {
+const parseComparisonEvidence = (input: unknown): ParsedComparison => {
const evidence = parseEvidence(input);
if (!(evidence.operation in EXPECTED_PROVIDERS))
throw new TypeError(
@@ -198,12 +233,17 @@ const parseComparisonEvidence = (input: unknown): Evidence => {
throw new TypeError(
"Comparison Evidence must cite both selected source observations",
);
- parseResult(evidence);
- return evidence;
+ return parseResult(evidence, operation);
};
-const parseResult = (evidence: Evidence): void => {
- if (evidence.operation === "compare_process_captures") {
+const parseResult = (
+ evidence: Evidence,
+ operation:
+ | "compare_process_captures"
+ | "compare_artifacts"
+ | "compare_functions",
+): ParsedComparison => {
+ if (operation === "compare_process_captures") {
const result = processCaptureComparisonSchema.parse(
evidence.normalized_result,
);
@@ -214,9 +254,9 @@ const parseResult = (evidence: Evidence): void => {
throw new TypeError(
"Process comparison status contradicts its dimensions",
);
- return;
+ return { operation, evidence, result };
}
- if (evidence.operation === "compare_functions") {
+ if (operation === "compare_functions") {
const result = functionComparisonResultSchema.parse(
evidence.normalized_result,
);
@@ -224,7 +264,7 @@ const parseResult = (evidence: Evidence): void => {
evidence,
result.dimensions.flatMap(({ evidence_links: links }) => links),
);
- return;
+ return { operation, evidence, result };
}
const result = artifactComparisonResultSchema.parse(
evidence.normalized_result,
@@ -233,6 +273,7 @@ const parseResult = (evidence: Evidence): void => {
evidence,
result.changes.flatMap(({ evidence_links: links }) => links),
);
+ return { operation, evidence, result };
};
const assertNestedLinks = (
@@ -246,18 +287,21 @@ const assertNestedLinks = (
);
};
-const findingsFor = (evidence: Evidence): Finding[] => {
- if (evidence.operation === "compare_process_captures")
- return processFindings(evidence);
- if (evidence.operation === "compare_functions")
- return functionFindings(evidence);
- return artifactFindings(evidence);
+const findingsFor = (comparison: ParsedComparison): Finding[] => {
+ if (comparison.operation === "compare_process_captures")
+ return processFindings(comparison);
+ if (comparison.operation === "compare_functions")
+ return functionFindings(comparison);
+ return artifactFindings(comparison);
};
-const processFindings = (evidence: Evidence): Finding[] => {
- const result = processCaptureComparisonSchema.parse(
- evidence.normalized_result,
- );
+const processFindings = (
+ comparison: Extract<
+ ParsedComparison,
+ { readonly operation: "compare_process_captures" }
+ >,
+): Finding[] => {
+ const { evidence, result } = comparison;
const dimensions = [
["terminal", result.terminal, "runtime"],
["interaction", result.interaction, "runtime"],
@@ -283,10 +327,13 @@ const processFindings = (evidence: Evidence): Finding[] => {
);
};
-const functionFindings = (evidence: Evidence): Finding[] => {
- const result = functionComparisonResultSchema.parse(
- evidence.normalized_result,
- );
+const functionFindings = (
+ comparison: Extract<
+ ParsedComparison,
+ { readonly operation: "compare_functions" }
+ >,
+): Finding[] => {
+ const { evidence, result } = comparison;
return result.dimensions.flatMap((dimension) =>
dimension.status === "unchanged"
? []
@@ -307,10 +354,13 @@ const functionFindings = (evidence: Evidence): Finding[] => {
);
};
-const artifactFindings = (evidence: Evidence): Finding[] => {
- const result = artifactComparisonResultSchema.parse(
- evidence.normalized_result,
- );
+const artifactFindings = (
+ comparison: Extract<
+ ParsedComparison,
+ { readonly operation: "compare_artifacts" }
+ >,
+): Finding[] => {
+ const { evidence, result } = comparison;
const changes = result.changes.map((change) =>
makeFinding({
evidence,
@@ -367,11 +417,6 @@ const makeFinding = (input: {
limitations: uniqueSorted(input.limitations),
});
-const runtimeStatus = (evidence: Evidence): RuntimeStatus[] =>
- evidence.operation === "compare_process_captures"
- ? [processCaptureComparisonSchema.parse(evidence.normalized_result).status]
- : [];
-
const behaviorStatus = (
statuses: readonly RuntimeStatus[],
): ChangedBehaviorResult["behavior_status"] => {
diff --git a/src/server/registerInvestigationTools.ts b/src/server/registerInvestigationTools.ts
index d5a2a4706..02e1c52d0 100644
--- a/src/server/registerInvestigationTools.ts
+++ b/src/server/registerInvestigationTools.ts
@@ -21,7 +21,10 @@ import {
RECONSTRUCTION_PROVIDER,
STATIC_RUNTIME_PROVIDER,
} from "../application/InvestigationProviders.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import {
+ applicationValidatedInputSchema,
+ toolRegistrationOptions,
+} from "./toolRegistrationOptions.js";
import { verifyReconstruction } from "../domain/reconstructionVerification.js";
/** Register Evidence-composed differential investigation workflows. */
@@ -52,30 +55,29 @@ const registerChangedBehavior = (
session: BinarySessionPort,
contract: ReturnType<typeof toolContract<"find_changed_behavior">>,
): void => {
+ const registration = toolRegistrationOptions(contract);
server.registerTool(
contract.name,
- toolRegistrationOptions(contract),
+ {
+ ...registration,
+ inputSchema: applicationValidatedInputSchema(registration.inputSchema),
+ },
async (input, context) => {
- const closure = evidenceClosure(
- session,
- comparisonClosure(input.comparisons),
- );
- if (!closure.ok)
- return server.delivery.toCallToolResult(closure, contract);
- const links = closure.value;
const computed = await runDerivedOperation(context, contract.name, () =>
- findChangedBehavior(input.comparisons),
+ findChangedBehavior(input),
);
if (!computed.ok)
return server.delivery.toCallToolResult(computed, contract);
- const result = computed.value;
+ 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: input.comparisons.map(
- ({ evidence_id: id }) => id,
- ),
+ comparison_evidence_ids: [...comparisonEvidenceIds],
},
result: jsonValueSchema.parse(result),
confidence: "derived",
diff --git a/tests/boundary/mcp/processEvidenceIdentityMcp.test.ts b/tests/boundary/mcp/processEvidenceIdentityMcp.test.ts
index fb20dd79b..993f1df69 100644
--- a/tests/boundary/mcp/processEvidenceIdentityMcp.test.ts
+++ b/tests/boundary/mcp/processEvidenceIdentityMcp.test.ts
@@ -309,7 +309,9 @@ it("separately rejects a tampered digest before admission to any consumer or ses
};
const digestMismatch = /semantic identifier does not match/u;
expect(() => parseEvidence(tampered)).toThrow(digestMismatch);
- expect(() => findChangedBehavior([tampered])).toThrow(digestMismatch);
+ expect(() => findChangedBehavior({ comparisons: [tampered] })).toThrow(
+ digestMismatch,
+ );
expect(() => correlateStaticAndRuntime(correlationInput(tampered))).toThrow(
digestMismatch,
);
@@ -336,6 +338,19 @@ it("separately rejects a tampered digest before admission to any consumer or ses
}
});
+it("maps malformed changed-behavior Evidence to an invalid request before closure lookup", async () => {
+ const { client, comparison } = await connectedComparison();
+ const malformed = { ...comparison, evidence_links: undefined } as unknown;
+ const response = await client.callTool({
+ name: "find_changed_behavior",
+ arguments: { comparisons: [malformed] },
+ });
+ expect(response.isError).toBe(true);
+ expect(parseMcpToolError(response)).toMatchObject({
+ error: { code: "invalid_request" },
+ });
+});
+
it("keeps withheld ownership unknown through CLI and MCP comparison", async () => {
const { client, right } = await connectedComparison();
const left = captureEvidence("left", {