Merge pull request #706 from kaoru0822-kitauji/fix/process-evidence-provider-identity

fix(evidence): admit current process provider identity
This commit is contained in:
Kaoru0822
2026-10-06 02:00:47 -07:00
committed by GitHub
7 changed files with 419 additions and 23 deletions
+2 -6
View File
@@ -1,17 +1,13 @@
import type { JsonValue } from "../domain/jsonValue.js";
import { createEvidence } from "../domain/evidence.js";
import { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
import { jsonValueSchema } from "../domain/jsonValue.js";
import type {
ProcessCapture,
ProcessScenario,
} from "../domain/processCapture.js";
/** Provider identity for controlled process capture evidence. */
export const PROCESS_PROVIDER = {
id: "rea-process",
name: "REA process capture",
version: "3",
} as const;
export { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
/** Project one process scenario into secret-free Evidence parameters. */
const processEvidenceParameters = (
+10 -6
View File
@@ -4,6 +4,10 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
import { uniqueSorted } from "./canonicalOrdering.js";
import { evidenceSchema, parseEvidence, type Evidence } from "./evidence.js";
import { functionComparisonResultSchema } from "./functionComparison.js";
import {
PROCESS_PROVIDER,
isProcessEvidenceProvider,
} from "./processEvidenceProvider.js";
import {
comparisonStatusSchema,
deriveProcessComparisonStatus,
@@ -86,9 +90,7 @@ type RuntimeStatus = z.infer<typeof processCaptureComparisonSchema>["status"];
const EXPECTED_PROVIDERS = {
compare_process_captures: {
predicates: ["rea.process-comparison"],
id: "rea-process",
name: "REA deterministic process harness",
version: "3",
...PROCESS_PROVIDER,
},
compare_artifacts: {
predicates: ["rea.artifact-comparison"],
@@ -171,9 +173,11 @@ const parseComparisonEvidence = (input: unknown): Evidence => {
const expected = EXPECTED_PROVIDERS[operation];
if (
!acceptsPredicate(expected.predicates, evidence.predicate_type) ||
evidence.provider.id !== expected.id ||
evidence.provider.name !== expected.name ||
evidence.provider.version !== expected.version ||
(operation === "compare_process_captures"
? !isProcessEvidenceProvider(evidence.provider)
: evidence.provider.id !== expected.id ||
evidence.provider.name !== expected.name ||
evidence.provider.version !== expected.version) ||
evidence.confidence !== "derived" ||
evidence.authority !== "analyst-inference" ||
evidence.subject !== null
@@ -0,0 +1,32 @@
import { expect, it } from "vitest";
import {
PROCESS_PROVIDER,
isProcessEvidenceProvider,
} from "./processEvidenceProvider.js";
it.each(["REA process capture", "REA deterministic process harness"])(
"accepts the exact v3 process provider name %s",
(name) => {
expect(isProcessEvidenceProvider({ ...PROCESS_PROVIDER, name })).toBe(true);
},
);
it.each([
{ name: "REA process capture extra" },
{ name: "REA deterministic process harness extra" },
{ name: "rea process capture" },
{ name: "REA Process Capture" },
{ name: " REA process capture" },
{ name: "REA process capture " },
{ name: "REA deterministic process harness " },
{ name: "Fixture process provider" },
{ id: "fixture-process" },
{ version: "2" },
{ version: "4" },
{ version: null },
])("rejects other process identities: %j", (change) => {
expect(isProcessEvidenceProvider({ ...PROCESS_PROVIDER, ...change })).toBe(
false,
);
});
+17
View File
@@ -0,0 +1,17 @@
import type { EvidenceProvider } from "./evidence.js";
/** Canonical provider identity for controlled process capture Evidence. */
export const PROCESS_PROVIDER = {
id: "rea-process",
name: "REA process capture",
version: "3",
} as const;
/** Admit current and previously emitted names for the same v3 process provider. */
export const isProcessEvidenceProvider = (
provider: EvidenceProvider,
): boolean =>
provider.id === PROCESS_PROVIDER.id &&
provider.version === PROCESS_PROVIDER.version &&
(provider.name === PROCESS_PROVIDER.name ||
provider.name === "REA deterministic process harness");
+10 -5
View File
@@ -9,6 +9,10 @@ import { uniqueSorted } from "./canonicalOrdering.js";
import { parseEvidence, type Evidence } from "./evidence.js";
import { parseEvidenceBundle } from "./evidenceBundle.js";
import { functionComparisonResultSchema } from "./functionComparison.js";
import {
PROCESS_PROVIDER,
isProcessEvidenceProvider,
} from "./processEvidenceProvider.js";
import { functionDossierSchema } from "./hopperValues.js";
import {
deriveProcessComparisonStatus,
@@ -45,8 +49,7 @@ const providers = {
behavioral: {
operation: "compare_process_captures",
predicates: ["rea.process-comparison"],
id: "rea-process",
name: "REA deterministic process harness",
...PROCESS_PROVIDER,
},
"structural-function": {
operation: "compare_functions",
@@ -209,9 +212,11 @@ const validateComparisonIdentity = (claim: Claim, evidence: Evidence): void => {
if (
evidence.operation !== expected.operation ||
!acceptsPredicate(expected.predicates, evidence.predicate_type) ||
evidence.provider.id !== expected.id ||
evidence.provider.name !== expected.name ||
evidence.provider.version !== (claim.kind === "behavioral" ? "3" : "1") ||
(claim.kind === "behavioral"
? !isProcessEvidenceProvider(evidence.provider)
: evidence.provider.id !== expected.id ||
evidence.provider.name !== expected.name ||
evidence.provider.version !== "1") ||
evidence.confidence !== "derived" ||
evidence.authority !== "analyst-inference" ||
evidence.subject !== null
+11 -6
View File
@@ -7,6 +7,10 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
import { uniqueSorted } from "./canonicalOrdering.js";
import { evidenceSchema, parseEvidence, type Evidence } from "./evidence.js";
import { functionComparisonResultSchema } from "./functionComparison.js";
import {
PROCESS_PROVIDER,
isProcessEvidenceProvider,
} from "./processEvidenceProvider.js";
import type { JsonValue } from "./jsonValue.js";
import {
comparisonStatusSchema,
@@ -151,8 +155,8 @@ const EXPECTED: Readonly<Record<string, ComparisonIdentity>> = {
],
compare_process_captures: [
"rea.process-comparison",
"rea-process",
"REA deterministic process harness",
PROCESS_PROVIDER.id,
PROCESS_PROVIDER.name,
],
};
@@ -381,10 +385,11 @@ const assertComparisonIdentity = (evidence: Evidence): void => {
!(Array.isArray(expected[0])
? expected[0].includes(evidence.predicate_type)
: evidence.predicate_type === expected[0]) ||
evidence.provider.id !== expected[1] ||
evidence.provider.name !== expected[2] ||
evidence.provider.version !==
(evidence.operation === "compare_process_captures" ? "3" : "1") ||
(evidence.operation === "compare_process_captures"
? !isProcessEvidenceProvider(evidence.provider)
: evidence.provider.id !== expected[1] ||
evidence.provider.name !== expected[2] ||
evidence.provider.version !== "1") ||
evidence.confidence !== "derived" ||
evidence.authority !== "analyst-inference" ||
evidence.subject !== null ||
@@ -0,0 +1,337 @@
import { writeFile } from "node:fs/promises";
import { join } from "node:path";
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
import { expect, it, onTestFinished } from "vitest";
import { z } from "zod";
import { compareProcessEvidenceFiles } from "../../../src/application/ProcessCli.js";
import { PROCESS_PROVIDER } from "../../../src/application/ProcessEvidence.js";
import { FUNCTION_COMPARISON_EXAMPLE } from "../../../src/contracts/functionComparisonExample.js";
import {
FUNCTION_COMPARISON_EVIDENCE,
INVESTIGATION_EXAMPLES,
} from "../../../src/contracts/investigationExamples.js";
import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../../../src/contracts/processCaptureExample.js";
import { findChangedBehavior } from "../../../src/domain/changedBehavior.js";
import {
createEvidence,
parseEvidence,
type Evidence,
} from "../../../src/domain/evidence.js";
import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js";
import { verifyReconstruction } from "../../../src/domain/reconstructionVerification.js";
import { correlateStaticAndRuntime } from "../../../src/domain/staticRuntimeCorrelation.js";
import { createServer } from "../../../src/server/createServer.js";
import { createTestBinarySession } from "../../fixtures/binarySession.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
const providerNames = [
"REA process capture",
"REA deterministic process harness",
];
const captureEvidence = (side: "left" | "right") =>
createEvidence(undefined, PROCESS_PROVIDER, {
predicateType: "rea.process-capture",
operation: "capture_process_scenario",
parameters: { side },
result: EMPTY_PROCESS_CAPTURE_EXAMPLE,
confidence: "observed",
authority: "controlled-replay",
environment: {
id: "fixture-process",
platform: "fixture",
architecture: "fixture",
isolation: "process",
},
});
const inlineEvidence = (response: { structuredContent?: unknown }) =>
parseEvidence(
z.object({ evidence: z.unknown() }).parse(response.structuredContent)
.evidence,
);
const connectedComparison = async () => {
const session = createTestBinarySession(() => {
throw new Error("Process comparison must not launch a provider");
});
const server = createServer(session, session);
const client = new Client({
name: "process-evidence-identity",
version: "1",
});
onTestFinished(async () => {
await Promise.allSettled([client.close(), server.close(), session.close()]);
});
const [clientTransport, serverTransport] =
InMemoryTransport.createLinkedPair();
await server.connect(serverTransport);
await client.connect(clientTransport);
for (const evidence of [
FUNCTION_COMPARISON_EXAMPLE.left,
FUNCTION_COMPARISON_EXAMPLE.right,
FUNCTION_COMPARISON_EVIDENCE,
])
expect(session.recordEvidence(evidence).ok).toBe(true);
const left = captureEvidence("left");
const right = captureEvidence("right");
const response = await client.callTool({
name: "compare_process_captures",
arguments: { left, right },
});
expect(response.isError, JSON.stringify(response)).not.toBe(true);
const comparison = inlineEvidence(response);
expect(comparison.provider).toEqual({
id: "rea-process",
name: "REA process capture",
version: "3",
});
expect(comparison.normalized_result).toMatchObject({ status: "unchanged" });
return { session, client, left, right, comparison };
};
const correlationInput = (comparison: Evidence) => {
const mapping =
INVESTIGATION_EXAMPLES.correlate_static_and_runtime.mappings[0];
if (mapping === undefined) throw new Error("Missing correlation mapping");
return {
static_comparisons: [FUNCTION_COMPARISON_EVIDENCE],
runtime_comparisons: [comparison],
mappings: [
{
...mapping,
runtime: {
...mapping.runtime,
comparison_evidence_id: comparison.evidence_id,
},
},
],
};
};
const specification = (comparison: Evidence) => ({
name: "Terminal compatibility",
claims: [
{
kind: "behavioral",
claim_id: "terminal-output",
title: "Terminal output remains equivalent",
comparison_evidence_id: comparison.evidence_id,
dimension: "terminal",
},
],
});
const consumerCalls = (comparison: Evidence) => [
{
name: "find_changed_behavior",
arguments: { comparisons: [comparison] },
expected: { behavior_status: "observed_unchanged" },
},
{
name: "correlate_static_and_runtime",
arguments: correlationInput(comparison),
expected: { status: "correlated" },
},
{
name: "verify_reconstruction",
arguments: { specification: specification(comparison) },
expected: { status: "pass" },
},
];
const expectConsumerResults = async (client: Client, comparison: Evidence) => {
for (const { expected, ...call } of consumerCalls(comparison)) {
const response = await client.callTool(call);
expect(
response.isError,
`${call.name}: ${JSON.stringify(response)}`,
).not.toBe(true);
expect(inlineEvidence(response).normalized_result).toMatchObject(expected);
}
};
it("feeds the exact public CLI/MCP process comparison into all three MCP consumers", async () => {
const { client, left, right, comparison } = await connectedComparison();
const root = await createTestTempDirectory("rea-process-identity-");
const leftPath = join(root, "left.json");
const rightPath = join(root, "right.json");
await Promise.all([
writeFile(leftPath, JSON.stringify(left)),
writeFile(rightPath, JSON.stringify(right)),
]);
const cliComparison = parseEvidence(
await compareProcessEvidenceFiles(leftPath, rightPath),
);
expect(cliComparison).toEqual(comparison);
await expectConsumerResults(client, comparison);
});
type IdentityChange = Partial<
Pick<
Evidence,
| "provider"
| "predicate_type"
| "operation"
| "subject"
| "confidence"
| "authority"
>
>;
// Use the public Evidence builder so each admission control has a valid digest.
const rehashedComparison = (
base: Evidence,
change: IdentityChange,
): Evidence => {
const next = { ...base, ...change };
const subject = next.subject;
return createEvidence(
subject === null
? undefined
: {
path: subject.local_path,
sha256: subject.digest.sha256,
format: subject.format,
...(subject.architecture === null
? {}
: { architecture: subject.architecture }),
},
next.provider,
{
predicateType: next.predicate_type,
operation: next.operation,
parameters: next.parameters,
result: next.normalized_result,
rawResult: next.raw_result,
confidence: next.confidence,
authority: next.authority,
environment: next.environment,
limitations: next.limitations,
locations: next.locations,
evidenceLinks: next.evidence_links,
},
);
};
it.each(providerNames)(
"admits the exact v3 provider name %s in every MCP consumer",
async (name) => {
const { session, client, comparison } = await connectedComparison();
const admitted = rehashedComparison(comparison, {
provider: { ...comparison.provider, name },
});
expect(parseEvidence(admitted)).toEqual(admitted);
expect(session.recordEvidence(admitted).ok).toBe(true);
await expectConsumerResults(client, admitted);
},
);
const invalidIdentities: ReadonlyArray<{
label: string;
change: (base: Evidence) => IdentityChange;
}> = [
{
label: "wrong name",
change: ({ provider }) => ({
provider: { ...provider, name: `${provider.name} extra` },
}),
},
{
label: "wrong id",
change: ({ provider }) => ({
provider: { ...provider, id: "fixture-process" },
}),
},
{
label: "old version",
change: ({ provider }) => ({ provider: { ...provider, version: "2" } }),
},
{
label: "future version",
change: ({ provider }) => ({ provider: { ...provider, version: "4" } }),
},
{
label: "missing version",
change: ({ provider }) => ({ provider: { ...provider, version: null } }),
},
{
label: "wrong predicate",
change: () => ({ predicate_type: "fixture.comparison" }),
},
{
label: "wrong operation",
change: () => ({ operation: "fixture_comparison" }),
},
{
label: "non-null subject",
change: () => ({ subject: FUNCTION_COMPARISON_EXAMPLE.left.subject }),
},
{ label: "wrong confidence", change: () => ({ confidence: "observed" }) },
{
label: "wrong authority",
change: () => ({ authority: "controlled-replay" }),
},
];
for (const name of providerNames)
it.each(invalidIdentities)(
`rejects independently rehashed $label for ${name} in every MCP consumer`,
async ({ change }) => {
const { session, client, comparison } = await connectedComparison();
const named = rehashedComparison(comparison, {
provider: { ...comparison.provider, name },
});
const invalid = rehashedComparison(named, change(named));
expect(invalid.evidence_id).not.toBe(named.evidence_id);
expect(parseEvidence(invalid)).toEqual(invalid);
expect(session.recordEvidence(invalid).ok).toBe(true);
for (const { expected: _expected, ...call } of consumerCalls(invalid)) {
const response = await client.callTool(call);
expect(response.isError, call.name).toBe(true);
expect(response.structuredContent, call.name).toMatchObject({
error: { code: "invalid_request" },
});
}
},
);
it("separately rejects a tampered digest before admission to any consumer or session", async () => {
const { session, client, comparison } = await connectedComparison();
const tampered = {
...comparison,
provider: {
...comparison.provider,
name: "REA deterministic process harness",
},
};
const digestMismatch = /semantic identifier does not match/u;
expect(() => parseEvidence(tampered)).toThrow(digestMismatch);
expect(() => findChangedBehavior([tampered])).toThrow(digestMismatch);
expect(() => correlateStaticAndRuntime(correlationInput(tampered))).toThrow(
digestMismatch,
);
const records = session
.exportEvidenceBundle()
.records.map((record) =>
record.evidence_id === tampered.evidence_id ? tampered : record,
);
expect(() =>
verifyReconstruction(
specification(tampered),
createEvidenceBundle(records),
),
).toThrow(digestMismatch);
expect(session.recordEvidence(tampered).ok).toBe(false);
for (const { expected: _expected, ...call } of consumerCalls(tampered).filter(
({ name }) => name !== "verify_reconstruction",
)) {
const response = await client.callTool(call);
expect(response.isError, call.name).toBe(true);
expect(response.structuredContent).toMatchObject({
error: { code: "invalid_request" },
});
}
});