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

package/src/graph-ranking-laws.ts

@@ -0,0 +1,362 @@
+import { Effect, Schema as S } from "effect";
+import { buildInlineCorpusInput, makeInlineCorpusHandle } from "@openagentsinc/rlm";
+import {
+  GraphDeleteRef,
+  type buildGraphCorpus,
+  type makeCanonicalEntity,
+  type makeGraphAdapterCapabilities,
+  type makeGraphMention,
+  type makeEmbeddingProjectionDescriptor,
+  type makeGraphRlmClassificationProjection,
+  type makeGraphRlmProjection,
+  type makeInMemoryGraphSnapshotHandle,
+} from "@openagentsinc/graph-corpus";
+import {
+  GRAPH_RANKING_OPERATION_BINDING_SCHEMA_ID,
+  GraphRankingOperationBinding,
+  type GraphRankingConfidence,
+  type makeGraphRankingSnapshot,
+  type makeGraphFeedbackObservation,
+  type rankGraphOperationResult,
+  type validateGraphUsedElementEvidence,
+  type validateGraphRankingSnapshot,
+} from "@openagentsinc/graph-corpus/ranking";
+import { describe, expect, test } from "vite-plus/test";
+
+import { graphConformanceDerivation, graphConformancePolicy } from "./graph-fixtures.ts";
+
+export interface GraphRankingLawsConfig {
+  readonly label: string;
+  readonly buildGraphCorpus: typeof buildGraphCorpus;
+  readonly makeGraphMention: typeof makeGraphMention;
+  readonly makeCanonicalEntity: typeof makeCanonicalEntity;
+  readonly makeEmbeddingProjectionDescriptor: typeof makeEmbeddingProjectionDescriptor;
+  readonly makeInMemoryGraphSnapshotHandle: typeof makeInMemoryGraphSnapshotHandle;
+  readonly makeGraphRlmClassificationProjection: typeof makeGraphRlmClassificationProjection;
+  readonly makeGraphAdapterCapabilities: typeof makeGraphAdapterCapabilities;
+  readonly makeGraphRlmProjection: typeof makeGraphRlmProjection;
+  readonly makeGraphRankingSnapshot: typeof makeGraphRankingSnapshot;
+  readonly makeGraphFeedbackObservation: typeof makeGraphFeedbackObservation;
+  readonly validateGraphRankingSnapshot: typeof validateGraphRankingSnapshot;
+  readonly rankGraphOperationResult: typeof rankGraphOperationResult;
+  readonly validateGraphUsedElementEvidence: typeof validateGraphUsedElementEvidence;
+}
+
+/** Laws for deterministic ranking that cannot mutate graph identity. */
+export const runGraphRankingLaws = (implementation: GraphRankingLawsConfig): void => {
+  const fixture = async () => {
+    const original = await Effect.runPromise(
+      makeInlineCorpusHandle(
+        buildInlineCorpusInput({
+          corpusRef: "corpus.ranking.conformance",
+          scopeRef: "tenant.a",
+          policy: graphConformancePolicy,
+          entries: ["a", "b"].map((entryRef) => ({
+            entryRef,
+            scopeRef: "tenant.a",
+            sourcePlane: "repository" as const,
+            sourceKind: "conformance_fixture",
+            sourceAddress: {
+              addressSchemaId: "conformance.path.v1",
+              encodedAddress: `fixture:${entryRef}`,
+            },
+            text: `source ${entryRef}`,
+            visibility: "private" as const,
+            redactionClass: "none" as const,
+          })),
+        }),
+      ),
+    );
+    const sources = await Promise.all(
+      ["a", "b"].map((entryRef) =>
+        Effect.runPromise(
+          original
+            .validateSourceAddress({
+              addressSchemaId: "conformance.path.v1",
+              encodedAddress: `fixture:${entryRef}`,
+            })
+            .pipe(Effect.map(({ origin }) => origin)),
+        ),
+      ),
+    );
+    const mentions = sources.map((source, index) =>
+      implementation.makeGraphMention({
+        identityNamespace: "people",
+        canonicalKey: `alex:${index}`,
+        identityScopeRef: "tenant.a",
+        source,
+        derivation: graphConformanceDerivation,
+      }),
+    );
+    const entity = implementation.makeCanonicalEntity({
+      identityNamespace: "people",
+      canonicalKey: "alex",
+      identityScopeRef: "tenant.a",
+      mentions,
+      derivation: graphConformanceDerivation,
+    });
+    const descriptor = implementation.makeEmbeddingProjectionDescriptor({
+      projectionSchemaId: "graph.embedding.conformance.v1",
+      elementKinds: ["mention", "entity"],
+      embeddableFields: ["identity.canonicalKey"],
+      dimensions: 2,
+    });
+    const built = await Effect.runPromise(
+      implementation.buildGraphCorpus({
+        graphRef: "graph.ranking.conformance",
+        scopeRef: "tenant.a",
+        policy: graphConformancePolicy,
+        mentions,
+        entities: [entity],
+        relations: [],
+        embeddingProjections: [descriptor],
+      }),
+    );
+    const handle = await Effect.runPromise(implementation.makeInMemoryGraphSnapshotHandle(built));
+    const classification = implementation.makeGraphRlmClassificationProjection(
+      handle,
+      [...mentions, entity].map(({ elementRef }) => ({
+        elementRef,
+        visibility: "private" as const,
+        redactionClass: "none" as const,
+      })),
+      [original],
+    );
+    const projection = await Effect.runPromise(
+      implementation.makeGraphRlmProjection({
+        handle,
+        capabilities: implementation.makeGraphAdapterCapabilities([
+          "graph_read",
+          "rlm_v2_projection",
+        ]),
+        classification,
+        corpusRef: "rlm.ranking.conformance",
+        supportingCorpora: [original],
+      }),
+    );
+    const limits = {
+      maxDepth: 2,
+      maxVisitedElements: 10,
+      maxReturnedElements: 10,
+      maxSourceAddresses: 10,
+      maxCharactersPerResult: 2_048,
+      maxObservationCharacters: 10_000,
+    };
+    const result = await Effect.runPromise(
+      projection.operators.neighbors(entity.elementRef, limits),
+    );
+    if (result._tag !== "Complete")
+      throw new Error("The ranking conformance fixture must complete.");
+    const binding = S.decodeUnknownSync(GraphRankingOperationBinding)({
+      schemaId: GRAPH_RANKING_OPERATION_BINDING_SCHEMA_ID,
+      _tag: "Neighbors",
+      elementRef: entity.elementRef,
+    });
+    return { built, projection, result, binding, mentions, entity, descriptor, limits };
+  };
+
+  const confidence = (
+    value: Awaited<ReturnType<typeof fixture>>,
+    elementRef: GraphRankingConfidence["elementRef"],
+    confidenceMicros: number,
+  ): GraphRankingConfidence => ({
+    graphRef: value.built.snapshot.graphRef,
+    scopeRef: value.built.snapshot.scopeRef,
+    graphDigest: value.result.graphDigest,
+    manifestDigest: value.result.manifestDigest,
+    corpusRef: value.result.corpusRef,
+    contentDigest: value.result.contentDigest,
+    corpusManifestDigest: value.result.corpusManifestDigest,
+    classificationDigest: value.result.classificationDigest,
+    elementRef,
+    confidenceMicros,
+    evidenceRef: S.decodeUnknownSync(GraphDeleteRef)(`evidence.${elementRef}`),
+  });
+
+  describe(`[${implementation.label}] graph ranking`, () => {
+    test("equal graph and ranking inputs produce deterministic order and evidence", async () => {
+      const value = await fixture();
+      const context = {
+        built: value.built,
+        projection: value.projection,
+        result: value.result,
+        expectedOperationDigest: value.result.operationDigest,
+        binding: value.binding,
+      };
+      const inputs = {
+        ...context,
+        confidences: [
+          confidence(value, value.mentions[0]!.elementRef, 900_000),
+          confidence(value, value.mentions[1]!.elementRef, 100_000),
+        ],
+      };
+      const left = await Effect.runPromise(implementation.makeGraphRankingSnapshot(inputs));
+      const right = await Effect.runPromise(implementation.makeGraphRankingSnapshot(inputs));
+      expect(right).toEqual(left);
+      const ranked = await Effect.runPromise(
+        implementation.rankGraphOperationResult({ ...context, snapshot: left }),
+      );
+      expect(ranked._tag).toBe("Ranked");
+      expect(ranked.evidence.rankingSnapshotDigest).toBe(left.snapshotDigest);
+      expect(ranked.observations[0]?.elementRef).toBe(value.mentions[0]?.elementRef);
+    });
+
+    test("ranking-only changes leave graph and manifest bytes unchanged", async () => {
+      const value = await fixture();
+      const graphBefore = structuredClone(value.built);
+      const resultBefore = structuredClone(value.result);
+      const context = {
+        built: value.built,
+        projection: value.projection,
+        result: value.result,
+        expectedOperationDigest: value.result.operationDigest,
+        binding: value.binding,
+      };
+      const highA = await Effect.runPromise(
+        implementation.makeGraphRankingSnapshot({
+          ...context,
+          confidences: [confidence(value, value.mentions[0]!.elementRef, 900_000)],
+        }),
+      );
+      const highB = await Effect.runPromise(
+        implementation.makeGraphRankingSnapshot({
+          ...context,
+          confidences: [confidence(value, value.mentions[1]!.elementRef, 900_000)],
+        }),
+      );
+      expect(highB.snapshotDigest).not.toBe(highA.snapshotDigest);
+      const rankedA = await Effect.runPromise(
+        implementation.rankGraphOperationResult({ ...context, snapshot: highA }),
+      );
+      const rankedB = await Effect.runPromise(
+        implementation.rankGraphOperationResult({ ...context, snapshot: highB }),
+      );
+      expect(rankedA.observations.map(({ elementRef }) => elementRef)).not.toEqual(
+        rankedB.observations.map(({ elementRef }) => elementRef),
+      );
+      expect(value.built).toEqual(graphBefore);
+      expect(value.built.snapshot.graphDigest).toBe(graphBefore.snapshot.graphDigest);
+      expect(value.built.manifest.manifestDigest).toBe(graphBefore.manifest.manifestDigest);
+      expect(value.built.snapshot.embeddingProjections).toEqual([value.descriptor]);
+      expect(value.result).toEqual(resultBefore);
+    });
+
+    test("disabled and truncated ranking is explicit and never drops observations", async () => {
+      const value = await fixture();
+      const context = {
+        built: value.built,
+        projection: value.projection,
+        result: value.result,
+        expectedOperationDigest: value.result.operationDigest,
+        binding: value.binding,
+      };
+      const unranked = await Effect.runPromise(implementation.rankGraphOperationResult(context));
+      expect(unranked).toMatchObject({ _tag: "Unranked", disabledReason: "ranking_disabled" });
+      expect(unranked.observations).toEqual(value.result.observations);
+      const truncated = await Effect.runPromise(
+        value.projection.operators.neighbors(value.entity.elementRef, {
+          ...value.limits,
+          maxReturnedElements: 1,
+        }),
+      );
+      expect(truncated._tag).toBe("Truncated");
+      const truncatedOutcome = await Effect.runPromise(
+        implementation.rankGraphOperationResult({
+          ...context,
+          result: truncated,
+          expectedOperationDigest: truncated.operationDigest,
+        }),
+      );
+      expect(truncatedOutcome).toMatchObject({
+        _tag: "Unranked",
+        disabledReason: "operation_truncated",
+      });
+      expect(truncatedOutcome.observations).toEqual(truncated.observations);
+    });
+
+    test("missing features degrade without dropping data and evidence substitution fails", async () => {
+      const value = await fixture();
+      const context = {
+        built: value.built,
+        projection: value.projection,
+        result: value.result,
+        expectedOperationDigest: value.result.operationDigest,
+        binding: value.binding,
+      };
+      const snapshot = await Effect.runPromise(
+        implementation.makeGraphRankingSnapshot({
+          ...context,
+          confidences: [confidence(value, value.mentions[0]!.elementRef, 900_000)],
+        }),
+      );
+      const outcome = await Effect.runPromise(
+        implementation.rankGraphOperationResult({ ...context, snapshot }),
+      );
+      expect(outcome.observations).toHaveLength(value.result.observations.length);
+      expect(outcome.missingFeatureElementRefs.length).toBeGreaterThan(0);
+      const changed = {
+        ...outcome.evidence,
+        evidenceDigest: "f".repeat(64),
+      } as typeof outcome.evidence;
+      const error = await Effect.runPromise(
+        implementation
+          .validateGraphUsedElementEvidence(changed, { ...context, snapshot })
+          .pipe(Effect.flip),
+      );
+      expect(error).toMatchObject({
+        _tag: "GraphCorpus.RankingError",
+        reason: "invalid_evidence",
+      });
+    });
+
+    test("feedback for an unknown element is rejected exactly", async () => {
+      const value = await fixture();
+      const error = await Effect.runPromise(
+        implementation
+          .makeGraphFeedbackObservation({
+            built: value.built,
+            projection: value.projection,
+            result: value.result,
+            expectedOperationDigest: value.result.operationDigest,
+            binding: value.binding,
+            elementRef: "graph.element.unknown",
+            feedbackWeightMicros: 1,
+            evidenceRef: "evidence.unknown",
+          })
+          .pipe(Effect.flip),
+      );
+      expect(error).toMatchObject({
+        _tag: "GraphCorpus.RankingError",
+        reason: "unknown_element",
+      });
+    });
+
+    test("a snapshot bound to another graph fails with stale_graph", async () => {
+      const value = await fixture();
+      const context = {
+        built: value.built,
+        projection: value.projection,
+        result: value.result,
+        expectedOperationDigest: value.result.operationDigest,
+        binding: value.binding,
+      };
+      const snapshot = await Effect.runPromise(implementation.makeGraphRankingSnapshot(context));
+      const changed = await Effect.runPromise(
+        implementation.buildGraphCorpus({
+          graphRef: "graph.ranking.other",
+          scopeRef: value.built.snapshot.scopeRef,
+          policy: value.built.snapshot.policy,
+          mentions: value.built.snapshot.mentions,
+          entities: value.built.snapshot.entities,
+          relations: value.built.snapshot.relations,
+        }),
+      );
+      const error = await Effect.runPromise(
+        implementation
+          .validateGraphRankingSnapshot(snapshot, { ...context, built: changed })
+          .pipe(Effect.flip),
+      );
+      expect(error.reason).toBe("stale_graph");
+    });
+  });
+};

package/src/graph-rlm-laws.ts

@@ -0,0 +1,243 @@
+import { Effect } from "effect";
+import {
+  buildInlineCorpusInput,
+  citationFromEntry,
+  makeInlineCorpusHandle,
+  validateCitations,
+  RlmCorpusError,
+} from "@openagentsinc/rlm";
+import type {
+  buildGraphCorpus,
+  makeGraphAdapterCapabilities,
+  makeGraphMention,
+  makeGraphRlmClassificationProjection,
+  makeGraphRlmProjection,
+  makeInMemoryGraphSnapshotHandle,
+} from "@openagentsinc/graph-corpus";
+import { describe, expect, test } from "vite-plus/test";
+
+import { graphConformanceDerivation, graphConformancePolicy } from "./graph-fixtures.ts";
+
+export interface GraphRlmLawsConfig {
+  readonly label: string;
+  readonly buildGraphCorpus: typeof buildGraphCorpus;
+  readonly makeGraphMention: typeof makeGraphMention;
+  readonly makeInMemoryGraphSnapshotHandle: typeof makeInMemoryGraphSnapshotHandle;
+  readonly makeGraphRlmClassificationProjection: typeof makeGraphRlmClassificationProjection;
+  readonly makeGraphAdapterCapabilities: typeof makeGraphAdapterCapabilities;
+  readonly makeGraphRlmProjection: typeof makeGraphRlmProjection;
+}
+
+const limits = {
+  maxDepth: 2,
+  maxVisitedElements: 10,
+  maxReturnedElements: 10,
+  maxSourceAddresses: 10,
+  maxCharactersPerResult: 2_048,
+  maxObservationCharacters: 10_000,
+} as const;
+
+/** Laws for graph-to-RLM projection, exact citations, freshness, and bounds. */
+export const runGraphRlmLaws = (implementation: GraphRlmLawsConfig): void => {
+  const fixture = async () => {
+    const original = await Effect.runPromise(
+      makeInlineCorpusHandle(
+        buildInlineCorpusInput({
+          corpusRef: "corpus.graph-rlm.conformance",
+          scopeRef: "tenant.a",
+          policy: graphConformancePolicy,
+          entries: ["a", "b"].map((entryRef) => ({
+            entryRef,
+            scopeRef: "tenant.a",
+            sourcePlane: "repository",
+            sourceKind: "conformance_fixture",
+            sourceAddress: {
+              addressSchemaId: "conformance.path.v1",
+              encodedAddress: `fixture:${entryRef}`,
+            },
+            text: `Alex source ${entryRef}.`,
+            visibility: "private",
+            redactionClass: "none",
+          })),
+        }),
+      ),
+    );
+    const sources = await Promise.all(
+      ["a", "b"].map((entryRef) =>
+        Effect.runPromise(
+          original
+            .validateSourceAddress({
+              addressSchemaId: "conformance.path.v1",
+              encodedAddress: `fixture:${entryRef}`,
+            })
+            .pipe(Effect.map(({ origin }) => origin)),
+        ),
+      ),
+    );
+    const mentions = sources.map((source, index) =>
+      implementation.makeGraphMention({
+        identityNamespace: "people",
+        canonicalKey: `alex:${index}`,
+        identityScopeRef: "tenant.a",
+        source,
+        derivation: graphConformanceDerivation,
+      }),
+    );
+    const mention = mentions[0]!;
+    const built = await Effect.runPromise(
+      implementation.buildGraphCorpus({
+        graphRef: "graph.rlm.conformance",
+        scopeRef: "tenant.a",
+        policy: graphConformancePolicy,
+        mentions,
+        entities: [],
+        relations: [],
+      }),
+    );
+    const handle = await Effect.runPromise(implementation.makeInMemoryGraphSnapshotHandle(built));
+    const classification = implementation.makeGraphRlmClassificationProjection(
+      handle,
+      mentions.map(({ elementRef }) => ({
+        elementRef,
+        visibility: "private" as const,
+        redactionClass: "none" as const,
+      })),
+      [original],
+    );
+    return { original, source: sources[0]!, mention, mentions, built, handle, classification };
+  };
+
+  describe(`[${implementation.label}] graph RLM`, () => {
+    test("projection preserves exact source citations and bounded lookup", async () => {
+      const value = await fixture();
+      const projection = await Effect.runPromise(
+        implementation.makeGraphRlmProjection({
+          handle: value.handle,
+          capabilities: implementation.makeGraphAdapterCapabilities([
+            "graph_read",
+            "rlm_v2_projection",
+          ]),
+          classification: value.classification,
+          corpusRef: "rlm.graph.conformance",
+          supportingCorpora: [value.original],
+        }),
+      );
+      const entries = await Effect.runPromise(projection.corpus.materializeAll());
+      expect(entries).toHaveLength(2);
+      expect(entries[0]?.supportingSources).toEqual([value.source]);
+      const citation = citationFromEntry(projection.corpus, entries[0]!);
+      expect(
+        (await Effect.runPromise(validateCitations(projection.corpus, [citation]))).invalid,
+      ).toEqual([]);
+      const result = await Effect.runPromise(
+        projection.operators.lookup(value.mention.elementRef, limits),
+      );
+      expect(result).toMatchObject({ _tag: "Complete", visitedElements: 1 });
+      const capped = await Effect.runPromise(
+        projection.operators.searchText("alex", { ...limits, maxReturnedElements: 1 }),
+      );
+      expect(capped).toMatchObject({ _tag: "Truncated", hitCaps: ["max_returned_elements"] });
+    });
+
+    test("missing capability and stale classification fail closed", async () => {
+      const value = await fixture();
+      const unsupported = await Effect.runPromise(
+        implementation
+          .makeGraphRlmProjection({
+            handle: value.handle,
+            capabilities: implementation.makeGraphAdapterCapabilities(["graph_read"]),
+            classification: value.classification,
+            corpusRef: "rlm.graph.unsupported",
+            supportingCorpora: [value.original],
+          })
+          .pipe(Effect.flip),
+      );
+      expect(unsupported).toMatchObject({
+        reason: "unsupported_operation",
+        capability: "rlm_v2_projection",
+      });
+      const incomplete = implementation.makeGraphRlmClassificationProjection(
+        value.handle,
+        [],
+        [value.original],
+      );
+      const stale = await Effect.runPromise(
+        implementation
+          .makeGraphRlmProjection({
+            handle: value.handle,
+            capabilities: implementation.makeGraphAdapterCapabilities([
+              "graph_read",
+              "rlm_v2_projection",
+            ]),
+            classification: incomplete,
+            corpusRef: "rlm.graph.stale",
+            supportingCorpora: [value.original],
+          })
+          .pipe(Effect.flip),
+      );
+      expect(stale).toMatchObject({ _tag: "GraphCorpus.RlmError", reason: "invalid_projection" });
+
+      const widened = implementation.makeGraphRlmClassificationProjection(
+        value.handle,
+        [{ elementRef: value.mention.elementRef, visibility: "public", redactionClass: "none" }],
+        [value.original],
+      );
+      const policyError = await Effect.runPromise(
+        implementation
+          .makeGraphRlmProjection({
+            handle: value.handle,
+            capabilities: implementation.makeGraphAdapterCapabilities([
+              "graph_read",
+              "rlm_v2_projection",
+            ]),
+            classification: widened,
+            corpusRef: "rlm.graph.policy-widened",
+            supportingCorpora: [value.original],
+          })
+          .pipe(Effect.flip),
+      );
+      expect(policyError.reason).toBe("invalid_projection");
+    });
+
+    test("a supporting corpus that changes after construction fails closed", async () => {
+      const value = await fixture();
+      let changed = false;
+      const supporting = {
+        ...value.original,
+        assertUnchanged: () =>
+          changed
+            ? Effect.fail(new RlmCorpusError({ reason: "changed" }))
+            : value.original.assertUnchanged(),
+      };
+      const classification = implementation.makeGraphRlmClassificationProjection(
+        value.handle,
+        value.mentions.map(({ elementRef }) => ({
+          elementRef,
+          visibility: "private" as const,
+          redactionClass: "none" as const,
+        })),
+        [supporting],
+      );
+      const projection = await Effect.runPromise(
+        implementation.makeGraphRlmProjection({
+          handle: value.handle,
+          capabilities: implementation.makeGraphAdapterCapabilities([
+            "graph_read",
+            "rlm_v2_projection",
+          ]),
+          classification,
+          corpusRef: "rlm.graph.changing",
+          supportingCorpora: [supporting],
+        }),
+      );
+      changed = true;
+      const error = await Effect.runPromise(
+        projection.operators.lookup(value.mention.elementRef, limits).pipe(Effect.flip),
+      );
+      expect(error).toMatchObject({
+        _tag: "GraphCorpus.RlmError",
+        reason: "projection_changed",
+      });
+    });
+  });
+};

package/src/index.ts

@@ -17,6 +17,22 @@ export {
   runCorpusCompositionLaws,
   type CorpusCompositionLawsConfig,
 } from "./corpus-composition-laws.ts";
+export { runGraphIdentityLaws, type GraphIdentityLawsConfig } from "./graph-identity-laws.ts";
+export {
+  runGraphCapabilityDeleteLaws,
+  type GraphCapabilityDeleteLawsConfig,
+} from "./graph-capability-delete-laws.ts";
+export { runDseExtractionLaws, type DseExtractionLawsConfig } from "./dse-extraction-laws.ts";
+export { runGraphRlmLaws, type GraphRlmLawsConfig } from "./graph-rlm-laws.ts";
+export { runGraphRankingLaws, type GraphRankingLawsConfig } from "./graph-ranking-laws.ts";
+export { runGraphArchiveLaws, type GraphArchiveLawsConfig } from "./graph-archive-laws.ts";
+export {
+  graphArchiveCorruptionFixtures,
+  graphConformanceDerivation,
+  graphConformancePolicy,
+  graphConformanceSource,
+  graphPromptInjectionFixture,
+} from "./graph-fixtures.ts";
 export {
   assertContiguous,
   attempt,

package/src/adapter-laws.test.ts

@@ -1,36 +0,0 @@
-import { Effect } from "effect";
-import { makeReferenceAdapter } from "@openagentsinc/agent-harness-contract";
-
-import { runAdapterLaws } from "./adapter-laws.ts";
-
-// The kit run against the in-repo reference adapter proves the kit itself
-// works — a lossless suspend/continue adapter that supports every verb.
-runAdapterLaws({
-  label: "reference-adapter",
-  makeHarness: () => Effect.sync(() => makeReferenceAdapter({ scriptWords: ["a", "b", "c"] })),
-});
-
-// A lossy-continue variant exercises the honest-degradation branch of the
-// suspend/continue law.
-runAdapterLaws({
-  label: "reference-adapter (lossy continue)",
-  makeHarness: () =>
-    Effect.sync(() =>
-      makeReferenceAdapter({ scriptWords: ["a", "b", "c"], continueIsLossy: true }),
-    ),
-});
-
-// A verb-refusing variant exercises the fail-closed capability branch: compact,
-// detach, and suspend must each fail with a named CapabilityUnsupported error.
-runAdapterLaws({
-  label: "reference-adapter (refuses compact/detach/suspend)",
-  makeHarness: () =>
-    Effect.sync(() =>
-      makeReferenceAdapter({
-        scriptWords: ["a", "b", "c"],
-        supportsCompact: false,
-        supportsDetach: false,
-        supportsSuspend: false,
-      }),
-    ),
-});

package/src/corpus-composition-laws.test.ts

@@ -1,9 +0,0 @@
-import { buildInMemoryCompositeProjection, makeCompositeCorpusHandle } from "@openagentsinc/rlm";
-
-import { runCorpusCompositionLaws } from "./corpus-composition-laws.ts";
-
-runCorpusCompositionLaws({
-  label: "reference",
-  compose: makeCompositeCorpusHandle,
-  makeProjection: buildInMemoryCompositeProjection,
-});

package/src/event-log-laws.test.ts

@@ -1,10 +0,0 @@
-import { Effect } from "effect";
-import { makeInMemoryEventLogStore } from "@openagentsinc/agent-harness-contract";
-
-import { runEventLogLaws } from "./event-log-laws.ts";
-
-// The kit run against the in-repo reference store proves the kit itself works.
-runEventLogLaws({
-  label: "in-memory-store",
-  makeStore: () => Effect.sync(() => makeInMemoryEventLogStore()),
-});

package/src/recall-laws.test.ts

@@ -1,10 +0,0 @@
-import { recallTierD } from "@openagentsinc/history-corpus";
-
-import { runRecallLaws } from "./recall-laws.ts";
-
-// The kit run against the in-repo reference recall backend (Tier D) proves the
-// kit itself works.
-runRecallLaws({
-  label: "recall-tier-d",
-  recall: (params) => recallTierD(params),
-});