@openagentsinc/conformance-kit 0.2.0-rc.2

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 OpenAgents, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,111 @@
+# @openagentsinc/conformance-kit
+
+Published law suites for the `@openagentsinc/ai` contracts. This package
+promotes the per-package test suites that already encode the SDK's laws into
+one reusable kit. Point a suite at an implementation under test — an adapter, a
+store, a reducer, a recall source, or the RLM engine — and it either passes the
+kit or it is not conformant.
+
+This is Phase 1 item 1 of `docs/ROADMAP.md` (issue #15, parent epic #14):
+conformance as product.
+
+## The idea
+
+Each law suite is one exported function. You call it inside your own test file,
+parameterized over your implementation. The suite registers the `describe` /
+`test` blocks against the same `vite-plus/test` runner your package already
+uses, so a conformance run is just part of your normal test sweep.
+
+The kit's own tests run every suite against the in-repo reference
+implementations (the reference adapter, the in-memory event-log store, the
+UI-message reducer, the Tier D recall backend, and the RLM engine), so the kit
+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                                               |
+
+Everything is re-exported from the package root too
+(`@openagentsinc/conformance-kit`).
+
+## Run the kit against your adapter
+
+Add the kit as a dev dependency, then write a test file that calls the runner:
+
+```ts
+// my-adapter.conformance.test.ts
+import { Effect } from "effect";
+import { runAdapterLaws } from "@openagentsinc/conformance-kit/adapter";
+
+import { makeMyAdapter } from "./my-adapter.ts";
+
+runAdapterLaws({
+  label: "my-adapter",
+  makeHarness: () => Effect.sync(() => makeMyAdapter()),
+});
+```
+
+That single call registers the full reference-adapter law suite against your
+adapter. The laws are content-agnostic: the kit starts the session and drives
+the turn itself, so they hold whatever your runtime emits. An adapter that
+cannot suspend a turn still passes — the suite proves the refusal is a typed,
+named `HarnessCapabilityUnsupported`, not a silent success.
+
+## Run the kit against your store
+
+```ts
+import { Effect } from "effect";
+import { runEventLogLaws } from "@openagentsinc/conformance-kit/event-log";
+
+import { makeMyStore } from "./my-store.ts";
+
+runEventLogLaws({
+  label: "my-store",
+  makeStore: () => Effect.sync(() => makeMyStore()),
+});
+```
+
+The kit builds the `HarnessEventLog` runtime over your store, so satisfying the
+`HarnessEventLogStore` port earns both the store-level and the live-attach and
+single-flight laws.
+
+## Run the kit against the recall and RLM engines
+
+```ts
+import { runRecallLaws } from "@openagentsinc/conformance-kit/recall";
+import { runRlmCapLaws } from "@openagentsinc/conformance-kit/rlm";
+import { recallTierD } from "@openagentsinc/history-corpus";
+import { makeRlm, rlmInlineCorpusSourceLayer } from "@openagentsinc/rlm";
+
+runRecallLaws({ label: "my-recall", recall: (params) => recallTierD(params) });
+
+runRlmCapLaws({
+  label: "my-rlm",
+  makeEngine: makeRlm,
+  corpusSourceLayer: rlmInlineCorpusSourceLayer,
+});
+```
+
+The kit owns the corpus fixtures (a deep planted-decision corpus for recall, a
+small four-entry corpus for RLM), so a recall or RLM implementation only has to
+answer honestly.
+
+## What "conformant" means
+
+The laws are the honesty contract, not just the happy path:
+
+- An adapter must never present a lossy re-drive as an exact cursor attach.
+- A store must reject a non-increasing sequence so replay stays duplicate-free.
+- A reducer must throw its tagged error on a malformed sequence rather than
+  silently corrupt the message.
+- A recall source must report exactly what it scanned, which caps it hit, and
+  the corpus coverage bound — and never fabricate a model call behind a
+  deterministic answer.
+- The RLM engine must surface every cap that bites as an honest `Partial`,
+  never as a `Completed` result that quietly dropped work.

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@openagentsinc/conformance-kit",
+  "version": "0.2.0-rc.2",
+  "private": false,
+  "license": "Apache-2.0",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./adapter": "./src/adapter-laws.ts",
+    "./event-log": "./src/event-log-laws.ts",
+    "./reducer": "./src/reducer-laws.ts",
+    "./recall": "./src/recall-laws.ts",
+    "./rlm": "./src/rlm-cap-laws.ts",
+    "./fixtures": "./src/fixtures.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "effect": "4.0.0-beta.94",
+    "@openagentsinc/agent-runtime-schema": "0.2.0-rc.2",
+    "@openagentsinc/rlm": "0.2.0-rc.2",
+    "@openagentsinc/history-corpus": "0.2.0-rc.2",
+    "@openagentsinc/agent-harness-contract": "0.2.0-rc.2"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.1",
+    "typescript": "^6.0.3",
+    "@types/vite-plus-matchers": "0.0.0"
+  },
+  "scripts": {
+    "test": "vp test --run packages/conformance-kit/src",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/adapter-laws.test.ts

@@ -0,0 +1,36 @@
+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/adapter-laws.ts

@@ -0,0 +1,184 @@
+import { Effect, Stream } from "effect";
+import {
+  type AgentHarness,
+  HarnessCapabilityUnsupported,
+  type HarnessSession,
+} from "@openagentsinc/agent-harness-contract";
+import type { KhalaRuntimeSource } from "@openagentsinc/agent-runtime-schema";
+import { describe, expect, test } from "vite-plus/test";
+
+import { attempt, collect, sequencesOf, TEST_SOURCE } from "./fixtures.ts";
+
+/**
+ * Configuration for {@link runAdapterLaws}. The implementation under test is a
+ * factory that produces a fresh {@link AgentHarness}; the kit starts the
+ * sessions and drives the turns itself, so the laws are content-agnostic and
+ * hold for any conforming adapter (the in-repo reference adapter, Codex,
+ * Claude Code, an ACP peer, a third-party runtime).
+ */
+export interface AdapterLawsConfig {
+  /** A short label naming the implementation under test, used in test titles. */
+  readonly label: string;
+  /** Produce a fresh harness. Called once per law so laws never share state. */
+  readonly makeHarness: () => Effect.Effect<AgentHarness>;
+  /** The prompt driven through each turn. Defaults to a neutral fixture prompt. */
+  readonly prompt?: string;
+  /** The event source label. Defaults to the shared `test_fixture` source. */
+  readonly source?: KhalaRuntimeSource;
+  /**
+   * How many events to pull before the suspend/continue law suspends the turn.
+   * Defaults to 2, enough to prove a mid-turn cursor is exact.
+   */
+  readonly prefixTake?: number;
+}
+
+/**
+ * The reference-adapter session-verb laws, parameterized over any adapter.
+ *
+ * These are the promoted, published form of
+ * `agent-harness-contract/src/reference-adapter.test.ts`. A third-party adapter
+ * either passes these or it is not conformant:
+ *
+ * 1. **Turn framing.** A full turn streams `turn.started` first and
+ *    `turn.finished` last, with session-global sequences contiguous from 0 and
+ *    no duplicate; the turn result's `lastCursor` is exactly the last event's
+ *    sequence.
+ * 2. **Capability refusal is fail-closed and named.** An optional verb an
+ *    adapter cannot satisfy fails with a typed
+ *    {@link HarnessCapabilityUnsupported} naming the exact missing capability —
+ *    never a silent success and never an untyped defect.
+ * 3. **Suspend/continue cursor exactness.** When an adapter supports
+ *    suspend+continue losslessly, the continuation cursor is exactly the last
+ *    event delivered before the suspend, and the continued slice attaches at
+ *    `cursor + 1` with no gap and no duplicate. When the adapter reports the
+ *    continuation as lossy, the degradation is honestly flagged rather than
+ *    presented as an exact attach.
+ */
+export const runAdapterLaws = (config: AdapterLawsConfig): void => {
+  const { label, makeHarness } = config;
+  const prompt = config.prompt ?? "hello";
+  const source = config.source ?? TEST_SOURCE;
+  const prefixTake = config.prefixTake ?? 2;
+
+  describe(`[${label}] adapter — turn framing`, () => {
+    test("a full turn streams turn.started -> ... -> turn.finished with contiguous sequences from 0", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const harness = yield* makeHarness();
+          const session = yield* harness.start({ sessionId: "s1", source });
+          const control = yield* session.promptTurn({ turnId: "t1", prompt });
+          const events = yield* collect(control.events);
+          const done = yield* control.done;
+          return { events, done };
+        }),
+      );
+
+      const { events, done } = result;
+      expect(events.length).toBeGreaterThanOrEqual(2);
+      expect(events[0]?.kind).toBe("turn.started");
+      expect(events.at(-1)?.kind).toBe("turn.finished");
+
+      const seqs = sequencesOf(events);
+      // Session-global sequences: fresh session starts at 0 so a replay from
+      // cursor -1 recovers the whole turn.
+      expect(seqs[0]).toBe(0);
+      expect(seqs).toEqual(seqs.map((_, index) => index));
+      expect(new Set(seqs).size).toBe(seqs.length);
+
+      expect(done.lastCursor).toBe(events.at(-1)?.sequence);
+      expect(typeof done.finishReason).toBe("string");
+      expect(done.finishReason.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe(`[${label}] adapter — capability refusal is fail-closed`, () => {
+    // The verbs whose refusal must be a named, typed capability error. Each
+    // returns a value on support, or fails with CapabilityUnsupported.
+    const verbs: ReadonlyArray<{
+      readonly capability: "compact" | "detach" | "suspend_turn";
+      readonly attemptVerb: (session: HarnessSession) => Effect.Effect<unknown, unknown>;
+    }> = [
+      { capability: "compact", attemptVerb: (session) => session.compact() },
+      { capability: "detach", attemptVerb: (session) => session.detach() },
+      { capability: "suspend_turn", attemptVerb: (session) => session.suspendTurn() },
+    ];
+
+    const startSession = (harness: AgentHarness) => harness.start({ sessionId: "s1", source });
+
+    for (const verb of verbs) {
+      test(`${verb.capability}: either succeeds or fails with a named CapabilityUnsupported error`, async () => {
+        const outcome = await Effect.runPromise(
+          Effect.gen(function* () {
+            const harness = yield* makeHarness();
+            const session = yield* startSession(harness);
+            return yield* attempt(verb.attemptVerb(session));
+          }),
+        );
+
+        if (outcome._tag === "failed") {
+          expect(outcome.error).toBeInstanceOf(HarnessCapabilityUnsupported);
+          expect((outcome.error as HarnessCapabilityUnsupported).capability).toBe(verb.capability);
+        }
+        // An `ok` outcome is a conformant adapter that supports the verb.
+      });
+    }
+  });
+
+  describe(`[${label}] adapter — suspend/continue cursor exactness`, () => {
+    test("continuation cursor is exact and a lossless continue attaches at cursor + 1", async () => {
+      const outcome = await Effect.runPromise(
+        Effect.gen(function* () {
+          const harness = yield* makeHarness();
+          const session = yield* harness.start({ sessionId: "s1", source });
+          const control = yield* session.promptTurn({ turnId: "t1", prompt });
+
+          // Pull a prefix, then attempt to suspend.
+          const phase1 = yield* collect(control.events.pipe(Stream.take(prefixTake)));
+          const suspend = yield* attempt(session.suspendTurn());
+          if (suspend._tag === "failed") {
+            return { supported: false as const, error: suspend.error };
+          }
+          const continuation = suspend.value;
+
+          // A FRESH session (different process) resumes from the cursor.
+          const session2 = yield* harness.start({
+            sessionId: "s1",
+            source,
+            continueFrom: continuation,
+          });
+          const continued = yield* attempt(session2.continueTurn({}));
+          if (continued._tag === "failed") {
+            return { supported: false as const, error: continued.error, continuation };
+          }
+          const phase2 = yield* collect(continued.value.events);
+          return { supported: true as const, phase1, continuation, phase2 };
+        }),
+      );
+
+      if (outcome.supported === false) {
+        // A refusal must be the named, typed capability error — never a defect.
+        expect(outcome.error).toBeInstanceOf(HarnessCapabilityUnsupported);
+        const capability = (outcome.error as HarnessCapabilityUnsupported).capability;
+        expect(["suspend_turn", "continue_turn"]).toContain(capability);
+        return;
+      }
+
+      const { phase1, continuation, phase2 } = outcome;
+      // The cursor is exactly the last event delivered in phase 1.
+      expect(continuation.cursor).toBe(phase1.at(-1)?.sequence);
+      expect(typeof continuation.lossy).toBe("boolean");
+
+      if (continuation.lossy === false) {
+        // No gap, no duplicate at the seam.
+        expect(phase2[0]?.sequence).toBe(continuation.cursor + 1);
+        const merged = sequencesOf([...phase1, ...phase2]);
+        expect(merged).toEqual(merged.map((_, index) => index));
+        expect(new Set(merged).size).toBe(merged.length);
+      } else {
+        // Honest degradation: a lossy continue re-drives the tail. The adapter
+        // must flag it rather than present a recomputed tail as an exact attach.
+        expect(continuation.lossy).toBe(true);
+      }
+    });
+  });
+};

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

@@ -0,0 +1,10 @@
+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()),
+});