diff --git a/apps/web/src/shell/provider-health-banner.tsx b/apps/web/src/shell/provider-health-banner.tsx
index d8d43e6fb..719e69778 100644
--- a/apps/web/src/shell/provider-health-banner.tsx
+++ b/apps/web/src/shell/provider-health-banner.tsx
@@ -8,6 +8,10 @@
 // consumption) — or, when the tenant has zero working providers,
 // routes to onboarding's credential step instead, since there is no
 // provider gallery worth opening yet.
+//
+// Chrome kinds (CL-6834): `unknown` (still polling), `error` (first-load
+// poll failed — not the same silence as healthy), `healthy` (ready and
+// nothing unhealthy), and `unhealthy` (guided Fix-it banner).
 
 import { Button } from "@corbits/react-ui";
 import { connectorDescriptors } from "@workbench/connections/registry";
@@ -20,9 +24,10 @@ import { matchesRoute, ONBOARDING_PATH, SETTINGS_PATH } from "../routes";
 import { WORKBENCH_PATH_PREFIX } from "../workbench-path";
 import {
   useDismissProviderHealthBanner,
-  useProviderHealthBanner,
+  useProviderHealthChrome,
   useRequestPluginsConnect,
   type ProviderHealthBannerState,
+  type ProviderHealthChrome,
 } from "./provider-health-context";
 
 const PLUGINS_PATH = "/plugins";
@@ -42,6 +47,8 @@ export function isProviderHealthRecoverySurface(path: string): boolean {
 // magic number repeated in two files.
 const COLLAPSE_TRANSITION_MS = 220;
 
+const POLL_ERROR_COPY = "Couldn't check provider health. Try again shortly.";
+
 // The connector registry's own `displayName` (`@workbench/connections/registry`,
 // the same browser-safe subpath `plugins.ts` already reads) — never a
 // reinvented title-case of the provider id, which mangles ids like
@@ -69,73 +76,113 @@ function bannerMessage(banner: ProviderHealthBannerState): string {
   return `${providerDisplayName(banner.provider)} ${CATEGORY_COPY[banner.category]}`;
 }
 
+type VisibleChrome =
+  | { readonly kind: "error" }
+  | { readonly kind: "unhealthy"; readonly banner: ProviderHealthBannerState };
+
+function visibleFromChrome(chrome: ProviderHealthChrome): VisibleChrome | null {
+  if (chrome.kind === "error") return { kind: "error" };
+  if (chrome.kind === "unhealthy") return chrome;
+  return null;
+}
+
 export function ProviderHealthBanner({ path }: { readonly path: string }) {
-  const banner = useProviderHealthBanner();
+  const chrome = useProviderHealthChrome();
   const dismiss = useDismissProviderHealthBanner();
   const requestPluginsConnect = useRequestPluginsConnect();
   const navigate = useNavigate();
 
+  const visible = visibleFromChrome(chrome);
+  // Stable deps for the cache effect — `visible` is a fresh object each
+  // render, so depending on it would loop (setState → re-render → new
+  // object → effect again).
+  const visibleKind = visible?.kind ?? null;
+  const unhealthyBanner = chrome.kind === "unhealthy" ? chrome.banner : null;
+
   // Keeps the banner's last-known content mounted for a moment after
-  // `banner` goes null, so the collapse/fade-out transition below has
+  // `visible` goes null, so the collapse/fade-out transition below has
   // something to animate away rather than the stage snapping shut
   // instantly — see the module comment on hard-shoving the stage this
-  // replaces. The `role="alert"` below still comes off the LIVE `banner`,
+  // replaces. The `role="alert"` below still comes off the LIVE chrome,
   // not this cache, so a screen reader never sees a stale alert linger.
-  const [cachedBanner, setCachedBanner] =
-    useState<ProviderHealthBannerState | null>(banner);
+  const [cachedVisible, setCachedVisible] = useState<VisibleChrome | null>(
+    visible,
+  );
   useEffect(() => {
-    if (banner !== null) {
-      setCachedBanner(banner);
+    if (visibleKind === "error") {
+      setCachedVisible({ kind: "error" });
+      return;
+    }
+    if (visibleKind === "unhealthy" && unhealthyBanner !== null) {
+      setCachedVisible({ kind: "unhealthy", banner: unhealthyBanner });
       return;
     }
     const timeout = setTimeout(
-      () => setCachedBanner(null),
+      () => setCachedVisible(null),
       COLLAPSE_TRANSITION_MS,
     );
     return () => clearTimeout(timeout);
-  }, [banner]);
+  }, [visibleKind, unhealthyBanner]);
 
-  const isOpen = banner !== null;
+  const isOpen = visible !== null;
 
   if (!isProviderHealthRecoverySurface(path)) {
     return null;
   }
 
   const handleFix = () => {
-    if (banner === null) return;
-    if (banner.zeroWorkingProviders) {
+    if (chrome.kind !== "unhealthy") return;
+    if (chrome.banner.zeroWorkingProviders) {
       navigate(ONBOARDING_PATH);
       return;
     }
-    requestPluginsConnect(banner.provider);
+    requestPluginsConnect(chrome.banner.provider);
     navigate(PLUGINS_PATH);
   };
 
+  // A ready all-clear still mounts a zero-size marker so tests (and any
+  // future chrome) can tell "actually healthy" from "unknown / not yet
+  // polled" without treating empty DOM as healthy (CL-6834).
+  if (chrome.kind === "healthy" && cachedVisible === null) {
+    return <div data-provider-health="healthy" hidden />;
+  }
+
+  if (chrome.kind === "unknown" && cachedVisible === null) {
+    return <div data-provider-health="unknown" hidden />;
+  }
+
   return (
     <div
       className={`provider-health-banner-collapse${isOpen ? " is-open" : ""}`}
+      data-provider-health={chrome.kind}
     >
       <div className="provider-health-banner-collapse-inner">
-        {cachedBanner !== null ? (
+        {cachedVisible !== null ? (
           <div
             className="provider-health-banner"
             role={isOpen ? "alert" : undefined}
           >
             <Warning className="provider-health-banner-icon" aria-hidden />
             <p className="provider-health-banner-text">
-              {bannerMessage(cachedBanner)}
+              {cachedVisible.kind === "error"
+                ? POLL_ERROR_COPY
+                : bannerMessage(cachedVisible.banner)}
             </p>
-            <Button size="sm" variant="primary" onClick={handleFix}>
-              Fix it
-            </Button>
-            <Button
-              variant="ghost"
-              size="sm"
-              onClick={dismiss}
-              aria-label="Dismiss"
-            >
-              <X aria-hidden />
-            </Button>
+            {cachedVisible.kind === "unhealthy" ? (
+              <>
+                <Button size="sm" variant="primary" onClick={handleFix}>
+                  Fix it
+                </Button>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  onClick={dismiss}
+                  aria-label="Dismiss"
+                >
+                  <X aria-hidden />
+                </Button>
+              </>
+            ) : null}
           </div>
         ) : null}
       </div>
diff --git a/apps/web/src/shell/provider-health-context.test.ts b/apps/web/src/shell/provider-health-context.test.ts
index cd472e0d0..180f8c685 100644
--- a/apps/web/src/shell/provider-health-context.test.ts
+++ b/apps/web/src/shell/provider-health-context.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
-import { deriveProviderHealthBanner } from "./provider-health-context";
+import {
+  deriveProviderHealthBanner,
+  deriveProviderHealthChrome,
+  nextProviderHealthPollStatus,
+} from "./provider-health-context";
 
 const RECORD = {
   status: "needs_attention" as const,
@@ -77,3 +81,59 @@ describe("deriveProviderHealthBanner", () => {
     );
   });
 });
+
+describe("nextProviderHealthPollStatus (CL-6834)", () => {
+  test("a successful poll always lands on ready", () => {
+    expect(nextProviderHealthPollStatus("unknown", "ok")).toBe("ready");
+    expect(nextProviderHealthPollStatus("error", "ok")).toBe("ready");
+    expect(nextProviderHealthPollStatus("ready", "ok")).toBe("ready");
+  });
+
+  test("first-load failure (unknown → fail) becomes error, not ready", () => {
+    expect(nextProviderHealthPollStatus("unknown", "fail")).toBe("error");
+  });
+
+  test("a failed poll after an error stays error until a success", () => {
+    expect(nextProviderHealthPollStatus("error", "fail")).toBe("error");
+  });
+
+  test("a failed poll after ready keeps ready so last-known state stays on screen", () => {
+    expect(nextProviderHealthPollStatus("ready", "fail")).toBe("ready");
+  });
+});
+
+describe("deriveProviderHealthChrome (CL-6834)", () => {
+  const unhealthyBanner = {
+    provider: "anthropic",
+    category: "credential_failure" as const,
+    zeroWorkingProviders: false,
+  };
+
+  test("unknown status is never healthy — empty providers are not 'all clear'", () => {
+    expect(deriveProviderHealthChrome("unknown", null)).toEqual({
+      kind: "unknown",
+    });
+    expect(deriveProviderHealthChrome("unknown", unhealthyBanner)).toEqual({
+      kind: "unknown",
+    });
+  });
+
+  test("error status is never healthy — first-load poll failure is not 'all clear'", () => {
+    expect(deriveProviderHealthChrome("error", null)).toEqual({
+      kind: "error",
+    });
+  });
+
+  test("ready with no banner is healthy", () => {
+    expect(deriveProviderHealthChrome("ready", null)).toEqual({
+      kind: "healthy",
+    });
+  });
+
+  test("ready with an undismissed incident is unhealthy", () => {
+    expect(deriveProviderHealthChrome("ready", unhealthyBanner)).toEqual({
+      kind: "unhealthy",
+      banner: unhealthyBanner,
+    });
+  });
+});
diff --git a/apps/web/src/shell/provider-health-context.tsx b/apps/web/src/shell/provider-health-context.tsx
index 8a7c36f2e..0aa1c0f4b 100644
--- a/apps/web/src/shell/provider-health-context.tsx
+++ b/apps/web/src/shell/provider-health-context.tsx
@@ -13,6 +13,13 @@
 // provider's banner remembers the record's own `at` timestamp, so a
 // *new* failure for the same provider (a later `at`) shows the banner
 // again — matching CL-6092's "reappears on a new failure" rule.
+//
+// Poll status (CL-6834): empty `providers` alone is not "all healthy".
+// The chrome distinguishes `unknown` (no successful poll yet), `error`
+// (first-load / never-ready poll failure), and `ready` (a snapshot has
+// landed). A failed poll after `ready` keeps last-known providers on
+// screen; a failed poll before any success becomes `error` so the
+// chrome can show unknown/error rather than a silent all-clear.
 
 import {
   createContext,
@@ -43,7 +50,24 @@ export type ProviderHealthBannerState = {
   readonly zeroWorkingProviders: boolean;
 };
 
+/** Whether the shell has a usable health snapshot yet (CL-6834). */
+export type ProviderHealthPollStatus = "unknown" | "ready" | "error";
+
+/**
+ * What health chrome should present — never collapse "no snapshot yet"
+ * or "poll failed" into the same silence as "ready and nothing unhealthy".
+ */
+export type ProviderHealthChrome =
+  | { readonly kind: "unknown" }
+  | { readonly kind: "error" }
+  | { readonly kind: "healthy" }
+  | {
+      readonly kind: "unhealthy";
+      readonly banner: ProviderHealthBannerState;
+    };
+
 type ProviderHealthContextValue = {
+  readonly status: ProviderHealthPollStatus;
   readonly banner: ProviderHealthBannerState | null;
   readonly dismissBanner: () => void;
   readonly pendingConnectProvider: string | null;
@@ -93,6 +117,36 @@ export function deriveProviderHealthBanner(
   };
 }
 
+/**
+ * Next poll-status after one fetch outcome (CL-6834). Success always
+ * becomes `ready`. Failure before any success becomes `error` (so empty
+ * providers are not read as healthy). Failure after `ready` stays
+ * `ready` so last-known state remains on screen for the next retry.
+ */
+export function nextProviderHealthPollStatus(
+  current: ProviderHealthPollStatus,
+  outcome: "ok" | "fail",
+): ProviderHealthPollStatus {
+  if (outcome === "ok") return "ready";
+  if (current === "ready") return "ready";
+  return "error";
+}
+
+/**
+ * Maps poll status + the (possibly null) unhealthy banner into chrome
+ * the shell can render. Empty providers under `unknown`/`error` are
+ * never `healthy` (CL-6834).
+ */
+export function deriveProviderHealthChrome(
+  status: ProviderHealthPollStatus,
+  banner: ProviderHealthBannerState | null,
+): ProviderHealthChrome {
+  if (status === "unknown") return { kind: "unknown" };
+  if (status === "error") return { kind: "error" };
+  if (banner === null) return { kind: "healthy" };
+  return { kind: "unhealthy", banner };
+}
+
 export function ProviderHealthProvider({
   children,
 }: {
@@ -105,6 +159,7 @@ export function ProviderHealthProvider({
   const [connectedProviderCount, setConnectedProviderCount] = useState<
     number | undefined
   >(undefined);
+  const [status, setStatus] = useState<ProviderHealthPollStatus>("unknown");
   // Keyed by provider, remembers the `at` of the incident a person last
   // dismissed — so a later `at` for the same provider is a NEW incident,
   // not a re-show of one already acknowledged.
@@ -117,24 +172,40 @@ export function ProviderHealthProvider({
 
   const tenantIdRef = useRef(selectedTenantId);
   tenantIdRef.current = selectedTenantId;
+  const statusRef = useRef(status);
+  statusRef.current = status;
 
   useEffect(() => {
     if (selectedTenantId === null) {
       setProviders({});
       setConnectedProviderCount(undefined);
+      setStatus("unknown");
+      statusRef.current = "unknown";
       return;
     }
     let cancelled = false;
+    setStatus("unknown");
+    statusRef.current = "unknown";
+    setProviders({});
+    setConnectedProviderCount(undefined);
     const poll = () => {
       fetchProviderHealth(selectedTenantId)
         .then((snapshot) => {
           if (cancelled || tenantIdRef.current !== selectedTenantId) return;
           setProviders(snapshot.providers);
           setConnectedProviderCount(snapshot.connectedProviderCount);
+          const next = nextProviderHealthPollStatus(statusRef.current, "ok");
+          statusRef.current = next;
+          setStatus(next);
         })
         .catch(() => {
-          // A failed poll leaves the last-known state on screen rather
-          // than flashing the banner away — the next poll retries.
+          if (cancelled || tenantIdRef.current !== selectedTenantId) return;
+          // First-load failure → error (empty providers must not look
+          // healthy). After a successful poll, leave last-known providers
+          // and stay ready — the next interval retries.
+          const next = nextProviderHealthPollStatus(statusRef.current, "fail");
+          statusRef.current = next;
+          setStatus(next);
         });
     };
     poll();
@@ -162,15 +233,19 @@ export function ProviderHealthProvider({
     setPendingConnectProvider(null);
   }, []);
 
-  const banner = deriveProviderHealthBanner(
-    providers,
-    dismissedAt,
-    connectedProviderCount,
-  );
+  const banner =
+    status === "ready"
+      ? deriveProviderHealthBanner(
+          providers,
+          dismissedAt,
+          connectedProviderCount,
+        )
+      : null;
 
   return (
     <ProviderHealthContext.Provider
       value={{
+        status,
         banner,
         dismissBanner,
         pendingConnectProvider,
@@ -197,6 +272,18 @@ export function useProviderHealthBanner(): ProviderHealthBannerState | null {
   return useProviderHealthContext().banner;
 }
 
+/** Poll readiness (CL-6834) — consumers that used to treat a null banner
+ * as "all healthy" must check this: `unknown`/`error` are not healthy. */
+export function useProviderHealthStatus(): ProviderHealthPollStatus {
+  return useProviderHealthContext().status;
+}
+
+/** Chrome discriminant (CL-6834) — unknown / error / healthy / unhealthy. */
+export function useProviderHealthChrome(): ProviderHealthChrome {
+  const { status, banner } = useProviderHealthContext();
+  return deriveProviderHealthChrome(status, banner);
+}
+
 export function useDismissProviderHealthBanner(): () => void {
   return useProviderHealthContext().dismissBanner;
 }
diff --git a/apps/web/test/provider-health-banner.test.tsx b/apps/web/test/provider-health-banner.test.tsx
index cfab23d27..3bc0b81fb 100644
--- a/apps/web/test/provider-health-banner.test.tsx
+++ b/apps/web/test/provider-health-banner.test.tsx
@@ -101,6 +101,20 @@ async function flush(): Promise<void> {
   }
 }
 
+/** Same flush loop, but waits for a specific `data-provider-health` marker
+ * (CL-6834) — used when the chrome settles without an alert (healthy) or
+ * with an error marker rather than an unhealthy-provider alert. */
+async function flushForHealthMarker(marker: string): Promise<void> {
+  for (let i = 0; i < 20; i += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    if (document.querySelector(`[data-provider-health="${marker}"]`) !== null) {
+      return;
+    }
+  }
+}
+
 function findByText(
   container: HTMLElement,
   text: string,
@@ -247,9 +261,41 @@ describe("ProviderHealthBanner (CL-6092)", () => {
   test("renders nothing when no provider is unhealthy", async () => {
     stubFetch({ providers: {}, connectedProviderCount: 2 });
     await mount(() => undefined);
-    await flush();
+    await flushForHealthMarker("healthy");
 
     expect(container.querySelector('[role="alert"]')).toBeNull();
+    expect(
+      container.querySelector('[data-provider-health="healthy"]'),
+    ).not.toBeNull();
+  });
+
+  // CL-6834: a failed first poll used to leave providers at {}, which the
+  // chrome treated the same as "ready and nothing unhealthy" — so an
+  // unreachable health endpoint looked like every provider was fine.
+  test("first-load poll failure shows error chrome, not a silent healthy state", async () => {
+    globalThis.fetch = ((input: RequestInfo | URL) => {
+      const path = typeof input === "string" ? input : String(input);
+      if (path.includes("/api/me/principals"))
+        return Promise.resolve(json(membership));
+      if (path.includes("/connections/provider-health"))
+        return Promise.reject(new Error("network down"));
+      return Promise.resolve(json({ items: [] }));
+    }) as typeof fetch;
+
+    await mount(() => undefined);
+    await flushForHealthMarker("error");
+
+    expect(
+      container.querySelector('[data-provider-health="error"]'),
+    ).not.toBeNull();
+    expect(container.querySelector('[role="alert"]')).not.toBeNull();
+    expect(container.textContent).toContain("Couldn't check provider health");
+    // Not the guided unhealthy-provider copy — there is no incident to fix.
+    expect(container.textContent).not.toContain("turned down your key.");
+    expect(findByText(container, "Fix it")).toBeUndefined();
+    expect(
+      container.querySelector('[data-provider-health="healthy"]'),
+    ).toBeNull();
   });
 });