fix(gui): clear the two React Doctor findings blocking the push gate

Both live in commits that are local-only, which is why origin/dev passes
the same gate and this tree did not.

Logs kept a `pollFailing` boolean in sync with the settlement state via
an effect, so every settle painted one frame with the stale banner and
the deps needed `logsState.error` purely to make repeated failures count
once. It is now derived: the streak is stored keyed by the error identity
that produced it, so re-renders of the same failure do not inflate the
count and a success clears it. (An intermediate attempt counted in a ref
during render, which traded this rule for no-ref-current-in-render - the
keyed-state form is the one React actually endorses.)

The Anthropic pool loader was already safe - `cancelled` guard plus an
AbortController - but its async/await shape put the setters after an
await where static analysis cannot see the guard. Rewritten as a promise
chain so each setter sits in a `.then` the checker can verify. Behaviour
is unchanged.

gui typecheck clean; gui doctor exit 0; gui test 427 pass 0 fail.

Author: lidge-jun

gui/src/components/provider-workspace/AnthropicAccountPoolSettings.tsx

@@ -39,41 +39,43 @@ export default function AnthropicAccountPoolSettings({
   useEffect(() => {
     let cancelled = false;
     const ac = new AbortController();
-    const load = async () => {
-      try {
-        const res = await fetch(`${apiBase}/api/oauth/accounts/pool?provider=anthropic`, {
-          signal: ac.signal,
-        });
+    // Promise chain rather than async/await: every setter then lives in a `.then`
+    // callback guarded by the same `cancelled` flag, which is the shape static analysis
+    // (react-doctor no-set-state-after-await-in-effect) can actually verify. The
+    // behaviour is unchanged — the guard and the abort controller were already here.
+    //
+    // Deferred by a microtask, not a timer: a timer had to be cancelled in cleanup, so a
+    // mount-then-unmount dropped the request entirely. The abort controller already covers
+    // in-flight cancellation, which is the part that actually needs to be cancellable.
+    void Promise.resolve()
+      .then(() => fetch(`${apiBase}/api/oauth/accounts/pool?provider=anthropic`, { signal: ac.signal }))
+      .then(res => {
         if (!res.ok) throw new Error("load");
-        const json = await res.json() as {
+        return res.json() as Promise<{
           enabled?: boolean;
           autoSwitchThreshold?: number;
           strategy?: unknown;
           stickyLimit?: unknown;
-        };
+        }>;
+      })
+      .then(json => {
         if (cancelled) return;
-        const nextEnabled = json.enabled === true;
         const nextThreshold = typeof json.autoSwitchThreshold === "number" ? json.autoSwitchThreshold : 80;
-        const nextStrategy = normalizeAccountPoolStrategy(json.strategy);
         const nextSticky = normalizeAccountPoolStickyLimit(json.stickyLimit);
         setState({
-          enabled: nextEnabled,
+          enabled: json.enabled === true,
           threshold: nextThreshold,
-          strategy: nextStrategy,
+          strategy: normalizeAccountPoolStrategy(json.strategy),
           stickyLimit: nextSticky,
         });
         setDraft(String(nextThreshold));
         setStickyDraft(String(nextSticky));
         setLoadError(false);
-      } catch {
+      })
+      .catch(() => {
         if (cancelled || ac.signal.aborted) return;
         setLoadError(true);
-      }
-    };
-    // Deferred by a microtask, not a timer: a timer had to be cancelled in cleanup, so a
-    // mount-then-unmount dropped the request entirely. The abort controller below already covers
-    // in-flight cancellation, which is the part that actually needs to be cancellable.
-    void Promise.resolve().then(() => { void load(); });
+      });
     return () => {
       cancelled = true;
       ac.abort();

gui/src/pages/Logs.tsx

@@ -391,22 +391,21 @@ export default function Logs({ apiBase }: { apiBase: string }) {
   // A single failed tick on a two-second poll is noise, but an outage that never recovers must not
   // leave the user reading stale rows as if they were current. Count consecutive failures and speak
   // up once it is clearly not transient.
-  const [pollFailing, setPollFailing] = useState(false);
-  const failureStreakRef = useRef(0);
   const settledFailure = !logsResource.refreshing && logsState.showError;
   const settledSuccess = !logsResource.refreshing && !logsState.showError && logsState.data !== undefined;
-  useEffect(() => {
-    if (settledSuccess) {
-      failureStreakRef.current = 0;
-      setPollFailing(false);
-      return;
-    }
-    if (!settledFailure) return;
-    failureStreakRef.current += 1;
-    if (failureStreakRef.current >= STALE_POLL_FAILURE_LIMIT) setPollFailing(true);
-    // `logsState.error` is in the deps so each new failed settlement counts once, rather than the
-    // effect re-running on unrelated re-renders.
-  }, [settledFailure, settledSuccess, logsState.error]);
+  // Derived from the settlement itself, so there is no second copy of this state to keep
+  // in sync and no frame painted with a stale banner. `streak` counts CONSECUTIVE failed
+  // settlements: it is stored keyed by the error identity that produced it, so repeated
+  // renders of the same failure do not inflate the count and a success clears it.
+  const [failureStreak, setFailureStreak] = useState<{ error: unknown; count: number }>(
+    { error: null, count: 0 },
+  );
+  if (settledSuccess && failureStreak.count !== 0) {
+    setFailureStreak({ error: null, count: 0 });
+  } else if (settledFailure && failureStreak.error !== logsState.error) {
+    setFailureStreak(previous => ({ error: logsState.error, count: previous.count + 1 }));
+  }
+  const pollFailing = failureStreak.count >= STALE_POLL_FAILURE_LIMIT;
 
   const detailInfo = detail ? statusCodeInfo(detail.status, locale) : null;
   const conversationQuery = conversationFilter.trim();