diff --git a/src/app/globals.css b/src/app/globals.css
index 88624cfc7d..1d282af1d0 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -543,24 +543,17 @@ summary::-webkit-details-marker {
     isolation: isolate;
     padding-left: max(0.75rem, var(--safe-area-left));
     padding-right: max(0.75rem, var(--safe-area-right));
-    border-bottom: 1px solid var(--border);
-    background: var(--surface);
+    /* Translucent glass bar: the header's backdrop-blur utilities frost the
+       content scrolling beneath it (they were inert over the old opaque
+       var(--surface)). The .edge-glass-header-backdrop scrim supersedes the
+       old hard border-bottom and below-header ::after gradient. Keep this
+       value in lock-step with .universal-header below (chrome parity). */
+    background: color-mix(in srgb, var(--surface) 72%, transparent);
     box-shadow: none;
   }
 
-  .edge-glass-header::after {
-    pointer-events: none;
-    position: absolute;
-    inset-inline: 0;
-    bottom: -1.25rem;
-    z-index: -1;
-    height: 1.25rem;
-    background: linear-gradient(180deg, color-mix(in srgb, var(--background) 54%, transparent), transparent);
-    content: "";
-  }
-
   .universal-header {
-    background: var(--surface);
+    background: color-mix(in srgb, var(--surface) 72%, transparent);
   }
 
   .universal-header-mode-button {
@@ -663,6 +656,71 @@ summary::-webkit-details-marker {
   }
 }
 
+/* Top progressive-blur scrim behind the glass header — the vertical mirror of
+   the bottom dock's .answer-footer-search-backdrop three-pass blur below.
+   Strongest blur/tint hugs the physical top edge (status-bar/notch band via
+   safe-area-inset-top) and fades downward into content, so scrolling text
+   frosts as it slides under the bar. Lives INSIDE <header> (first child) so it
+   translates away with the header on scroll-hide. Unlayered on purpose, like
+   the rest of the positioning chrome (see the layering note above). */
+.edge-glass-header-backdrop {
+  pointer-events: none;
+  position: absolute;
+  inset-inline: 0;
+  top: 0;
+  z-index: -1;
+  height: max(6.5rem, calc(var(--safe-area-top) + 5.5rem));
+  overflow: hidden;
+  background: linear-gradient(
+    180deg,
+    color-mix(in srgb, var(--background) 42%, transparent) 0%,
+    color-mix(in srgb, var(--background) 32%, transparent) 12%,
+    color-mix(in srgb, var(--background) 18%, transparent) 32%,
+    color-mix(in srgb, var(--background) 8%, transparent) 62%,
+    transparent 100%
+  );
+  backdrop-filter: blur(2px) saturate(130%);
+  -webkit-backdrop-filter: blur(2px) saturate(130%);
+  mask-image: linear-gradient(180deg, black 0%, black 45%, rgb(0 0 0 / 45%) 72%, rgb(0 0 0 / 20%) 100%);
+  -webkit-mask-image: linear-gradient(180deg, black 0%, black 45%, rgb(0 0 0 / 45%) 72%, rgb(0 0 0 / 20%) 100%);
+}
+
+.edge-glass-header-backdrop::before,
+.edge-glass-header-backdrop::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+}
+
+.edge-glass-header-backdrop::before {
+  backdrop-filter: blur(8px) saturate(130%);
+  -webkit-backdrop-filter: blur(8px) saturate(130%);
+  mask-image: linear-gradient(
+    180deg,
+    black 0%,
+    black 20%,
+    rgb(0 0 0 / 55%) 45%,
+    rgb(0 0 0 / 35%) 65%,
+    transparent 100%
+  );
+  -webkit-mask-image: linear-gradient(
+    180deg,
+    black 0%,
+    black 20%,
+    rgb(0 0 0 / 55%) 45%,
+    rgb(0 0 0 / 35%) 65%,
+    transparent 100%
+  );
+}
+
+.edge-glass-header-backdrop::after {
+  backdrop-filter: blur(22px) saturate(140%);
+  -webkit-backdrop-filter: blur(22px) saturate(140%);
+  mask-image: linear-gradient(180deg, black 0%, black 32%, transparent 50%, transparent 100%);
+  -webkit-mask-image: linear-gradient(180deg, black 0%, black 32%, transparent 50%, transparent 100%);
+}
+
 .answer-footer-search-backdrop {
   pointer-events: none;
   position: fixed;
@@ -787,6 +845,30 @@ summary::-webkit-details-marker {
       color-mix(in srgb, var(--background) 92%, transparent) 100%
     );
   }
+
+  /* No blur available: the glass header goes opaque so text never sits on
+     un-frosted scrolled content, and the top scrim swaps to a stronger tint. */
+  .edge-glass-header-backdrop,
+  .edge-glass-header-backdrop::before,
+  .edge-glass-header-backdrop::after {
+    backdrop-filter: none;
+    -webkit-backdrop-filter: none;
+  }
+
+  .edge-glass-header-backdrop {
+    background: linear-gradient(
+      180deg,
+      color-mix(in srgb, var(--background) 92%, transparent) 0%,
+      color-mix(in srgb, var(--background) 78%, transparent) 40%,
+      color-mix(in srgb, var(--background) 45%, transparent) 72%,
+      transparent 100%
+    );
+  }
+
+  .edge-glass-header,
+  .universal-header {
+    background: var(--surface);
+  }
 }
 
 @media (prefers-reduced-transparency: reduce) {
@@ -806,6 +888,29 @@ summary::-webkit-details-marker {
       color-mix(in srgb, var(--background) 94%, transparent) 100%
     );
   }
+
+  /* Reduced transparency: same opaque-bar treatment as the no-blur fallback. */
+  .edge-glass-header-backdrop,
+  .edge-glass-header-backdrop::before,
+  .edge-glass-header-backdrop::after {
+    backdrop-filter: none;
+    -webkit-backdrop-filter: none;
+  }
+
+  .edge-glass-header-backdrop {
+    background: linear-gradient(
+      180deg,
+      color-mix(in srgb, var(--background) 94%, transparent) 0%,
+      color-mix(in srgb, var(--background) 82%, transparent) 42%,
+      color-mix(in srgb, var(--background) 50%, transparent) 74%,
+      transparent 100%
+    );
+  }
+
+  .edge-glass-header,
+  .universal-header {
+    background: var(--surface);
+  }
 }
 
 @layer components {
@@ -2002,6 +2107,23 @@ summary::-webkit-details-marker {
   select {
     forced-color-adjust: auto;
   }
+
+  /* Glass header: color-mix(Canvas, transparent) would thin system-color
+     contrast, so force a solid Canvas bar and drop the scrim blur entirely. */
+  .edge-glass-header,
+  .universal-header {
+    background: Canvas;
+  }
+
+  .edge-glass-header-backdrop,
+  .edge-glass-header-backdrop::before,
+  .edge-glass-header-backdrop::after {
+    background: Canvas;
+    backdrop-filter: none;
+    -webkit-backdrop-filter: none;
+    mask-image: none;
+    -webkit-mask-image: none;
+  }
 }
 
 @media print {
diff --git a/src/components/ClinicalDashboard.tsx b/src/components/ClinicalDashboard.tsx
index 218fa3b409..83a5386815 100644
--- a/src/components/ClinicalDashboard.tsx
+++ b/src/components/ClinicalDashboard.tsx
@@ -709,9 +709,6 @@ export function ClinicalDashboard({
     mainRef.current = node;
     setMainScrollRoot(node);
   }, []);
-  const phoneScrollHide = useScrollHideReporter();
-  const reportPhoneScrollHideRef = useRef(phoneScrollHide.reportScroll);
-  reportPhoneScrollHideRef.current = phoneScrollHide.reportScroll;
   const [bottomSearchScrollHidden, setBottomSearchScrollHidden] = useState(false);
   const composerInputRef = useRef<HTMLInputElement>(null);
   const scrollFrameRef = useRef<number | null>(null);
@@ -737,6 +734,12 @@ export function ClinicalDashboard({
   const [answerThreadBootstrapped, setAnswerThreadBootstrapped] = useState(false);
   const [query, setQuery] = useState(initialQuery);
   const [searchMode, setSearchMode] = useState<AppModeId>(initialSearchMode);
+  // Answer mode hides the glass header at every breakpoint (all-breakpoints
+  // overlay); other modes keep the phone-only collapse, so the reporter only
+  // widens past the phone media gate while in answer mode.
+  const phoneScrollHide = useScrollHideReporter(false, searchMode === "answer");
+  const reportPhoneScrollHideRef = useRef(phoneScrollHide.reportScroll);
+  reportPhoneScrollHideRef.current = phoneScrollHide.reportScroll;
   const [modeSearchSubmitted, setModeSearchSubmitted] = useState(() =>
     Boolean(autoRunSearch && initialQuery.trim() && initialSearchMode !== "tools"),
   );
@@ -3465,7 +3468,7 @@ export function ClinicalDashboard({
         onPrefetchApplications={prefetchApplications}
       />
 
-      <div className="flex min-h-0 min-w-0 flex-1 flex-col md:h-full">
+      <div className="relative flex min-h-0 min-w-0 flex-1 flex-col md:h-full">
         <MasterSearchHeader
           documents={documents}
           documentTotal={indexedDocumentTotal}
@@ -3518,33 +3521,19 @@ export function ClinicalDashboard({
             differentialsCompareAddonActive ? differentialsMobileCompareAddonSlotId : undefined
           }
           desktopHomeComposerSlotId={desktopHomeComposerSlotId}
-          // Phone-only: the header sits above the internally scrolling <main>,
-          // so hiding must collapse its layout space to hand it to content.
-          hideOnScroll={{ strategy: "collapse", scrollHidden: phoneScrollHide.hidden }}
+          // Answer view: the header overlays the scrolling <main> at every width
+          // (main reserves matching top padding) so content frosts under the
+          // glass bar, and it slides away/returns with scroll direction. Other
+          // modes keep the phone-only collapse (their sm+ composer renders
+          // in-flow below the header, which an absolute header would bury).
+          hideOnScroll={
+            searchMode === "answer"
+              ? { strategy: "overlay", allBreakpoints: true, scrollHidden: phoneScrollHide.hidden }
+              : { strategy: "collapse", scrollHidden: phoneScrollHide.hidden }
+          }
           onBottomComposerScrollHiddenChange={setBottomSearchScrollHidden}
         />
 
-        {privateScopeStatus === "unavailable" ? (
-          <div
-            role="alert"
-            data-testid="private-scope-unavailable"
-            className="mx-3 mt-3 flex flex-wrap items-center justify-between gap-3 rounded-lg border border-[color:var(--warning-border)] bg-[color:var(--warning-soft)] px-3 py-2 text-sm text-[color:var(--text)] sm:mx-4 lg:mx-8"
-          >
-            <p>
-              The original private document scope is unavailable. Choose the documents again or confirm a broader
-              search.
-            </p>
-            <div className="flex flex-wrap gap-2">
-              <button type="button" className={floatingControl} onClick={reselectUnavailablePrivateScope}>
-                Reselect documents
-              </button>
-              <button type="button" className={floatingControl} onClick={runWithoutUnavailablePrivateScope}>
-                Run without private scope
-              </button>
-            </div>
-          </div>
-        ) : null}
-
         <main
           id="main-content"
           ref={assignMainRef}
@@ -3552,6 +3541,18 @@ export function ClinicalDashboard({
           onScroll={handleMainScroll}
           className={cn(
             "min-h-0 flex-1 overflow-x-hidden overflow-y-auto overscroll-contain [-webkit-overflow-scrolling:touch] focus:outline-none",
+            // Answer view: the glass header is absolute over this scroll container,
+            // so <main> reserves its exact height as top padding (72px borderless
+            // bar = 4rem content/padding + the max(0.5rem, safe-area) top inset —
+            // measured; must stay 1:1 with the rendered #search height so all the
+            // dvh-based section floors below keep their meaning). Padding, not
+            // margin: padding scrolls with content, which is what lets it slide
+            // up and frost beneath the bar. Kept constant when the header
+            // scroll-hides — the reserve lives at scroll-start, already off-screen
+            // whenever the header is hidden, so reclaiming it would only jump
+            // the content.
+            searchMode === "answer" &&
+              "pt-[calc(4rem+max(0.5rem,env(safe-area-inset-top)))] [scroll-padding-top:calc(4.5rem+max(0.5rem,env(safe-area-inset-top)))]",
             searchMode === "answer"
               ? compactMobileModeHome
                 ? "mb-0"
@@ -3584,6 +3585,29 @@ export function ClinicalDashboard({
           )}
         >
           <h1 className="sr-only">Clinical Guide</h1>
+          {privateScopeStatus === "unavailable" ? (
+            // Lives inside <main> (not as a header sibling): in the answer view
+            // the header is absolute, so a sibling alert would reflow to the
+            // column top and hide behind the glass bar.
+            <div
+              role="alert"
+              data-testid="private-scope-unavailable"
+              className="mx-3 mt-3 flex flex-wrap items-center justify-between gap-3 rounded-lg border border-[color:var(--warning-border)] bg-[color:var(--warning-soft)] px-3 py-2 text-sm text-[color:var(--text)] sm:mx-4 lg:mx-8"
+            >
+              <p>
+                The original private document scope is unavailable. Choose the documents again or confirm a broader
+                search.
+              </p>
+              <div className="flex flex-wrap gap-2">
+                <button type="button" className={floatingControl} onClick={reselectUnavailablePrivateScope}>
+                  Reselect documents
+                </button>
+                <button type="button" className={floatingControl} onClick={runWithoutUnavailablePrivateScope}>
+                  Run without private scope
+                </button>
+              </div>
+            </div>
+          ) : null}
           <SearchCommandProvider value={searchCommandContextValue}>
             <div
               className={cn(
diff --git a/src/components/clinical-dashboard/master-search-header.tsx b/src/components/clinical-dashboard/master-search-header.tsx
index 6504471f90..a2602dcd59 100644
--- a/src/components/clinical-dashboard/master-search-header.tsx
+++ b/src/components/clinical-dashboard/master-search-header.tsx
@@ -245,6 +245,12 @@ export function MasterSearchHeader({
    *  `useScrollHideReporter` wired to that element's scroll events. */
   hideOnScroll?: {
     strategy: "overlay" | "collapse";
+    /**
+     * Overlay-only: apply the hide/reveal (and the out-of-flow absolute header)
+     * at every breakpoint instead of phones only. The host must reserve
+     * matching top padding on its scroll container.
+     */
+    allBreakpoints?: boolean;
     /** Parent-owned hidden state for hosts that report scroll via React `onScroll`. */
     scrollHidden?: boolean;
   };
@@ -1388,6 +1394,10 @@ export function MasterSearchHeader({
   }
 
   const hideStrategy = hideOnScroll?.strategy;
+  // Overlay hosts that opt into all breakpoints take the header fully out of
+  // flow (absolute over the scrolling <main>, which reserves matching top
+  // padding) so content frosts under the glass bar at every width.
+  const overlayAllBreakpoints = hideStrategy === "overlay" && Boolean(hideOnScroll?.allBreakpoints);
   const chromeFocusProps = hideOnScroll
     ? {
         onFocusCapture: () => setHeaderChromeFocused(true),
@@ -1409,22 +1419,35 @@ export function MasterSearchHeader({
     <>
       <header
         id="search"
+        data-scroll-hidden={hideStrategy === "overlay" && headerChromeHidden ? "true" : undefined}
         className={cn(
-          "edge-glass-header universal-header z-30 border-b border-[color:var(--border)] py-2 pt-[max(0.5rem,env(safe-area-inset-top))] text-[color:var(--text)] backdrop-blur-xl",
+          "edge-glass-header universal-header z-30 py-2 pt-[max(0.5rem,env(safe-area-inset-top))] text-[color:var(--text)] backdrop-blur-xl backdrop-saturate-150",
           // Collapse hosts keep the header above an internally scrolling <main>, so
           // sticky is unnecessary on phones and fights the 0fr grid collapse by
-          // pinning the bar inside the viewport. Overlay hosts need sticky so the
-          // header rides document scroll and can translate away with zero layout shift.
-          hideStrategy === "collapse" ? "max-sm:relative sm:sticky sm:top-0" : "sticky top-0",
-          // Overlay hide-on-scroll (phones): a plain translate reveals the content
-          // already flowing beneath it. No transform is applied while visible so
-          // the fixed-position mobile mode menu keeps the viewport as its containing block.
+          // pinning the bar inside the viewport. All-breakpoints overlay hosts take
+          // the header out of flow entirely (absolute over the padded <main>) —
+          // sticky would be inert there because the scroll container is <main>, not
+          // an ancestor of the header. Legacy overlay hosts keep sticky (they ride
+          // document scroll) and can translate away with zero layout shift.
+          hideStrategy === "collapse"
+            ? "max-sm:relative sm:sticky sm:top-0"
+            : overlayAllBreakpoints
+              ? "absolute inset-x-0 top-0"
+              : "sticky top-0",
+          // Overlay hide-on-scroll: a plain translate reveals the content already
+          // flowing beneath it. No transform is applied while visible so the
+          // fixed-position mobile mode menu keeps the viewport as its containing block.
           hideStrategy === "overlay" &&
-            "max-sm:transition-transform max-sm:duration-200 max-sm:ease-out motion-reduce:transition-none",
-          hideStrategy === "overlay" && headerChromeHidden && "max-sm:-translate-y-full",
+            (overlayAllBreakpoints
+              ? "transition-transform duration-200 ease-out motion-reduce:transition-none"
+              : "max-sm:transition-transform max-sm:duration-200 max-sm:ease-out motion-reduce:transition-none"),
+          hideStrategy === "overlay" &&
+            headerChromeHidden &&
+            (overlayAllBreakpoints ? "-translate-y-full" : "max-sm:-translate-y-full"),
         )}
         {...(hideStrategy === "overlay" ? chromeFocusProps : undefined)}
       >
+        <div className="edge-glass-header-backdrop" aria-hidden="true" />
         <div
           className={cn(
             "relative mx-auto grid min-h-14 grid-cols-[auto_minmax(0,1fr)_auto] items-center gap-2 sm:gap-3",
diff --git a/src/components/clinical-dashboard/use-hide-on-scroll.ts b/src/components/clinical-dashboard/use-hide-on-scroll.ts
index 99bf6b1307..b2d04eb28e 100644
--- a/src/components/clinical-dashboard/use-hide-on-scroll.ts
+++ b/src/components/clinical-dashboard/use-hide-on-scroll.ts
@@ -3,12 +3,14 @@
 import { useCallback, useEffect, useRef, useState, useSyncExternalStore, type RefObject } from "react";
 
 // Matches phoneSearchLayoutMediaQuery in master-search-header.tsx — the repo's
-// phone/tablet seam. Hide-on-scroll only ever runs below the sm breakpoint.
+// phone/tablet seam. Hide-on-scroll runs below the sm breakpoint unless the
+// host opts into all breakpoints (the ClinicalDashboard glass-header overlay).
 const phoneMediaQuery = "(max-width: 639px)";
 
-// Scroll offset (px) that must be passed before the chrome may hide; roughly
-// the header's own height so it never vanishes while still fully in view.
-const hideActivationOffset = 56;
+// Scroll offset (px) that must be passed before the chrome may hide; the
+// header's own height (72px borderless bar; <main> reserves the same strip)
+// so it never vanishes while its reserve is still in view.
+const hideActivationOffset = 72;
 // Offset (px) at or below which the chrome is always shown.
 const topRevealOffset = 8;
 // Minimum per-event delta (px) before we treat movement as intentional, to
@@ -50,20 +52,22 @@ function readPhoneMediaServer() {
   return false;
 }
 
-function usePhoneScrollHideActive(disabled = false) {
+function usePhoneScrollHideActive(disabled = false, allowAllBreakpoints = false) {
   const isPhone = useSyncExternalStore(subscribeToPhoneMedia, readPhoneMedia, readPhoneMediaServer);
-  return isPhone && !disabled;
+  return (allowAllBreakpoints || isPhone) && !disabled;
 }
 
 /**
  * Imperative scroll-offset reporter for hosts that already own a React `onScroll`
  * handler on the scrolling element (for example ClinicalDashboard `<main>`).
+ * Pass `allowAllBreakpoints` when the consumer hides chrome at every width
+ * (the all-breakpoints glass-header overlay) instead of phones only.
  */
-export function useScrollHideReporter(disabled = false) {
+export function useScrollHideReporter(disabled = false, allowAllBreakpoints = false) {
   const [hidden, setHidden] = useState(false);
   const hiddenRef = useRef(false);
   const lastOffsetRef = useRef(0);
-  const active = usePhoneScrollHideActive(disabled);
+  const active = usePhoneScrollHideActive(disabled, allowAllBreakpoints);
 
   const reportScroll = useCallback(
     (offset: number) => {
diff --git a/tests/ui-smoke.spec.ts b/tests/ui-smoke.spec.ts
index 48b7f55ffa..6e581aa13d 100644
--- a/tests/ui-smoke.spec.ts
+++ b/tests/ui-smoke.spec.ts
@@ -2664,24 +2664,102 @@ test.describe("Clinical KB UI smoke coverage", () => {
     await expectNoPageHorizontalOverflow(page);
   });
 
-  test("phone universal header fully hides while scrolling dashboard main on phones", async ({ page }) => {
+  test("answer glass header overlays main and fully hides while scrolling on phones", async ({ page }) => {
     await page.setViewportSize({ width: 390, height: 844 });
     await gotoApp(page, "/?mode=answer");
 
+    const header = page.locator("header.universal-header");
+    await expect(header).toBeVisible();
+    await expect(header).not.toHaveAttribute("data-scroll-hidden", "true");
+    // Answer mode takes the header out of flow (absolute over <main>) so
+    // content frosts under the glass bar; <main> must reserve the header's
+    // exact height as top padding or short answers regain phantom scroll.
+    await expect.poll(async () => header.evaluate((node) => window.getComputedStyle(node).position)).toBe("absolute");
+    const main = page.locator("main#main-content");
+    const reserve = await main.evaluate((node) => Number.parseFloat(window.getComputedStyle(node).paddingTop));
+    const headerHeight = await header.evaluate((node) => node.getBoundingClientRect().height);
+    expect(Math.abs(reserve - headerHeight)).toBeLessThanOrEqual(2);
+
+    await main.evaluate((node) => {
+      const spacer = document.createElement("div");
+      spacer.setAttribute("data-testid", "header-hide-scroll-spacer");
+      spacer.style.height = "2000px";
+      node.appendChild(spacer);
+    });
+    // Step scroll down so the dashboard main listener sees deliberate movement.
+    for (const offset of [40, 80, 120, 160, 200]) {
+      await main.evaluate((node, top) => {
+        node.scrollTop = top;
+      }, offset);
+    }
+
+    await expect(header).toHaveAttribute("data-scroll-hidden", "true");
+    await expect
+      .poll(async () =>
+        header.evaluate((node) => {
+          const rect = node.getBoundingClientRect();
+          return Math.max(0, rect.bottom) - Math.max(0, rect.top);
+        }),
+      )
+      .toBe(0);
+
+    // Any deliberate scroll up slides the glass bar back in.
+    for (const offset of [160, 120, 60]) {
+      await main.evaluate((node, top) => {
+        node.scrollTop = top;
+      }, offset);
+    }
+    await expect(header).not.toHaveAttribute("data-scroll-hidden", "true");
+  });
+
+  test("answer glass header hides and returns on desktop widths too", async ({ page }) => {
+    await page.setViewportSize({ width: 1280, height: 860 });
+    await gotoApp(page, "/?mode=answer");
+
+    const header = page.locator("header.universal-header");
+    await expect(header).toBeVisible();
+    await expect.poll(async () => header.evaluate((node) => window.getComputedStyle(node).position)).toBe("absolute");
+
+    const main = page.locator("main#main-content");
+    await main.evaluate((node) => {
+      const spacer = document.createElement("div");
+      spacer.style.height = "2400px";
+      node.appendChild(spacer);
+    });
+    for (const offset of [40, 90, 150, 220, 300]) {
+      await main.evaluate((node, top) => {
+        node.scrollTop = top;
+      }, offset);
+    }
+    await expect(header).toHaveAttribute("data-scroll-hidden", "true");
+
+    for (const offset of [250, 200, 140]) {
+      await main.evaluate((node, top) => {
+        node.scrollTop = top;
+      }, offset);
+    }
+    await expect(header).not.toHaveAttribute("data-scroll-hidden", "true");
+  });
+
+  test("non-answer phone header keeps the in-flow collapse hide", async ({ page }) => {
+    await page.setViewportSize({ width: 390, height: 844 });
+    await mockDemoApi(page);
+    await gotoApp(page, "/?mode=documents");
+
     const header = page.locator("header.universal-header");
     const collapseHost = page.getByTestId("universal-header-collapse");
     await expect(header).toBeVisible();
     await expect(collapseHost).not.toHaveAttribute("data-scroll-hidden", "true");
+    // Non-answer modes keep the header in flow — their sm+ composer renders
+    // beneath it, which the absolute answer-mode overlay would bury.
     await expect.poll(async () => header.evaluate((node) => window.getComputedStyle(node).position)).toBe("relative");
 
     const main = page.locator("main#main-content");
     await main.evaluate((node) => {
       const spacer = document.createElement("div");
-      spacer.setAttribute("data-testid", "header-hide-scroll-spacer");
       spacer.style.height = "2000px";
       node.appendChild(spacer);
     });
-    // Step scroll down so the dashboard main listener sees deliberate movement.
     for (const offset of [40, 80, 120, 160, 200]) {
       await main.evaluate((node, top) => {
         node.scrollTop = top;