Skip open circuit failure writes

Return early when recording a failure for a host whose circuit is already
open.  The state and failure history are unchanged in that case, so avoiding
the CAS prevents redundant KV writes.

#778 (comment)

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/fedify/src/federation/circuit-breaker.test.ts

@@ -24,6 +24,20 @@ class AlwaysConflictingKvStore extends MemoryKvStore {
   }
 }
 
+class CountingCasKvStore extends MemoryKvStore {
+  attempts = 0;
+
+  override cas(
+    key: KvKey,
+    expectedValue: unknown,
+    newValue: unknown,
+    options?: KvStoreSetOptions,
+  ): Promise<boolean> {
+    this.attempts++;
+    return super.cas(key, expectedValue, newValue, options);
+  }
+}
+
 test("normalizeCircuitBreakerOptions() uses numeric failure policy", () => {
   const options = normalizeCircuitBreakerOptions({
     failureThreshold: 3,
@@ -468,6 +482,31 @@ test("CircuitBreaker bounds beforeSend CAS retries", async () => {
   });
 });
 
+test("CircuitBreaker skips recording failures for open circuits", async () => {
+  const kv = new CountingCasKvStore();
+  const circuit = new CircuitBreaker({
+    kv,
+    prefix: ["_fedify", "circuit"],
+    now: () => Temporal.Instant.from("2026-05-25T00:01:00Z"),
+  });
+  await kv.set(["_fedify", "circuit", "open.example"], {
+    state: "open",
+    failures: ["2026-05-25T00:00:00Z"],
+    opened: "2026-05-25T00:00:00Z",
+  });
+
+  assertEquals(await circuit.recordFailure("open.example"), undefined);
+  assertEquals(kv.attempts, 0);
+  assertEquals(
+    await kv.get(["_fedify", "circuit", "open.example"]),
+    {
+      state: "open",
+      failures: ["2026-05-25T00:00:00Z"],
+      opened: "2026-05-25T00:00:00Z",
+    },
+  );
+});
+
 test("CircuitBreaker prunes stale closed failure history", async () => {
   const kv = new MemoryKvStore();
   let now = Temporal.Instant.from("2026-05-25T00:00:00Z");

packages/fedify/src/federation/circuit-breaker.ts

@@ -336,16 +336,15 @@ export class CircuitBreaker {
     const now = this.#now();
     for (let attempt = 0; attempt < 10; attempt++) {
       const oldState = await this.#get(remoteHost);
+      if (oldState?.state === "open") return undefined;
       const oldFailures = oldState?.failures.map(Temporal.Instant.from) ?? [];
       const failures = this.#options.pruneFailures(
         [...oldFailures, now],
         now,
       );
       let newState: CircuitBreakerKvState;
       let transition: [CircuitBreakerState, CircuitBreakerState] | undefined;
-      if (oldState?.state === "open") {
-        newState = oldState;
-      } else if (
+      if (
         oldState?.state === "half-open" || this.#options.failure(failures)
       ) {
         newState = {