@intentius/chant 0.57.0 → 0.59.0

package/src/op/operator.test.ts

@@ -9,13 +9,35 @@ import {
   runOperatorRound,
   runOperatorForever,
   formatRoundLine,
+  formatSignalLine,
   DEFAULT_OPERATOR_INTERVAL_MS,
+  type ChangeSubscriber,
+  type OperatorSignalEvent,
+  type OperatorTickEvent,
 } from "./operator";
 import { readLease } from "../lifecycle/lease";
 import { appendConvergeRecord, readConvergeLedger } from "../lifecycle/converge-ledger";
+import { readRunLedger } from "../lifecycle/run-ledger";
+import type { OpRunRecord } from "./runtime";
 
 const PROFILES: Record<string, ActivityProfile> = {};
 
+/** A minimal `OpRunRecord` for a result literal that never touches a ledger. */
+function runRecord(op: string, status: OpRunRecord["status"] = "ok"): OpRunRecord {
+  return {
+    version: 1,
+    id: "00000000-0000-4000-8000-000000000000",
+    op,
+    env: "staging",
+    started: "2026-01-01T00:00:00.000Z",
+    ended: "2026-01-01T00:00:01.000Z",
+    status,
+    labels: {},
+    outcomes: {},
+    phases: [],
+  };
+}
+
 function git(args: string[], cwd: string): { stdout: string; exitCode: number } {
   const r = spawnSync("git", args, { cwd, encoding: "utf-8" });
   return { stdout: r.stdout ?? "", exitCode: r.status ?? -1 };
@@ -34,7 +56,7 @@ async function initRepo(dir: string): Promise<void> {
  * Write a minimal fixture ConvergeOp — the same `{ props: OpConfig }` shape
  * `discoverOps` reads from a real `*.op.ts` file's default export
  * (`../op/discover.ts`), hand-built here rather than going through the real
- * `ConvergeOp()` composite (lexicons/temporal) so this suite tests the
+ * `ConvergeOp()` composite so this suite tests the
  * operator's own discovery/lease/tick-loop logic without depending on that
  * lexicon at all. One "Converge" phase calling a single fake activity —
  * `runOpLocally` doesn't care what the phases are named or how many there
@@ -50,7 +72,26 @@ function writeFixtureConvergeOp(dir: string, opName: string, env: string): void
     name: ${JSON.stringify(opName)},
     overview: "fixture converge op",
     phases: [{ name: "Converge", steps: [{ kind: "activity", fn: "fakeTick", args: {} }] }],
-    searchAttributes: { Converge: "true", Env: ${JSON.stringify(env)}, Dial: "observe" },
+    labels: { Converge: "true", Env: ${JSON.stringify(env)}, Dial: "observe" },
+  },
+};
+`,
+  );
+}
+
+/** The same fixture with a cadence of its own (#2120) — what `ConvergeOp({ schedule })` produces. */
+function writeFixtureScheduledConvergeOp(dir: string, opName: string, env: string, cron: string): void {
+  const opsDir = join(dir, "ops");
+  mkdirSync(opsDir, { recursive: true });
+  writeFileSync(
+    join(opsDir, `${opName}.op.ts`),
+    `export default {
+  props: {
+    name: ${JSON.stringify(opName)},
+    overview: "fixture scheduled converge op",
+    phases: [{ name: "Converge", steps: [{ kind: "activity", fn: "fakeTick", args: {} }] }],
+    labels: { Converge: "true", Env: ${JSON.stringify(env)}, Dial: "observe" },
+    schedule: { cron: ${JSON.stringify(cron)}, overlap: "skip" },
   },
 };
 `,
@@ -99,7 +140,7 @@ function fakeTickActivities(dir: string, env: string, opName: string, opts?: { t
 }
 
 describe("discoverConvergeOps", () => {
-  test("finds only ops with searchAttributes.Converge === 'true'", async () => {
+  test("finds only ops with labels.Converge === 'true'", async () => {
     await withTestDir(async (dir) => {
       await initRepo(dir);
       writeFixtureConvergeOp(dir, "staging-converge", "staging");
@@ -132,6 +173,28 @@ describe("discoverConvergeOps", () => {
       expect(ops.map((d) => d.config.name)).toEqual(["prod-converge", "staging-converge"]);
     });
   });
+
+  test("a ConvergeOp declaring no labels.Env is discovered unfiltered but never matches --env", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      mkdirSync(join(dir, "ops"), { recursive: true });
+      writeFileSync(
+        join(dir, "ops", "envless-converge.op.ts"),
+        `export default {
+  props: {
+    name: "envless-converge",
+    overview: "a hand-built ConvergeOp with no Env label",
+    phases: [{ name: "Converge", steps: [{ kind: "activity", fn: "fakeTick", args: {} }] }],
+    labels: { Converge: "true" },
+  },
+};
+`,
+      );
+
+      expect((await discoverConvergeOps({ cwd: dir })).ops.map((d) => d.config.name)).toEqual(["envless-converge"]);
+      expect((await discoverConvergeOps({ cwd: dir, env: "staging" })).ops).toEqual([]);
+    });
+  });
 });
 
 describe("runOperatorRound — lease + tick execution over a fixture ConvergeOp (offline)", () => {
@@ -142,7 +205,7 @@ describe("runOperatorRound — lease + tick execution over a fixture ConvergeOp
       const activities = fakeTickActivities(dir, "staging", "staging-converge");
 
       const events = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES });
-      expect(events).toEqual([{ kind: "ticked", op: "staging-converge", env: "staging", result: expect.objectContaining({ ok: true }) }]);
+      expect(events).toEqual([{ kind: "ticked", op: "staging-converge", env: "staging", result: expect.objectContaining({ status: "ok" }) }]);
 
       const { records } = await readConvergeLedger("staging", { cwd: dir });
       expect(records).toHaveLength(1);
@@ -150,6 +213,27 @@ describe("runOperatorRound — lease + tick execution over a fixture ConvergeOp
     });
   });
 
+  test("the tick's own run lands on the run ledger, keyed by the op's labels.Env (#2118)", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+
+      await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES });
+
+      const { records, malformed } = await readRunLedger("staging", "staging-converge", { cwd: dir });
+      expect(malformed).toBe(0);
+      expect(records).toHaveLength(1);
+      expect(records[0]).toMatchObject({
+        op: "staging-converge",
+        env: "staging",
+        status: "ok",
+        labels: { Converge: "true", Env: "staging", Dial: "observe" },
+      });
+      expect(records[0].phases.map((p) => p.name)).toEqual(["Converge"]);
+    });
+  });
+
   test("a second operator process (different holder) sees the lease held and skips — never queues", async () => {
     await withTestDir(async (dir) => {
       await initRepo(dir);
@@ -330,10 +414,97 @@ describe("runOperatorForever — interval/timer behavior", () => {
   });
 });
 
+describe("runOperatorRound — an Op's own schedule is its tick cadence (#2120)", () => {
+  /** 2026-09-06T13:30 local — a minute `*​/10 * * * *` fires on. */
+  const firing = () => new Date(2026, 8, 6, 13, 30, 0, 0);
+  /** …and 13:33, which it does not. */
+  const quiet = () => new Date(2026, 8, 6, 13, 33, 0, 0);
+
+  test("a round on a firing minute ticks the op", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureScheduledConvergeOp(dir, "staging-converge", "staging", "*/10 * * * *");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+
+      const events = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: firing });
+      expect(events).toEqual([
+        { kind: "ticked", op: "staging-converge", env: "staging", result: expect.objectContaining({ status: "ok" }) },
+      ]);
+    });
+  });
+
+  test("a round off the cron skips without touching the lease, and writes no ledger record", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureScheduledConvergeOp(dir, "staging-converge", "staging", "*/10 * * * *");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+
+      const events = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: quiet });
+      expect(events).toEqual([
+        { kind: "skipped-not-due", op: "staging-converge", env: "staging", cron: "*/10 * * * *" },
+      ]);
+
+      const { records } = await readConvergeLedger("staging", { cwd: dir });
+      expect(records).toHaveLength(0);
+      expect((await readLease("staging-converge", { cwd: dir })).record).toBeUndefined();
+    });
+  });
+
+  test("a late round still owes the tick: a firing minute passed since this op was last considered", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureScheduledConvergeOp(dir, "staging-converge", "staging", "*/10 * * * *");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+      const scheduleState = new Map<string, Date>();
+
+      // 13:33 — first sight, not a firing minute: recorded, not ticked.
+      const first = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: quiet, scheduleState });
+      expect(first[0].kind).toBe("skipped-not-due");
+
+      // 13:42 — 13:40 fired while nobody was looking, so this round ticks.
+      const late = () => new Date(2026, 8, 6, 13, 42, 0, 0);
+      const second = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: late, scheduleState });
+      expect(second[0].kind).toBe("ticked");
+
+      // 13:43 — nothing has fired since 13:42.
+      const after = () => new Date(2026, 8, 6, 13, 43, 0, 0);
+      const third = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: after, scheduleState });
+      expect(third[0].kind).toBe("skipped-not-due");
+    });
+  });
+
+  test("an op with no cadence of its own still ticks every round — `--interval` is the fallback", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+
+      const events = await runOperatorRound({ cwd: dir, holder: "op-a", activities, profiles: PROFILES, now: quiet });
+      expect(events[0].kind).toBe("ticked");
+    });
+  });
+});
+
 describe("formatRoundLine", () => {
   test("renders each event kind as one line", () => {
-    expect(formatRoundLine({ kind: "ticked", op: "x", env: "staging", result: { op: "x", records: [], totalMs: 1, ok: true } }))
-      .toContain("ticked=1 ok=true");
+    expect(formatRoundLine({
+      kind: "ticked", op: "x", env: "staging",
+      result: {
+        op: "x", records: [], totalMs: 1, status: "ok", startedAt: "2026-09-05T12:00:00.000Z",
+        record: runRecord("x", "ok"),
+      },
+    })).toContain("ticked=1 status=ok");
+    expect(formatRoundLine({
+      kind: "ticked", op: "x", env: "staging",
+      result: {
+        op: "x", records: [], totalMs: 1, status: "gated", startedAt: "2026-09-05T12:00:00.000Z",
+        gate: {
+          version: 1, kind: "pending", op: "x", gate: "rollout-gate",
+          timestamp: "2026-09-05T12:00:00.000Z", expiresAt: "2026-09-07T12:00:00.000Z",
+        },
+        record: runRecord("x", "gated"),
+      },
+    })).toContain('status=gated gate="rollout-gate"');
     expect(formatRoundLine({ kind: "skipped-lease-held", op: "x", env: "staging", heldBy: "holder-a" }))
       .toContain("lease-held:holder-a");
     expect(formatRoundLine({ kind: "tick-failed", op: "x", env: "staging", error: "boom" }))
@@ -342,5 +513,371 @@ describe("formatRoundLine", () => {
       .toContain("fenced=1");
     expect(formatRoundLine({ kind: "lease-error", op: "x", env: "staging", error: "stale lock at .../x.lock" }))
       .toContain("stale lock at .../x.lock");
+    expect(formatRoundLine({ kind: "skipped-not-due", op: "x", env: "staging", cron: "*/10 * * * *" }))
+      .toContain("not-due:*/10 * * * *");
+  });
+});
+
+describe("runOperatorForever: a substrate change signal wakes a tick (#1981)", () => {
+  async function waitFor(predicate: () => boolean, maxWaitMs = 5_000): Promise<void> {
+    const deadline = Date.now() + maxWaitMs;
+    while (!predicate() && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+  }
+
+  /**
+   * A stub `subscribeChanges` seam. Hands the loop's `onChange`/`onError` back
+   * to the test so it can fabricate signals and kill the subscription, with no
+   * substrate anywhere near it, which is the whole point of the seam being a
+   * plain callback pair.
+   */
+  function stubSubscriber(lexicon = "stub") {
+    const handle = {
+      lexicon,
+      subscribes: 0,
+      closes: 0,
+      onChange: undefined as undefined | (() => void),
+      onError: undefined as undefined | ((message: string) => void),
+      signal: undefined as undefined | AbortSignal,
+      failNextSubscribe: undefined as undefined | string,
+    };
+    const subscriber: ChangeSubscriber = {
+      lexicon,
+      async subscribe(ctx) {
+        handle.subscribes++;
+        if (handle.failNextSubscribe) {
+          const message = handle.failNextSubscribe;
+          handle.failNextSubscribe = undefined;
+          throw new Error(message);
+        }
+        handle.onChange = ctx.onChange;
+        handle.onError = ctx.onError;
+        handle.signal = ctx.signal;
+        return {
+          async close() {
+            handle.closes++;
+          },
+        };
+      },
+    };
+    return { handle, subscriber };
+  }
+
+  test("a signal wakes the next round early, well inside the interval", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const activities = fakeTickActivities(dir, "staging", "staging-converge");
+      const { handle, subscriber } = stubSubscriber("k8s");
+
+      const controller = new AbortController();
+      const rounds: number[] = [];
+      const signalEvents: OperatorSignalEvent[] = [];
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 60_000, // a full minute: nothing but a signal can produce a second round
+        signalFloorMs: 0,
+        activities,
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [subscriber],
+        onRound: () => rounds.push(Date.now()),
+        onSignalEvent: (e) => signalEvents.push(e),
+      });
+
+      await waitFor(() => handle.onChange !== undefined);
+      expect(rounds.length).toBe(1);
+      handle.onChange!();
+      await waitFor(() => rounds.length >= 2);
+      expect(rounds.length).toBeGreaterThanOrEqual(2);
+
+      controller.abort();
+      await loop;
+      expect(signalEvents.some((e) => e.kind === "subscribed" && e.lexicon === "k8s")).toBe(true);
+      expect(signalEvents.some((e) => e.kind === "woken")).toBe(true);
+    });
+  }, 15_000);
+
+  test("a fabricated signal cannot change what the tick reports, only when it runs", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+
+      /** One round's events, run to completion on a timer alone. */
+      async function roundsWithoutSignal(): Promise<string> {
+        const controller = new AbortController();
+        const seen: OperatorTickEvent[][] = [];
+        const loop = runOperatorForever({
+          cwd: dir,
+          holder: "op-a",
+          intervalMs: 60_000,
+          activities: fakeTickActivities(dir, "staging", "staging-converge"),
+          profiles: PROFILES,
+          signal: controller.signal,
+          onRound: (events) => {
+            seen.push(events);
+            controller.abort();
+          },
+        });
+        await loop;
+        return JSON.stringify(seen[0].map((e) => ({ kind: e.kind, op: e.op, env: e.env })));
+      }
+
+      /** The same, woken by a signal carrying a fabricated payload. */
+      async function roundsWithFabricatedSignal(): Promise<string> {
+        const { handle, subscriber } = stubSubscriber("liar");
+        const controller = new AbortController();
+        const seen: OperatorTickEvent[][] = [];
+        const loop = runOperatorForever({
+          cwd: dir,
+          holder: "op-a",
+          intervalMs: 60_000,
+          signalFloorMs: 0,
+          activities: fakeTickActivities(dir, "staging", "staging-converge"),
+          profiles: PROFILES,
+          signal: controller.signal,
+          subscribers: [subscriber],
+          onRound: (events) => {
+            seen.push(events);
+            if (seen.length >= 2) controller.abort();
+          },
+        });
+        await waitFor(() => handle.onChange !== undefined);
+        // `onChange` takes no arguments; a caller that fabricates a resource
+        // has nowhere to put it, and the extra arguments go nowhere.
+        (handle.onChange as unknown as (...args: unknown[]) => void)(
+          { kind: "Deployment", name: "ghost", status: "Drifted" },
+          "fabricated",
+        );
+        await waitFor(() => seen.length >= 2);
+        controller.abort();
+        await loop;
+        return JSON.stringify(seen[1].map((e) => ({ kind: e.kind, op: e.op, env: e.env })));
+      }
+
+      const timerOnly = await roundsWithoutSignal();
+      const signalled = await roundsWithFabricatedSignal();
+      // Byte for byte the same verdict: the signal moved the clock, nothing else.
+      expect(signalled).toBe(timerOnly);
+      // And the seam itself carries no payload channel to begin with.
+      const { handle } = stubSubscriber();
+      expect(handle.onChange?.length ?? 0).toBe(0);
+    });
+  }, 20_000);
+
+  test("a storm of signals wakes at most one round per floor", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const { handle, subscriber } = stubSubscriber();
+
+      const controller = new AbortController();
+      const rounds: number[] = [];
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 60_000,
+        signalFloorMs: 400,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [subscriber],
+        onRound: () => rounds.push(Date.now()),
+      });
+
+      await waitFor(() => handle.onChange !== undefined);
+      const before = rounds.length;
+      for (let i = 0; i < 300; i++) handle.onChange!();
+      // Well past a floor, but nowhere near the 60s interval: at most one
+      // extra round may have happened, and a per-signal wake would have
+      // produced hundreds.
+      await waitFor(() => rounds.length > before, 2_000);
+      expect(rounds.length - before).toBeLessThanOrEqual(1);
+
+      controller.abort();
+      await loop;
+    });
+  }, 15_000);
+
+  test("a killed subscription is reported once, the loop keeps ticking, and the next round re-subscribes", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const { handle, subscriber } = stubSubscriber("k8s");
+
+      const controller = new AbortController();
+      const rounds: number[] = [];
+      const signalEvents: OperatorSignalEvent[] = [];
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 60,
+        signalFloorMs: 0,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [subscriber],
+        onRound: () => rounds.push(Date.now()),
+        onSignalEvent: (e) => signalEvents.push(e),
+      });
+
+      await waitFor(() => handle.onError !== undefined);
+      const subscribesBefore = handle.subscribes;
+      // The watch dies. Twice, because a dead subscription reports once.
+      handle.onError!("connection reset by peer");
+      handle.onError!("connection reset by peer");
+
+      await waitFor(() => handle.subscribes > subscribesBefore);
+      const roundsAtDeath = rounds.length;
+      await waitFor(() => rounds.length > roundsAtDeath + 1);
+
+      controller.abort();
+      await loop;
+
+      const lost = signalEvents.filter((e) => e.kind === "subscription-lost");
+      expect(lost).toHaveLength(1);
+      expect(formatSignalLine(lost[0])).toContain("polling on the timer");
+      // The loop kept ticking on the timer, and re-subscribed.
+      expect(rounds.length).toBeGreaterThan(roundsAtDeath + 1);
+      expect(handle.subscribes).toBeGreaterThan(subscribesBefore);
+    });
+  }, 15_000);
+
+  test("a subscription that cannot be established degrades to polling with one line, never a crash", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const failing: ChangeSubscriber = {
+        lexicon: "k8s",
+        async subscribe() {
+          throw new Error("no cluster binding for env staging");
+        },
+      };
+
+      const controller = new AbortController();
+      const rounds: number[] = [];
+      const signalEvents: OperatorSignalEvent[] = [];
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 40,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [failing],
+        onRound: () => rounds.push(Date.now()),
+        onSignalEvent: (e) => signalEvents.push(e),
+      });
+
+      await waitFor(() => rounds.length >= 3);
+      controller.abort();
+      await loop; // resolves: a failing subscription never rejects the loop
+
+      const failed = signalEvents.filter((e) => e.kind === "subscribe-failed");
+      expect(failed.length).toBeGreaterThanOrEqual(1);
+      expect(formatSignalLine(failed[0])).toContain("no cluster binding for env staging");
+      expect(rounds.length).toBeGreaterThanOrEqual(3);
+    });
+  }, 15_000);
+
+  test("stopping the operator closes every subscription and aborts its signal", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const a = stubSubscriber("k8s");
+      const b = stubSubscriber("docker");
+
+      const controller = new AbortController();
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 60_000,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [a.subscriber, b.subscriber],
+      });
+
+      await waitFor(() => a.handle.onChange !== undefined && b.handle.onChange !== undefined);
+      expect(a.handle.signal!.aborted).toBe(false);
+
+      controller.abort();
+      await loop;
+
+      expect(a.handle.closes).toBe(1);
+      expect(b.handle.closes).toBe(1);
+      expect(a.handle.signal!.aborted).toBe(true);
+      expect(b.handle.signal!.aborted).toBe(true);
+    });
+  }, 15_000);
+
+  test("a close() that throws still unwinds the loop cleanly", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      let subscribed = false;
+      const hostile: ChangeSubscriber = {
+        lexicon: "k8s",
+        async subscribe() {
+          subscribed = true;
+          return { close: async () => { throw new Error("close blew up"); } };
+        },
+      };
+
+      const controller = new AbortController();
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 60_000,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [hostile],
+      });
+
+      await waitFor(() => subscribed);
+      controller.abort();
+      await expect(loop).resolves.toBeUndefined();
+    });
+  }, 15_000);
+
+  test("no subscribers: the loop is exactly the timer it always was", async () => {
+    await withTestDir(async (dir) => {
+      await initRepo(dir);
+      writeFixtureConvergeOp(dir, "staging-converge", "staging");
+      const controller = new AbortController();
+      const rounds: number[] = [];
+      const signalEvents: OperatorSignalEvent[] = [];
+      const loop = runOperatorForever({
+        cwd: dir,
+        holder: "op-a",
+        intervalMs: 40,
+        activities: fakeTickActivities(dir, "staging", "staging-converge"),
+        profiles: PROFILES,
+        signal: controller.signal,
+        subscribers: [], // a project whose lexicons implement no signal seam
+        onRound: () => rounds.push(Date.now()),
+        onSignalEvent: (e) => signalEvents.push(e),
+      });
+
+      await waitFor(() => rounds.length >= 3);
+      controller.abort();
+      await loop;
+      expect(rounds.length).toBeGreaterThanOrEqual(3);
+      expect(signalEvents).toEqual([]);
+    });
+  }, 15_000);
+});
+
+describe("formatSignalLine", () => {
+  test("renders each signal event kind as one line, none of them an observation", () => {
+    expect(formatSignalLine({ kind: "subscribed", lexicon: "k8s" })).toContain("the timer still runs");
+    expect(formatSignalLine({ kind: "subscribe-failed", lexicon: "k8s", error: "no binding" }))
+      .toContain("polling on the timer");
+    expect(formatSignalLine({ kind: "subscription-lost", lexicon: "k8s", error: "410 Gone" }))
+      .toContain("re-subscribes");
+    expect(formatSignalLine({ kind: "woken", afterMs: 120 })).toContain("running an ordinary round");
   });
 });