@openagentsinc/conformance-kit 0.2.0-rc.7 → 0.2.1-rc.3

package/README.md

@@ -23,14 +23,24 @@ is proven to work before anyone points it at a third-party implementation.
 
 ## The suites
 
-| Import                                     | Runner                     | Implementation under test        | Laws                                                                                                                                                   |
-| ------------------------------------------ | -------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `@openagentsinc/conformance-kit/adapter`   | `runAdapterLaws`           | `AgentHarness`                   | turn framing, capability refusal is fail-closed and named, suspend/continue cursor exactness (with honest lossy degradation)                           |
-| `@openagentsinc/conformance-kit/event-log` | `runEventLogLaws`          | `HarnessEventLogStore`           | append monotonicity / dup-free, gap-free replay from a cursor, durable replay after process death, rerun boundaries, live attach, single-flight attach |
-| `@openagentsinc/conformance-kit/reducer`   | `runReducerLaws`           | a progressive UI-message reducer | progressive fold, tool state machine, transient bypass, fail-loud-never-corrupt                                                                        |
-| `@openagentsinc/conformance-kit/recall`    | `runRecallLaws`            | a `HistoryRecall` Tier D source  | correctness anchor, caps truncate + report, `cost.modelCalls === 0`, coverage-note carry-through, typed invalid input                                  |
-| `@openagentsinc/conformance-kit/rlm`       | `runRlmCapLaws`            | the RLM engine + corpus source   | every cap → honest `Partial`, generous → `Completed`, no laundering, deterministic never touches a model                                               |
-| `@openagentsinc/conformance-kit/corpus`    | `runCorpusCompositionLaws` | a constructor and projection     | identity, order, policy, scope, freshness, citations, duplicates, planes, coverage, exclusions, bounded access                                         |
+| Import                                          | Runner                         | Implementation under test        | Laws                                                                                                                                                   |
+| ----------------------------------------------- | ------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `@openagentsinc/conformance-kit/adapter`        | `runAdapterLaws`               | `AgentHarness`                   | turn framing, capability refusal is fail-closed and named, suspend/continue cursor exactness (with honest lossy degradation)                           |
+| `@openagentsinc/conformance-kit/event-log`      | `runEventLogLaws`              | `HarnessEventLogStore`           | append monotonicity / dup-free, gap-free replay from a cursor, durable replay after process death, rerun boundaries, live attach, single-flight attach |
+| `@openagentsinc/conformance-kit/reducer`        | `runReducerLaws`               | a progressive UI-message reducer | progressive fold, tool state machine, transient bypass, fail-loud-never-corrupt                                                                        |
+| `@openagentsinc/conformance-kit/recall`         | `runRecallLaws`                | a `HistoryRecall` Tier D source  | correctness anchor, caps truncate + report, `cost.modelCalls === 0`, coverage-note carry-through, typed invalid input                                  |
+| `@openagentsinc/conformance-kit/rlm`            | `runRlmCapLaws`                | the RLM engine + corpus source   | every cap → honest `Partial`, generous → `Completed`, no laundering, deterministic never touches a model                                               |
+| `@openagentsinc/conformance-kit/corpus`         | `runCorpusCompositionLaws`     | a constructor and projection     | identity, order, policy, scope, freshness, citations, duplicates, planes, coverage, exclusions, bounded access                                         |
+| `@openagentsinc/conformance-kit/graph-identity` | `runGraphIdentityLaws`         | graph builders                   | identity separation, deterministic rebuild, merge evidence, provenance                                                                                 |
+| `@openagentsinc/conformance-kit/graph-delete`   | `runGraphCapabilityDeleteLaws` | graph adapter and delete planner | typed capabilities, shared retention, all artifact planes, execution receipts                                                                          |
+| `@openagentsinc/conformance-kit/dse-extraction` | `runDseExtractionLaws`         | DSE graph extraction             | bounded extraction, receipts, inert prompt-injection text                                                                                              |
+| `@openagentsinc/conformance-kit/graph-rlm`      | `runGraphRlmLaws`              | graph RLM projection             | exact citations, policy, freshness, bounded operators                                                                                                  |
+| `@openagentsinc/conformance-kit/graph-ranking`  | `runGraphRankingLaws`          | graph ranker                     | isolation, deterministic order, degradation, evidence validation                                                                                       |
+| `@openagentsinc/conformance-kit/graph-archive`  | `runGraphArchiveLaws`          | archive codec                    | stable round trip, optional state, semantic corruption refusal                                                                                         |
+
+The `@openagentsinc/conformance-kit/graph-fixtures` subpath exports public-safe
+fixtures. The fixtures contain no credentials, private corpus text, or host
+authority.
 
 Everything is re-exported from the package root too
 (`@openagentsinc/conformance-kit`).

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@openagentsinc/conformance-kit",
-  "version": "0.2.0-rc.7",
+  "version": "0.2.1-rc.3",
   "private": false,
   "license": "Apache-2.0",
   "files": [
-    "src",
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
     "README.md"
   ],
   "type": "module",
@@ -16,6 +17,13 @@
     "./recall": "./src/recall-laws.ts",
     "./rlm": "./src/rlm-cap-laws.ts",
     "./corpus": "./src/corpus-composition-laws.ts",
+    "./graph-identity": "./src/graph-identity-laws.ts",
+    "./graph-delete": "./src/graph-capability-delete-laws.ts",
+    "./dse-extraction": "./src/dse-extraction-laws.ts",
+    "./graph-rlm": "./src/graph-rlm-laws.ts",
+    "./graph-ranking": "./src/graph-ranking-laws.ts",
+    "./graph-archive": "./src/graph-archive-laws.ts",
+    "./graph-fixtures": "./src/graph-fixtures.ts",
     "./fixtures": "./src/fixtures.ts"
   },
   "publishConfig": {
@@ -23,16 +31,22 @@
   },
   "dependencies": {
     "effect": "4.0.0-beta.94",
-    "@openagentsinc/agent-runtime-schema": "0.2.0-rc.7",
-    "@openagentsinc/agent-harness-contract": "0.2.0-rc.7",
-    "@openagentsinc/rlm": "0.2.0-rc.7",
-    "@openagentsinc/history-corpus": "0.2.0-rc.7"
+    "@openagentsinc/agent-harness-contract": "0.2.1-rc.3",
+    "@openagentsinc/agent-runtime-schema": "0.2.1-rc.3",
+    "@openagentsinc/history-corpus": "0.2.1-rc.3",
+    "@openagentsinc/dse": "0.2.1-rc.3",
+    "@openagentsinc/graph-corpus": "0.2.1-rc.3",
+    "@openagentsinc/rlm": "0.2.1-rc.3"
   },
   "devDependencies": {
     "@types/node": "24.13.1",
     "typescript": "^6.0.3",
+    "vite-plus": "0.2.4",
     "@types/vite-plus-matchers": "0.0.0"
   },
+  "peerDependencies": {
+    "vite-plus": ">=0.2.4 <1"
+  },
   "scripts": {
     "test": "vp test --run packages/conformance-kit/src",
     "typecheck": "tsc -p tsconfig.json --noEmit"

package/src/dse-extraction-laws.ts

@@ -0,0 +1,273 @@
+import { Effect, Schema as S } from "effect";
+import {
+  COMPILED_PROGRAM_SCHEMA_LITERAL,
+  CompiledProgram,
+  GRAPH_EXTRACTION_CORPUS_SCHEMA_ID,
+  GraphExtractionCorpus,
+  GraphExtractionLimits,
+  GraphExtractionError,
+  graphExtractionSignature,
+  type GraphExtractionCandidates,
+  type applyGraphExtractionCandidates,
+  type planGraphExtractionBatches,
+  type runDeterministicGraphExtraction,
+  type runGraphExtraction,
+  type validateGraphExtractionRunReceipt,
+  type GraphExtractionRuntimeDeps,
+} from "@openagentsinc/dse";
+import type { RlmSourceLocator } from "@openagentsinc/rlm/schemas";
+import { describe, expect, test } from "vite-plus/test";
+
+import { graphPromptInjectionFixture } from "./graph-fixtures.ts";
+
+export interface DseExtractionLawsConfig {
+  readonly label: string;
+  readonly planGraphExtractionBatches: typeof planGraphExtractionBatches;
+  readonly runGraphExtraction: typeof runGraphExtraction;
+  readonly runDeterministicGraphExtraction: typeof runDeterministicGraphExtraction;
+  readonly validateGraphExtractionRunReceipt: typeof validateGraphExtractionRunReceipt;
+  readonly applyGraphExtractionCandidates: typeof applyGraphExtractionCandidates;
+}
+
+const source = (entryKey: string): RlmSourceLocator => ({
+  sourcePlane: "repository",
+  sourceKind: "conformance_fixture",
+  sourceAddress: { addressSchemaId: "conformance.path.v1", encodedAddress: `src/${entryKey}.ts` },
+  corpusRef: "corpus.extraction.conformance",
+  contentDigest: "a".repeat(64) as RlmSourceLocator["contentDigest"],
+  entryRef: entryKey as RlmSourceLocator["entryRef"],
+});
+
+const corpus = S.decodeUnknownSync(GraphExtractionCorpus)({
+  schemaId: GRAPH_EXTRACTION_CORPUS_SCHEMA_ID,
+  corpusRef: "corpus.extraction.conformance",
+  contentDigest: "a".repeat(64),
+  manifestDigest: "b".repeat(64),
+  entries: [
+    { entryKey: "a", source: source("a"), text: graphPromptInjectionFixture },
+    { entryKey: "b", source: source("b"), text: "Alex builds portable agents." },
+  ],
+});
+
+const limits = S.decodeUnknownSync(GraphExtractionLimits)({
+  maxEntries: 10,
+  maxCharacters: 10_000,
+  maxInputTokens: 10_000,
+  maxOutputTokens: 10_000,
+  maxOutputCharacters: 20_000,
+  maxModelCalls: 10,
+  maxWallClockMs: 10_000,
+  maxConcurrency: 1,
+  maxEntriesPerBatch: 10,
+  maxCharactersPerBatch: 10_000,
+  maxInputTokensPerBatch: 10_000,
+});
+
+const candidates: GraphExtractionCandidates = {
+  mentions: [
+    {
+      candidateKey: "m1",
+      identityNamespace: "people",
+      canonicalKey: "alex:a",
+      supportEntryKey: "a",
+      confidence: 0.9,
+    },
+    {
+      candidateKey: "m2",
+      identityNamespace: "people",
+      canonicalKey: "alex:b",
+      supportEntryKey: "b",
+      confidence: 0.8,
+    },
+  ],
+  entities: [
+    {
+      candidateKey: "e1",
+      identityNamespace: "people",
+      canonicalKey: "alex",
+      mentionCandidateKeys: ["m1", "m2"],
+      confidence: 0.95,
+    },
+  ],
+  relations: [],
+  merges: [
+    {
+      candidateKey: "merge1",
+      entityCandidateKey: "e1",
+      mentionCandidateKeys: ["m1", "m2"],
+      confidence: 0.9,
+    },
+  ],
+};
+
+const deps = (): GraphExtractionRuntimeDeps => ({
+  countTokens: (text) => text.length,
+  monotonicMs: () => 0,
+  now: () => "2026-07-22T00:00:00Z",
+  assertCorpusUnchanged: () => Effect.succeed("freshness.conformance"),
+});
+
+/** Laws for bounded DSE graph extraction and application. */
+export const runDseExtractionLaws = (implementation: DseExtractionLawsConfig): void => {
+  describe(`[${implementation.label}] DSE graph extraction`, () => {
+    test("deterministic extraction is stable, receipted, and applicable", async () => {
+      const extractor = {
+        parserRef: "parser.conformance.v1",
+        parserVersion: "1.0.0",
+        extract: () => Effect.succeed(candidates),
+      };
+      const args = { corpus, extractor, limits, deps: deps() };
+      const left = await Effect.runPromise(implementation.runDeterministicGraphExtraction(args));
+      const right = await Effect.runPromise(implementation.runDeterministicGraphExtraction(args));
+      expect(right).toEqual(left);
+      expect(left.receipt).toMatchObject({ modelCalls: 0, concurrencyHighWaterMark: 0 });
+      await expect(
+        Effect.runPromise(
+          implementation.validateGraphExtractionRunReceipt(left.receipt, {
+            corpus,
+            limits,
+            countTokens: deps().countTokens,
+            assertCorpusUnchanged: deps().assertCorpusUnchanged,
+            result: left,
+          }),
+        ),
+      ).resolves.toBeUndefined();
+      const built = await Effect.runPromise(
+        implementation.applyGraphExtractionCandidates({
+          run: left,
+          execution: {
+            corpus,
+            limits,
+            countTokens: deps().countTokens,
+            assertCorpusUnchanged: deps().assertCorpusUnchanged,
+          },
+          graphRef: "graph.extraction.conformance",
+          scopeRef: "tenant.a",
+          policy: { includeVisibilities: ["private"], includeRedactionClasses: ["none"] },
+        }),
+      );
+      expect(built.snapshot).toMatchObject({
+        mentions: { length: 2 },
+        entities: { length: 1 },
+        merges: { length: 1 },
+      });
+    });
+
+    test("caps are named and partial output cannot be applied", async () => {
+      const capped = S.decodeUnknownSync(GraphExtractionLimits)({ ...limits, maxEntries: 1 });
+      const plan = implementation.planGraphExtractionBatches({
+        corpus,
+        limits: capped,
+        countTokens: deps().countTokens,
+      });
+      expect(plan.reasons).toContain("entry_cap");
+      const run = await Effect.runPromise(
+        implementation.runDeterministicGraphExtraction({
+          corpus,
+          extractor: {
+            parserRef: "parser.conformance.v1",
+            parserVersion: "1.0.0",
+            extract: () =>
+              Effect.succeed({ mentions: [], entities: [], relations: [], merges: [] }),
+          },
+          limits: capped,
+          deps: deps(),
+        }),
+      );
+      expect(run.status).toBe("Partial");
+      const error = await Effect.runPromise(
+        implementation
+          .applyGraphExtractionCandidates({
+            run,
+            execution: {
+              corpus,
+              limits: capped,
+              countTokens: deps().countTokens,
+              assertCorpusUnchanged: deps().assertCorpusUnchanged,
+            },
+            graphRef: "graph.extraction.partial",
+            scopeRef: "tenant.a",
+            policy: { includeVisibilities: ["private"], includeRedactionClasses: ["none"] },
+          })
+          .pipe(Effect.flip),
+      );
+      expect(error.reason).toBe("invalid_candidate");
+    });
+
+    test("prompt-injection text stays in the untrusted envelope", async () => {
+      const program = S.decodeUnknownSync(CompiledProgram)({
+        schema: COMPILED_PROGRAM_SCHEMA_LITERAL,
+        signatureId: graphExtractionSignature.signatureId,
+        promptIr: graphExtractionSignature.defaultPromptIr,
+        decodePolicy: { maxRepairs: 0, maxOutputChars: 20_000 },
+        modelRole: "graph_extractor",
+      });
+      const observed: string[] = [];
+      await Effect.runPromise(
+        implementation.runGraphExtraction({
+          corpus,
+          program,
+          model: {
+            complete: ({ message }) => {
+              observed.push(message.canonicalBytes);
+              return Effect.succeed({
+                text: JSON.stringify(candidates),
+                modelIdentity: "model.conformance.v1",
+                usage: { _tag: "Exact", inputTokens: 1, outputTokens: 1 },
+              });
+            },
+          },
+          limits,
+          deps: deps(),
+        }),
+      );
+      const envelope = JSON.parse(observed[0]!) as { trusted: unknown; untrustedContext: string };
+      expect(envelope.untrustedContext).toContain(graphPromptInjectionFixture);
+      expect(JSON.stringify(envelope.trusted)).not.toContain(graphPromptInjectionFixture);
+    });
+
+    test("a corpus that changes at an external-call boundary is refused", async () => {
+      const program = S.decodeUnknownSync(CompiledProgram)({
+        schema: COMPILED_PROGRAM_SCHEMA_LITERAL,
+        signatureId: graphExtractionSignature.signatureId,
+        promptIr: graphExtractionSignature.defaultPromptIr,
+        decodePolicy: { maxRepairs: 0, maxOutputChars: 20_000 },
+        modelRole: "graph_extractor",
+      });
+      let assertions = 0;
+      const changingDeps: GraphExtractionRuntimeDeps = {
+        ...deps(),
+        assertCorpusUnchanged: () => {
+          assertions += 1;
+          return assertions < 3
+            ? Effect.succeed("freshness.conformance")
+            : Effect.fail(
+                new GraphExtractionError({
+                  reason: "invalid_corpus",
+                  detailSafe: "The conformance corpus changed.",
+                }),
+              );
+        },
+      };
+      const result = await Effect.runPromise(
+        implementation.runGraphExtraction({
+          corpus,
+          program,
+          model: {
+            complete: () =>
+              Effect.succeed({
+                text: JSON.stringify(candidates),
+                modelIdentity: "model.conformance.v1",
+                usage: { _tag: "Exact", inputTokens: 1, outputTokens: 1 },
+              }),
+          },
+          limits,
+          deps: changingDeps,
+        }),
+      );
+      expect(result.status).toBe("Refused");
+      expect(result.batches).toEqual([]);
+      expect(result.receipt.reasons).toContain("invalid_corpus");
+    });
+  });
+};

package/src/graph-archive-laws.ts

@@ -0,0 +1,267 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema as S } from "effect";
+import {
+  GraphArchiveRef,
+  type GraphCorpusArchive,
+  type encodeGraphCorpusArchive,
+  type exportGraphCorpusArchive,
+  type importGraphCorpusArchive,
+} from "@openagentsinc/graph-corpus/archive";
+import {
+  canonicalJson,
+  GraphSummaryArtifact,
+  graphDigest,
+  sha256Hex,
+  type GraphDigest,
+  buildGraphCorpus,
+  makeGraphAdapterCapabilities,
+  makeGraphArtifactInventory,
+  makeGraphMention,
+} from "@openagentsinc/graph-corpus";
+import {
+  GRAPH_RANKING_ALGORITHM_VERSION,
+  GRAPH_RANKING_SNAPSHOT_SCHEMA_ID,
+  GraphRankingSnapshot,
+} from "@openagentsinc/graph-corpus/ranking";
+import { describe, expect, test } from "vite-plus/test";
+
+import {
+  graphArchiveCorruptionFixtures,
+  graphConformanceDerivation,
+  graphConformancePolicy,
+  graphConformanceSource,
+} from "./graph-fixtures.ts";
+
+export interface GraphArchiveLawsConfig {
+  readonly label: string;
+  readonly buildGraphCorpus: typeof buildGraphCorpus;
+  readonly makeGraphMention: typeof makeGraphMention;
+  readonly makeGraphAdapterCapabilities: typeof makeGraphAdapterCapabilities;
+  readonly makeGraphArtifactInventory: typeof makeGraphArtifactInventory;
+  readonly exportGraphCorpusArchive: typeof exportGraphCorpusArchive;
+  readonly encodeGraphCorpusArchive: typeof encodeGraphCorpusArchive;
+  readonly importGraphCorpusArchive: typeof importGraphCorpusArchive;
+}
+
+type Mutable<T> = T extends string | number | boolean | null | undefined
+  ? T
+  : T extends ReadonlyArray<infer U>
+    ? Mutable<U>[]
+    : T extends object
+      ? { -readonly [K in keyof T]: Mutable<T[K]> }
+      : T;
+const digest = (value: unknown): GraphDigest => graphDigest(sha256Hex(canonicalJson(value)));
+const bytesOf = (value: unknown): Uint8Array => new TextEncoder().encode(canonicalJson(value));
+const payloadDigest = (bytes: Uint8Array): GraphDigest =>
+  graphDigest(createHash("sha256").update(bytes).digest("hex"));
+const base64 = (bytes: Uint8Array): string =>
+  btoa(Array.from(bytes, (value) => String.fromCharCode(value)).join(""));
+const rehash = (value: GraphCorpusArchive | Mutable<GraphCorpusArchive>): GraphCorpusArchive => {
+  const archive = structuredClone(value) as unknown as Mutable<GraphCorpusArchive>;
+  const update = (section: { sectionDigest: GraphDigest; [key: string]: unknown }) => {
+    const { sectionDigest: _old, ...content } = section;
+    section.sectionDigest = digest(content);
+  };
+  update(archive.sections.graph);
+  update(archive.sections.nodes);
+  update(archive.sections.edges);
+  update(archive.sections.sourceMemberships);
+  update(archive.sections.mergeEvidence);
+  update(archive.sections.provenance);
+  update(archive.sections.descriptors);
+  if (archive.sections.vectors !== undefined) update(archive.sections.vectors);
+  if (archive.sections.summaries !== undefined) update(archive.sections.summaries);
+  if (archive.sections.ranking !== undefined) update(archive.sections.ranking);
+  if (archive.sections.contentExtension !== undefined) update(archive.sections.contentExtension);
+  archive.manifest.sectionDigests = {
+    graph: archive.sections.graph.sectionDigest,
+    nodes: archive.sections.nodes.sectionDigest,
+    edges: archive.sections.edges.sectionDigest,
+    sourceMemberships: archive.sections.sourceMemberships.sectionDigest,
+    mergeEvidence: archive.sections.mergeEvidence.sectionDigest,
+    provenance: archive.sections.provenance.sectionDigest,
+    descriptors: archive.sections.descriptors.sectionDigest,
+    ...(archive.sections.vectors === undefined
+      ? {}
+      : { vectors: archive.sections.vectors.sectionDigest }),
+    ...(archive.sections.summaries === undefined
+      ? {}
+      : { summaries: archive.sections.summaries.sectionDigest }),
+    ...(archive.sections.ranking === undefined
+      ? {}
+      : { ranking: archive.sections.ranking.sectionDigest }),
+    ...(archive.sections.contentExtension === undefined
+      ? {}
+      : { contentExtension: archive.sections.contentExtension.sectionDigest }),
+  };
+  archive.manifest.contentDigest = digest(archive.sections);
+  const {
+    manifestDigest: _manifestDigest,
+    archiveRef: _archiveRef,
+    ...manifestContent
+  } = archive.manifest;
+  archive.manifest.manifestDigest = digest(manifestContent);
+  archive.manifest.archiveRef = S.decodeUnknownSync(GraphArchiveRef)(
+    `archive.${sha256Hex(canonicalJson({ contentDigest: archive.manifest.contentDigest, manifestDigest: archive.manifest.manifestDigest }))}`,
+  );
+  return archive as unknown as GraphCorpusArchive;
+};
+
+/** Laws for canonical graph archive round trips and semantic corruption refusal. */
+export const runGraphArchiveLaws = (implementation: GraphArchiveLawsConfig): void => {
+  const fixture = async () => {
+    const mention = implementation.makeGraphMention({
+      identityNamespace: "archive",
+      canonicalKey: "alex",
+      identityScopeRef: "tenant.a",
+      source: graphConformanceSource("archive"),
+      derivation: graphConformanceDerivation,
+    });
+    const built = await Effect.runPromise(
+      implementation.buildGraphCorpus({
+        graphRef: "graph.archive.conformance",
+        scopeRef: "tenant.a",
+        policy: graphConformancePolicy,
+        mentions: [mention],
+        entities: [],
+        relations: [],
+      }),
+    );
+    const summaryBytes = new TextEncoder().encode("public conformance summary");
+    const summary = S.decodeUnknownSync(GraphSummaryArtifact)({
+      artifactKind: "summary",
+      artifactRef: "summary.conformance",
+      artifactDigest: payloadDigest(summaryBytes),
+      ownerElementRef: mention.elementRef,
+    });
+    const inventory = implementation.makeGraphArtifactInventory({
+      built,
+      vectors: [],
+      summaries: [summary],
+      rankingRefs: [],
+      coverage: {
+        vectors: { _tag: "Complete" },
+        summaries: { _tag: "Complete" },
+        rankingRefs: { _tag: "Complete" },
+      },
+    });
+    const rankingContent = {
+      schemaId: GRAPH_RANKING_SNAPSHOT_SCHEMA_ID,
+      graphRef: built.snapshot.graphRef,
+      scopeRef: built.snapshot.scopeRef,
+      graphDigest: built.snapshot.graphDigest,
+      manifestDigest: built.manifest.manifestDigest,
+      corpusRef: "corpus.archive.conformance",
+      contentDigest: "c".repeat(64),
+      corpusManifestDigest: "d".repeat(64),
+      classificationDigest: "e".repeat(64),
+      algorithmVersion: GRAPH_RANKING_ALGORITHM_VERSION,
+      feedbackObservations: [],
+      confidences: [],
+      features: [],
+    } as const;
+    const ranking = S.decodeUnknownSync(GraphRankingSnapshot)({
+      ...rankingContent,
+      snapshotRef: `ranking-snapshot.${sha256Hex(canonicalJson(rankingContent))}`,
+      snapshotDigest: digest(rankingContent),
+    });
+    return { built, inventory, ranking, summary, summaryBytes };
+  };
+
+  describe(`[${implementation.label}] graph archive`, () => {
+    test("graph, provenance, inventory, and ranking round-trip in stable inert bytes", async () => {
+      const value = await fixture();
+      const capabilities = implementation.makeGraphAdapterCapabilities(["snapshot_export"]);
+      const input = {
+        built: value.built,
+        capabilities,
+        artifactInventory: value.inventory,
+        summaryRecords: [
+          {
+            artifact: value.summary,
+            summarySchemaId: "summary.conformance.v1",
+            encoding: "utf8-base64" as const,
+            payloadBase64: base64(value.summaryBytes),
+            payloadDigest: payloadDigest(value.summaryBytes),
+            visibility: "private" as const,
+            redactionClass: "none" as const,
+          },
+        ],
+        rankingSnapshots: [value.ranking],
+      };
+      const left = await Effect.runPromise(implementation.encodeGraphCorpusArchive(input));
+      const right = await Effect.runPromise(implementation.encodeGraphCorpusArchive(input));
+      expect(right).toEqual(left);
+      const imported = await Effect.runPromise(implementation.importGraphCorpusArchive(left));
+      expect(imported.built).toEqual(value.built);
+      expect(imported.artifactInventory).toEqual(value.inventory);
+      expect(imported.rankingSnapshots).toEqual([value.ranking]);
+      expect(Object.isFrozen(imported)).toBe(true);
+      expect(Object.isFrozen(imported.archive)).toBe(true);
+      expect(Object.isFrozen(imported.archive.sections)).toBe(true);
+      expect(Object.isFrozen(imported.built.snapshot)).toBe(true);
+      expect(Object.isFrozen(imported.built.snapshot.mentions)).toBe(true);
+      expect(Object.isFrozen(imported.artifactInventory)).toBe(true);
+      expect(Object.isFrozen(imported.rankingSnapshots)).toBe(true);
+      expect(Object.isFrozen(imported.rankingSnapshots[0])).toBe(true);
+    });
+
+    test("semantic corruption reaches exact fail-closed reasons", async () => {
+      expect(graphArchiveCorruptionFixtures).toEqual(
+        expect.arrayContaining([
+          "changed_graph_identity",
+          "missing_provenance",
+          "unsupported_version",
+          "non_canonical_bytes",
+        ]),
+      );
+      const value = await fixture();
+      const capabilities = implementation.makeGraphAdapterCapabilities(["snapshot_export"]);
+      const archive = await Effect.runPromise(
+        implementation.exportGraphCorpusArchive({
+          built: value.built,
+          capabilities,
+          artifactInventory: value.inventory,
+          summaryRecords: [
+            {
+              artifact: value.summary,
+              summarySchemaId: "summary.conformance.v1",
+              encoding: "utf8-base64",
+              payloadBase64: base64(value.summaryBytes),
+              payloadDigest: payloadDigest(value.summaryBytes),
+              visibility: "private",
+              redactionClass: "none",
+            },
+          ],
+          rankingSnapshots: [value.ranking],
+        }),
+      );
+      const missing = structuredClone(archive) as unknown as Mutable<GraphCorpusArchive>;
+      missing.sections.provenance.entries.pop();
+      await expect(
+        Effect.runPromise(implementation.importGraphCorpusArchive(bytesOf(rehash(missing)))),
+      ).rejects.toMatchObject({
+        _tag: "GraphCorpus.ArchiveError",
+        reason: "stale_binding",
+      });
+      await expect(
+        Effect.runPromise(
+          implementation.importGraphCorpusArchive(
+            new TextEncoder().encode('{"manifest":{"formatVersion":2}}'),
+          ),
+        ),
+      ).rejects.toMatchObject({ reason: "unsupported_version" });
+      const canonical = bytesOf(archive);
+      await expect(
+        Effect.runPromise(
+          implementation.importGraphCorpusArchive(new Uint8Array([...canonical, 32])),
+        ),
+      ).rejects.toMatchObject({ reason: "non_canonical" });
+      const changed = structuredClone(archive) as unknown as Mutable<GraphCorpusArchive>;
+      changed.sections.graph.graphDigest = "f".repeat(64) as GraphDigest;
+      await expect(
+        Effect.runPromise(implementation.importGraphCorpusArchive(bytesOf(rehash(changed)))),
+      ).rejects.toMatchObject({ reason: "stale_binding" });
+    });
+  });
+};