@alma-harness/testing 0.1.0 → 0.3.0

package/README.md

@@ -3,7 +3,8 @@
 The shared storage contract suites of [Alma](https://github.com/FabioFernandesCarneiro/alma)
 — what "correct" means for every storage adapter, on any backend.
 
-> **Status: pre-release.** Not yet published to npm.
+> **Status: 0.2.0 on npm, pre-1.0.** The API is still moving; see the
+> [roadmap](../../docs/architecture.md#12-adoption-roadmap) for where it stands.
 
 ## What it owns
 
@@ -12,10 +13,20 @@ The shared storage contract suites of [Alma](https://github.com/FabioFernandesCa
   storage contracts: deterministic ids, three states never conflated, the
   three-case confidence rule, identity never extracted, a budget on every read.
 - `describeMemoryErasureContract` — the LGPD/GDPR story as a test: content
-  gone, derived data invalidated, every declared copy surface reached.
+  gone, derived data invalidated, every declared copy surface reached. The
+  fixture's `watermarks` and `accessEvents` are required: six cases used to
+  return silently without them, green on an in-flight guard and a trail the
+  adapter never proved (spec: erasure-reaches-the-claims).
 - `describeSpendStoreContract` — the `SpendStore` contract (spec: spend-store):
   atomic increment-and-return, UTC day bucketing, org-wide day aggregation,
   no lost increments under concurrency.
+- `describeRoutineStoreContract` — the `RoutineStore` contract (spec:
+  clock-tick): a routine round-trips with its registration stamp, the stamp
+  survives re-registration, cancel removes, `list` sees every scope.
+- `describeRoutineRunStoreContract` — the `RoutineRunStore` contract (spec:
+  postgres-routine-runs): a run round-trips whole, upserts by key, lists
+  newest first with an inclusive `since` that compares instants, and is
+  isolated by routine, uid and org.
 - `describeTurnStoreContract` — the `TurnStore` contract (spec 030): exactly one
   winner per session, leases that expire so a crashed holder never blocks
   forever, a stale release that touches nothing, claims that replay a finished

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SessionStore, EpisodeStore, ProfileStore, MemoryErasure, ErasureWatermarkStore, AccessEvent, SpendStore, TurnStore } from '@alma-harness/core';
+import { SessionStore, EpisodeStore, ProfileStore, MemoryErasure, ErasureWatermarkStore, AccessEvent, SpendStore, TurnStore, RoutineRunStore, RoutineStore } from '@alma-harness/core';
 
 /**
  * Shared `SessionStore` contract suite — §6: storage contracts are
@@ -72,9 +72,15 @@ interface MemoryErasureFixture {
     erasure: MemoryErasure;
     episodes: EpisodeStore;
     profile: ProfileStore;
-    watermarks?: ErasureWatermarkStore;
+    /**
+     * REQUIRED — spec: erasure-reaches-the-claims. Both used to be optional and
+     * six cases returned silently without them, so an adapter with no in-flight
+     * guard and no trail was green on both. A fixture that cannot supply them
+     * has nothing to prove here.
+     */
+    watermarks: ErasureWatermarkStore;
     /** Events the wired `AuditLog` received — the erasure trail (§6.8, §10). */
-    accessEvents?: readonly AccessEvent[];
+    accessEvents: readonly AccessEvent[];
 }
 declare function describeMemoryErasureContract(name: string, factory: MemoryErasureFactory): void;
 
@@ -109,7 +115,8 @@ declare function describeSpendStoreContract(name: string, factory: SpendStoreFac
  * Timing is exercised with REAL time and small TTLs, deliberately. A fake
  * clock cannot reach a Postgres `now()`, and one that desynchronizes from the
  * `setTimeout` a wait is built on makes the reference store and the adapter
- * prove different things.
+ * prove different things. An expiry is waited for through `acquire`'s own
+ * `waitMs`, never a fixed sleep (spec: close-review-part-two).
  *
  * ```ts
  * describeTurnStoreContract("PostgresTurnStore", { create: () => … });
@@ -122,4 +129,34 @@ interface TurnStoreFactory {
 }
 declare function describeTurnStoreContract(name: string, factory: TurnStoreFactory): void;
 
-export { type EpisodeStoreFactory, type MemoryErasureFactory, type MemoryErasureFixture, type ProfileStoreFactory, type SessionStoreFactory, type SpendStoreFactory, type TurnStoreFactory, describeEpisodeStoreContract, describeMemoryErasureContract, describeProfileStoreContract, describeSessionStoreContract, describeSpendStoreContract, describeTurnStoreContract };
+/**
+ * Shared `RoutineRunStore` contract suite — spec: postgres-routine-runs. Pins
+ * the three reads the routine runner relies on (spec: routine-runner): the
+ * same fire again, today's runs for the ceiling, the last run of an outcome
+ * for the dedupe — and that a record is metadata that round-trips whole.
+ *
+ * ```ts
+ * describeRoutineRunStoreContract("PostgresRoutineRunStore", { create: () => … });
+ * ```
+ */
+interface RoutineRunStoreFactory {
+    /** Must return a store holding NO runs for the scopes below. */
+    create(): Promise<RoutineRunStore> | RoutineRunStore;
+    destroy?(store: RoutineRunStore): Promise<void> | void;
+}
+declare function describeRoutineRunStoreContract(name: string, factory: RoutineRunStoreFactory): void;
+
+/**
+ * Shared `RoutineStore` contract suite — spec: clock-tick. What the tick
+ * relies on: a routine round-trips whole with its registration stamp, the
+ * stamp survives re-registration, cancel removes, and `list` sees every
+ * scope while `get`/`cancel` are exact.
+ */
+interface RoutineStoreFactory {
+    /** Must return a store holding NO routines. */
+    create(): Promise<RoutineStore> | RoutineStore;
+    destroy?(store: RoutineStore): Promise<void> | void;
+}
+declare function describeRoutineStoreContract(name: string, factory: RoutineStoreFactory): void;
+
+export { type EpisodeStoreFactory, type MemoryErasureFactory, type MemoryErasureFixture, type ProfileStoreFactory, type RoutineRunStoreFactory, type RoutineStoreFactory, type SessionStoreFactory, type SpendStoreFactory, type TurnStoreFactory, describeEpisodeStoreContract, describeMemoryErasureContract, describeProfileStoreContract, describeRoutineRunStoreContract, describeRoutineStoreContract, describeSessionStoreContract, describeSpendStoreContract, describeTurnStoreContract };

package/dist/index.js

@@ -65,6 +65,18 @@ function describeSessionStoreContract(name, factory) {
       await store.append(ALICE, "s1", [text("assistant", "4")]);
       expect(bodies(await store.load(ALICE, "s1"))).toEqual(["1", "2", "3", "4"]);
     });
+    it("lands every message of concurrent appends on one session exactly once", async () => {
+      await Promise.all(
+        Array.from(
+          { length: 12 },
+          (_, i) => store.append(ALICE, "s1", [text("user", `q${i}`), text("assistant", `a${i}`)])
+        )
+      );
+      const seen = bodies(await store.load(ALICE, "s1")).map(String);
+      expect(seen).toHaveLength(24);
+      expect(new Set(seen).size).toBe(24);
+      for (let i = 0; i < seen.length; i += 2) expect(seen[i + 1]).toBe(seen[i].replace("q", "a"));
+    });
     it("resolves an unknown session to an empty history", async () => {
       await expect(store.load(ALICE, "never-created")).resolves.toEqual([]);
     });
@@ -141,6 +153,37 @@ function describeSessionStoreContract(name, factory) {
       expect(flat).not.toContain("tool_call");
       expect(flat).not.toContain("tool_result");
     });
+    it("expires reasoning blocks with the tool traffic \u2014 backstage, not what the person saw", async () => {
+      await store.append(ALICE, "s1", [
+        {
+          role: "assistant",
+          blocks: [
+            { type: "reasoning", provider: "anthropic", text: "the patient asked twice", opaque: { signature: "sig" } },
+            { type: "tool_call", id: "c1", name: "list", input: {} }
+          ],
+          meta: { at: "2026-01-01T00:00:00.000Z" }
+        },
+        {
+          role: "tool",
+          blocks: [{ type: "tool_result", callId: "c1", output: "two" }],
+          meta: { at: "2026-01-01T00:00:00.000Z" }
+        },
+        {
+          role: "assistant",
+          blocks: [
+            { type: "reasoning", provider: "anthropic", text: "answer briefly", opaque: { signature: "sig2" } },
+            { type: "text", text: "you have two" }
+          ],
+          meta: { at: "2026-01-01T00:00:00.000Z" }
+        }
+      ]);
+      const report = await store.expireToolTraffic(ALICE, "s1", {
+        inactiveSince: "2026-06-01T00:00:00.000Z"
+      });
+      expect(report).toEqual({ blocks: 4, messages: 2, expired: true });
+      expect(kinds(await store.load(ALICE, "s1"))).toEqual([["text"]]);
+      expect(JSON.stringify(await store.load(ALICE, "s1"))).not.toContain("the patient asked twice");
+    });
     it("keeps media blocks \u2014 a pointer the user saw, not tool traffic", async () => {
       await store.append(ALICE, "s1", [
         {
@@ -364,6 +407,12 @@ function describeEpisodeStoreContract(name, factory) {
       const { episodes } = await store.query(ALICE2, { text: "kayaking" });
       expect2(summaries(episodes)).toEqual(["loves kayaking"]);
     });
+    it2("finds an inflected form: a query in the singular matches a summary in the plural", async () => {
+      await store.append(ALICE2, { kind: "note", summary: "duas reuni\xF5es marcadas para ter\xE7a" });
+      await store.append(ALICE2, { kind: "note", summary: "nada a ver com isso", dedupeKey: "other" });
+      const { episodes } = await store.query(ALICE2, { text: "reuni\xE3o" });
+      expect2(summaries(episodes)).toEqual(["duas reuni\xF5es marcadas para ter\xE7a"]);
+    });
     it2("finds a term deep in a long summary, past the query tokenizer's cap", async () => {
       const filler = Array.from({ length: 40 }, (_, i) => `filler${i}`).join(" ");
       await store.append(ALICE2, { kind: "note", summary: `${filler} chocolate` });
@@ -1021,7 +1070,6 @@ function describeMemoryErasureContract(name, factory) {
       expect4(report.complete).toBe(true);
     });
     it4("stamps the scope's erasure watermark for the in-flight job guard", async () => {
-      if (!fx.watermarks) return;
       await expect4(fx.watermarks.get(ALICE4)).resolves.toBeNull();
       const report = await fx.erasure.erase(ALICE4, { kind: "all" });
       await expect4(fx.watermarks.get(ALICE4)).resolves.toBe(report.erasedAt);
@@ -1034,10 +1082,9 @@ function describeMemoryErasureContract(name, factory) {
       await fx.erasure.erase(ALICE4, { kind: "all" });
       expect4((await fx.episodes.get(TWIN, [twin.id]))[0]).toMatchObject({ state: "active" });
       expect4((await fx.profile.get(TWIN)).facts).toHaveLength(1);
-      if (fx.watermarks) await expect4(fx.watermarks.get(TWIN)).resolves.toBeNull();
+      await expect4(fx.watermarks.get(TWIN)).resolves.toBeNull();
     });
     it4("never moves the watermark backwards, whatever clock stamps the second erasure", async () => {
-      if (!fx.watermarks) return;
       await fx.watermarks.set(ALICE4, "2026-06-01T00:00:10.000Z");
       await fx.watermarks.set(ALICE4, "2026-06-01T00:00:00.000Z");
       await expect4(fx.watermarks.get(ALICE4)).resolves.toBe("2026-06-01T00:00:10.000Z");
@@ -1077,7 +1124,6 @@ function describeMemoryErasureContract(name, factory) {
       await expect4(fx.profile.get(ALICE4)).resolves.toMatchObject({ facts: [] });
     });
     it4("refuses an observation submitted from before the erasure", async () => {
-      if (!fx.watermarks) return;
       const before = new Date(Date.now() - 6e4).toISOString();
       await fx.erasure.erase(ALICE4, { kind: "all" });
       const [result] = await fx.profile.observe(ALICE4, [
@@ -1097,7 +1143,6 @@ function describeMemoryErasureContract(name, factory) {
       await expect4(fx.profile.get(ALICE4)).resolves.toMatchObject({ facts: [] });
     });
     it4("refuses an episode stamped before the erasure, not only a fact", async () => {
-      if (!fx.watermarks) return;
       const before = new Date(Date.now() - 6e4).toISOString();
       await fx.erasure.erase(ALICE4, { kind: "all" });
       await expect4(
@@ -1105,7 +1150,6 @@ function describeMemoryErasureContract(name, factory) {
       ).rejects.toThrow();
     });
     it4("records a trail even when the erasure fails partway", async () => {
-      if (!fx.accessEvents) return;
       const before = fx.accessEvents.length;
       await expect4(
         fx.erasure.erase(ALICE4, {
@@ -1114,10 +1158,9 @@ function describeMemoryErasureContract(name, factory) {
         })
       ).rejects.toThrow();
       expect4(fx.accessEvents.length).toBe(before);
-      if (fx.watermarks) await expect4(fx.watermarks.get(ALICE4)).resolves.toBeNull();
+      await expect4(fx.watermarks.get(ALICE4)).resolves.toBeNull();
     });
     it4("leaves an audit trail proving the erasure ran, carrying no content", async () => {
-      if (!fx.accessEvents) return;
       await seedSupportedFact(ALICE4, "s1", "zeta");
       await fx.erasure.erase(ALICE4, { kind: "all" });
       const erasures = fx.accessEvents.filter((e) => e.action === "delete");
@@ -1324,9 +1367,8 @@ function describeTurnStoreContract(name, factory) {
       await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.not.toBeNull();
     });
     it6("ignores a STALE release instead of freeing the current holder's session", async () => {
-      const stale = await store.acquire(ALICE6, "s1", { ttlMs: 20, waitMs: 0 });
-      await new Promise((r) => setTimeout(r, 60));
-      const current = await store.acquire(ALICE6, "s1", { ttlMs: 6e4, waitMs: 200 });
+      const stale = await store.acquire(ALICE6, "s1", { ttlMs: 100, waitMs: 0 });
+      const current = await store.acquire(ALICE6, "s1", { ttlMs: 6e4, waitMs: 2e3 });
       expect6(current.token).not.toBe(stale.token);
       await store.release(ALICE6, "s1", stale);
       await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.toBeNull();
@@ -1334,9 +1376,8 @@ function describeTurnStoreContract(name, factory) {
       await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.not.toBeNull();
     });
     it6("lets a later caller take a lease whose TTL expired \u2014 a crashed holder never blocks a session forever", async () => {
-      await store.acquire(ALICE6, "s1", { ttlMs: 20, waitMs: 0 });
-      await new Promise((r) => setTimeout(r, 60));
-      await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.not.toBeNull();
+      await store.acquire(ALICE6, "s1", { ttlMs: 100, waitMs: 0 });
+      await expect6(store.acquire(ALICE6, "s1", { ttlMs: 6e4, waitMs: 2e3 })).resolves.not.toBeNull();
     });
     it6("WAITS for a busy session and takes it when the holder releases inside the window", async () => {
       const lease = await store.acquire(ALICE6, "s1", { ttlMs: 6e4, waitMs: 0 });
@@ -1435,16 +1476,18 @@ function describeTurnStoreContract(name, factory) {
       await store.complete(k, completedTurn());
       await expect6(store.claim(k)).resolves.toEqual({ status: "fresh" });
     });
-    it6("erases one session's claims and lease, leaving its siblings alone", async () => {
+    it6("erases one session's claims and leaves its lease to the holder, so a turn in flight is not interleaved", async () => {
       const target = key(ALICE6, "s1", "wamid-3");
       const sibling = key(ALICE6, "s2", "wamid-3");
       for (const k of [target, sibling]) {
         await store.claim(k);
         await store.complete(k, completedTurn());
       }
-      await store.acquire(ALICE6, "s1", NEVER_EXPIRES);
+      const held = await store.acquire(ALICE6, "s1", NEVER_EXPIRES);
       await store.erase(ALICE6, "s1");
       await expect6(store.claim(target)).resolves.toEqual({ status: "fresh" });
+      await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.toBeNull();
+      await store.release(ALICE6, "s1", held);
       await expect6(store.acquire(ALICE6, "s1", NEVER_EXPIRES)).resolves.not.toBeNull();
       const siblingClaim = await store.claim(sibling);
       expect6(siblingClaim.status).toBe("replay");
@@ -1499,10 +1542,189 @@ function describeTurnStoreContract(name, factory) {
     });
   });
 }
+
+// src/routine-run-store-contract.ts
+import { afterEach as afterEach7, beforeEach as beforeEach7, describe as describe7, expect as expect7, it as it7 } from "vitest";
+var ALICE7 = { org: "org-a", uid: "user-alice" };
+var BOB7 = { org: "org-a", uid: "user-bob" };
+var OTHER_ORG5 = { org: "org-b", uid: "user-alice" };
+var T4 = {
+  early: "2026-08-24T08:00:00.000Z",
+  late: "2026-08-24T20:00:00.000Z",
+  nextDay: "2026-08-25T09:00:00.000Z",
+  /** 01:00+02:00 on the 25th IS 23:00Z on the 24th. */
+  lateByOffset: "2026-08-25T01:00:00+02:00"
+};
+function run(over) {
+  return { routineId: "briefing", scope: ALICE7, outcome: "delivered", costUsd: 0.01, ...over };
+}
+function describeRoutineRunStoreContract(name, factory) {
+  describe7(`RoutineRunStore contract: ${name}`, () => {
+    let store;
+    beforeEach7(async () => {
+      store = await factory.create();
+    });
+    afterEach7(async () => {
+      await factory.destroy?.(store);
+    });
+    it7("round-trips a run whole, optional fields present when set and absent when not", async () => {
+      const full = run({
+        id: "r1",
+        startedAt: T4.early,
+        finishedAt: T4.late,
+        outcome: "submitted",
+        reason: "why",
+        costUsd: 2e-6,
+        sessionId: "s1",
+        turnId: "t1",
+        handle: { provider: "openai", id: "batch_1", model: { provider: "openai", id: "m" } },
+        deliveryHash: "abc"
+      });
+      const bare = run({ id: "r2", startedAt: T4.late });
+      await store.record(full);
+      await store.record(bare);
+      expect7(await store.get(ALICE7, "briefing", "r1")).toEqual(full);
+      expect7(await store.get(ALICE7, "briefing", "r2")).toEqual(bare);
+    });
+    it7("upserts by (scope, routine, run): a second record replaces the first", async () => {
+      await store.record(run({ id: "r1", startedAt: T4.early, outcome: "submitted" }));
+      await store.record(run({ id: "r1", startedAt: T4.early, outcome: "delivered", finishedAt: T4.late, deliveryHash: "h" }));
+      expect7(await store.get(ALICE7, "briefing", "r1")).toMatchObject({ outcome: "delivered", deliveryHash: "h" });
+      expect7(await store.list(ALICE7, "briefing")).toHaveLength(1);
+    });
+    it7("resolves an unknown run to null", async () => {
+      await expect7(store.get(ALICE7, "briefing", "never")).resolves.toBeNull();
+    });
+    it7("lists newest first; since is inclusive and compares instants; outcome filters; limit caps", async () => {
+      await store.record(run({ id: "early", startedAt: T4.early }));
+      await store.record(run({ id: "late", startedAt: T4.late, outcome: "duplicate" }));
+      await store.record(run({ id: "offset", startedAt: T4.lateByOffset }));
+      await store.record(run({ id: "next", startedAt: T4.nextDay, outcome: "refused" }));
+      expect7((await store.list(ALICE7, "briefing")).map((r) => r.id)).toEqual(["next", "offset", "late", "early"]);
+      expect7((await store.list(ALICE7, "briefing", { since: T4.late })).map((r) => r.id)).toEqual(["next", "offset", "late"]);
+      expect7((await store.list(ALICE7, "briefing", { since: "2026-08-24T00:00:00.000Z" })).map((r) => r.id)).toEqual(["next", "offset", "late", "early"]);
+      expect7((await store.list(ALICE7, "briefing", { since: "2026-08-25T00:00:00.000Z" })).map((r) => r.id)).toEqual(["next"]);
+      expect7((await store.list(ALICE7, "briefing", { outcome: "delivered", limit: 1 })).map((r) => r.id)).toEqual(["offset"]);
+      expect7((await store.list(ALICE7, "briefing", { outcome: "refused" })).map((r) => r.id)).toEqual(["next"]);
+      expect7(await store.list(ALICE7, "briefing", { limit: 0 })).toEqual([]);
+    });
+    it7("orders two runs at the same instant by id, on every backend", async () => {
+      await store.record(run({ id: "b", startedAt: T4.late }));
+      await store.record(run({ id: "a", startedAt: T4.late }));
+      await store.record(run({ id: "c", startedAt: T4.early }));
+      expect7((await store.list(ALICE7, "briefing")).map((r) => r.id)).toEqual(["a", "b", "c"]);
+      expect7((await store.list(ALICE7, "briefing", { limit: 1 })).map((r) => r.id)).toEqual(["a"]);
+    });
+    it7("isolates runs by routine, uid and org", async () => {
+      await store.record(run({ id: "r1", startedAt: T4.early }));
+      await store.record(run({ id: "r1", startedAt: T4.early, routineId: "closing" }));
+      await store.record(run({ id: "r1", startedAt: T4.early, scope: BOB7 }));
+      await store.record(run({ id: "r1", startedAt: T4.early, scope: OTHER_ORG5 }));
+      expect7(await store.list(ALICE7, "briefing")).toHaveLength(1);
+      expect7(await store.list(ALICE7, "closing")).toHaveLength(1);
+      expect7(await store.list(BOB7, "briefing")).toHaveLength(1);
+      expect7(await store.list(OTHER_ORG5, "briefing")).toHaveLength(1);
+      await expect7(store.get(ALICE7, "nothing", "r1")).resolves.toBeNull();
+    });
+    it7("rejects an invalid scope on every surface", async () => {
+      const bad = { org: "../evil", uid: "user-1" };
+      await expect7(store.record(run({ id: "r1", startedAt: T4.early, scope: bad }))).rejects.toThrow();
+      await expect7(store.get(bad, "briefing", "r1")).rejects.toThrow();
+      await expect7(store.list(bad, "briefing")).rejects.toThrow();
+    });
+    it7("rejects an unparseable since or startedAt rather than sorting it to the epoch", async () => {
+      await expect7(store.record(run({ id: "r1", startedAt: "not a date" }))).rejects.toThrow();
+      await store.record(run({ id: "r2", startedAt: T4.early }));
+      await expect7(store.list(ALICE7, "briefing", { since: "not a date" })).rejects.toThrow();
+    });
+  });
+}
+
+// src/routine-store-contract.ts
+import { afterEach as afterEach8, beforeEach as beforeEach8, describe as describe8, expect as expect8, it as it8 } from "vitest";
+var ALICE8 = { org: "org-a", uid: "user-alice" };
+var BOB8 = { org: "org-a", uid: "user-bob" };
+var OTHER_ORG6 = { org: "org-b", uid: "user-alice" };
+function routine(over) {
+  return {
+    scope: ALICE8,
+    schedule: { cron: "0 8 * * 1-5", tz: "America/Sao_Paulo" },
+    goal: "prepare the briefing",
+    intent: { tier: "mechanical", sensitivity: "internal" },
+    toolProfile: "briefing",
+    budget: { perTurnUsd: 0.2 },
+    outputSink: "inbox",
+    maxRunsPerDay: 2,
+    ...over
+  };
+}
+function describeRoutineStoreContract(name, factory) {
+  describe8(`RoutineStore contract: ${name}`, () => {
+    let store;
+    beforeEach8(async () => {
+      store = await factory.create();
+    });
+    afterEach8(async () => {
+      await factory.destroy?.(store);
+    });
+    it8("registers a routine stamped with the time, round-trips it whole, and keeps the anchor on re-registration", async () => {
+      const before = Date.now();
+      await store.register(routine({ id: "briefing" }));
+      const stored = await store.get(ALICE8, "briefing");
+      expect8(stored).toMatchObject(routine({ id: "briefing" }));
+      const at = Date.parse(stored.registeredAt);
+      expect8(Number.isNaN(at)).toBe(false);
+      expect8(at).toBeGreaterThanOrEqual(before - 1e3);
+      await store.register(routine({ id: "briefing", goal: "prepare the briefing, shorter" }));
+      const edited = await store.get(ALICE8, "briefing");
+      expect8(edited).toMatchObject({ goal: "prepare the briefing, shorter", registeredAt: stored.registeredAt });
+    });
+    it8("keeps a supplied registration stamp on first registration \u2014 a migration keeps its anchors \u2014 and ignores it on re-registration", async () => {
+      await store.register({ ...routine({ id: "moved" }), registeredAt: "2026-01-01T00:00:00.000Z" });
+      expect8((await store.get(ALICE8, "moved"))?.registeredAt).toBe("2026-01-01T00:00:00.000Z");
+      await store.register({ ...routine({ id: "moved" }), registeredAt: "2026-06-01T00:00:00.000Z" });
+      expect8((await store.get(ALICE8, "moved"))?.registeredAt).toBe("2026-01-01T00:00:00.000Z");
+      await expect8(store.register({ ...routine({ id: "bad" }), registeredAt: "not a date" })).rejects.toThrow();
+    });
+    it8("cancels a routine, after which get is null and list omits it", async () => {
+      await store.register(routine({ id: "briefing" }));
+      await store.register(routine({ id: "closing", execution: "job", toolProfile: void 0 }));
+      await store.cancel(ALICE8, "briefing");
+      await expect8(store.get(ALICE8, "briefing")).resolves.toBeNull();
+      expect8((await store.list()).map((r) => r.id)).toEqual(["closing"]);
+      await expect8(store.cancel(ALICE8, "briefing")).resolves.toBeUndefined();
+    });
+    it8("lists every routine of every scope \u2014 the tick is a deployment read", async () => {
+      await store.register(routine({ id: "briefing" }));
+      await store.register(routine({ id: "briefing", scope: BOB8 }));
+      await store.register(routine({ id: "briefing", scope: OTHER_ORG6 }));
+      const all = await store.list();
+      expect8(all).toHaveLength(3);
+      expect8(all.map((r) => `${r.scope.org}/${r.scope.uid}`).sort()).toEqual(["org-a/user-alice", "org-a/user-bob", "org-b/user-alice"]);
+    });
+    it8("isolates get and cancel by scope and id", async () => {
+      await store.register(routine({ id: "briefing" }));
+      await store.register(routine({ id: "briefing", scope: BOB8, goal: "bob's" }));
+      await store.cancel(OTHER_ORG6, "briefing");
+      await store.cancel(ALICE8, "closing");
+      expect8((await store.get(ALICE8, "briefing"))?.goal).toBe("prepare the briefing");
+      expect8((await store.get(BOB8, "briefing"))?.goal).toBe("bob's");
+      await expect8(store.get(OTHER_ORG6, "briefing")).resolves.toBeNull();
+    });
+    it8("rejects an invalid scope on every surface", async () => {
+      const bad = { org: "../evil", uid: "user-1" };
+      await expect8(store.register(routine({ id: "r", scope: bad }))).rejects.toThrow();
+      await expect8(store.get(bad, "r")).rejects.toThrow();
+      await expect8(store.cancel(bad, "r")).rejects.toThrow();
+    });
+  });
+}
 export {
   describeEpisodeStoreContract,
   describeMemoryErasureContract,
   describeProfileStoreContract,
+  describeRoutineRunStoreContract,
+  describeRoutineStoreContract,
   describeSessionStoreContract,
   describeSpendStoreContract,
   describeTurnStoreContract