fix: retain realtime work through draining

R-02: add an OPEN/DRAINING/CLOSED lifecycle orthogonal to freshness. Effect and
recovery authorities are now awaited under a deadline: on expiry the commit
capability is revoked and the work aborted, the caller gets a bounded
non-retryable IDLE_TIMEOUT, and the underlying task is retained rather than
dropped. A draining stream refuses new events and recovery, and close() returns
a Promise that succeeds only once every retained task actually settled,
reporting IDLE_TIMEOUT otherwise.

R-03: a handoff fail-close moves active, probe, quiescing and transition leases
into a retired-writer set before clearing their references, and close() waits on
current and retired writers together, so an abandoned non-cooperative writer can
no longer make teardown report a false success.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/unit/realtime/live-poll-handoff-coordinator.test.ts

@@ -214,6 +214,47 @@ describe("live/poll authoritative writer handoff", () => {
     void second;
   });
 
+  it("tracks a retired active writer after handoff queue overflow", async () => {
+    let release: ((result: RealtimeResult<void>) => void) | undefined;
+    const harness = createHarness({
+      limits: {
+        ...limits,
+        maxActiveQueueCount: 2,
+        maxActiveQueueBytes: 10,
+      },
+      apply: vi.fn(async ({ value }) => {
+        if (value === "first") {
+          return await new Promise<RealtimeResult<void>>((resolve) => {
+            release = resolve;
+          });
+        }
+        return realtimeSuccess(undefined);
+      }),
+    });
+    const writer = harness.coordinator.currentWriter()!;
+    const first = writer.write("first", 5);
+    const second = writer.write("second", 5);
+    await flush();
+    await expect(writer.write("overflow", 1)).resolves.toMatchObject({
+      ok: false,
+      error: { kind: "QUEUE_OVERFLOW" },
+    });
+
+    // R-03. The fail-close dropped the active reference, but the writer is
+    // still running, so close() must not claim quiescence.
+    const closing = harness.coordinator.close();
+    await flush();
+    harness.clock.advance(100);
+    await expect(closing).resolves.toMatchObject({
+      ok: false,
+      error: { kind: "IDLE_TIMEOUT", operation: "CLOSE" },
+    });
+
+    release?.(realtimeSuccess(undefined));
+    void first;
+    void second;
+  });
+
   it("fences and aborts live, waits for quiescence, then recovers before activating poll", async () => {
     const liveEffect = deferred<RealtimeResult<void>>();
     const checkpoint = deferred<RealtimeResult<void>>();