@frockbot/kernel-do 0.3.10 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/kernel-do",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-composition": "0.3.10",
-    "@frockbot/kernel-contracts": "0.3.10",
+    "@frockbot/kernel-composition": "0.3.11",
+    "@frockbot/kernel-contracts": "0.3.11",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/composition-failures.test.ts

@@ -486,6 +486,45 @@ describe("fail-closed Composition activation", () => {
     expect(activation.quarantined).toBe(false);
   });
 
+  test("the streak expires, so unrelated failures far apart are separate incidents", async () => {
+    // Three repair attempts are one sitting. Three failures months apart are
+    // three incidents, and quarantining the third would strand a Bot for
+    // something it had already recovered from twice.
+    const storage = new MemoryStorage();
+    const state = { storage } as unknown as DurableObjectState;
+    const store = new DurableCompositionStore({ state, bootstrap });
+    let clock = new Date("2026-09-01T00:00:00.000Z");
+    const failures = new DurableCompositionFailureLog({
+      state,
+      now: () => clock,
+      streakWindowMs: 60 * 60 * 1000,
+    });
+    const lastKnownGood = await store.current();
+
+    const outcomes: boolean[] = [];
+    for (const day of [1, 2, 3]) {
+      clock = new Date(`2026-09-0${day}T00:00:00.000Z`);
+      const generation = await authored(
+        lastKnownGood,
+        `2026-09-0${day}T00:00:00.000Z`,
+      );
+      await store.propose(generation, { pin: true });
+      const activation = await activateCompositionV1({
+        generationId: generation.generationId,
+        store: activationStore(store),
+        failures,
+        host: brokenHost(generation.generationId, "mount"),
+        signal: new AbortController().signal,
+        now: () => clock,
+      });
+      if (activation.status !== "failed-closed") throw new Error("expected");
+      outcomes.push(activation.quarantined);
+    }
+
+    // A day apart each time: never a streak, so never a quarantine.
+    expect(outcomes).toEqual([false, false, false]);
+  });
+
   test("a last known good that will not mount has nothing to fail into", async () => {
     const { store, failures, lastKnownGood } = await fixture();
     await expect(

package/src/composition-failures.ts

@@ -27,8 +27,23 @@ export interface DurableCompositionFailureLogOptions {
   now?(): Date;
   /** Consecutive failures that quarantine a generation. Defaults to three. */
   threshold?: number;
+  /** How long the Bot-wide streak stays alive. Defaults to one hour. */
+  streakWindowMs?: number;
 }
 
+/** The Bot's live failure streak: how many, and when the last one landed. */
+interface CompositionFailureStreakV1 {
+  count: number;
+  at: string;
+}
+
+/**
+ * One sitting. Repair attempts arrive minutes apart, so an hour is long enough
+ * to span a Bot's whole attempt to fix itself and short enough that yesterday's
+ * unrelated failure does not count towards today's quarantine.
+ */
+const COMPOSITION_FAILURE_STREAK_WINDOW_MS = 60 * 60 * 1000;
+
 /**
  * `CompositionFailureLog` over the Bot object's prefixed keys:
  * `composition:failure:<generationId>:<attempt>`,
@@ -45,11 +60,14 @@ export class DurableCompositionFailureLog implements CompositionFailureLog {
   private readonly ctx: DurableObjectState;
   private readonly now: () => Date;
   private readonly threshold: number;
+  private readonly streakWindowMs: number;
 
   constructor(options: DurableCompositionFailureLogOptions) {
     this.ctx = options.state;
     this.now = options.now ?? (() => new Date());
     this.threshold = options.threshold ?? COMPOSITION_QUARANTINE_THRESHOLD;
+    this.streakWindowMs =
+      options.streakWindowMs ?? COMPOSITION_FAILURE_STREAK_WINDOW_MS;
   }
 
   /** The attempt number is assigned here, inside the counter's transaction. */
@@ -70,14 +88,27 @@ export class DurableCompositionFailureLog implements CompositionFailureLog {
       // the model repairs by authoring a *new* generation, which is what it
       // always does — so without it the safeguard never fired and the
       // Composition grew one dead generation per repair attempt.
-      const streak =
-        ((await transaction.get<number>(COMPOSITION_FAILURE_STREAK_KEY)) ?? 0) +
-        1;
+      //
+      // The streak is bounded in time as well as reset by success. Three
+      // repair attempts are one sitting; three unrelated failures months apart
+      // are three separate incidents, and quarantining the third would strand
+      // a Bot for something it had already recovered from twice.
+      const at = this.now();
+      const stored = await transaction.get<CompositionFailureStreakV1>(
+        COMPOSITION_FAILURE_STREAK_KEY,
+      );
+      const continues =
+        stored !== undefined &&
+        at.getTime() - Date.parse(stored.at) <= this.streakWindowMs;
+      const streak = (continues ? stored.count : 0) + 1;
       const quarantined = attempt >= this.threshold || streak >= this.threshold;
       const writes: Record<string, unknown> = {
         [compositionFailureKey(generationId, attempt)]: recorded,
         [compositionFailureCountKey(generationId)]: attempt,
-        [COMPOSITION_FAILURE_STREAK_KEY]: streak,
+        [COMPOSITION_FAILURE_STREAK_KEY]: {
+          count: streak,
+          at: at.toISOString(),
+        } satisfies CompositionFailureStreakV1,
       };
       if (quarantined) {
         writes[compositionQuarantineKey(generationId)] =