diff --git a/docs/design-system/COMPONENTS.md b/docs/design-system/COMPONENTS.md
index 879976a14b..1d0f53ad57 100644
--- a/docs/design-system/COMPONENTS.md
+++ b/docs/design-system/COMPONENTS.md
@@ -1001,7 +1001,7 @@ This generated snapshot is a local source-derived inventory. It does not assert
 | `SearchField`            | controls | yes   | yes                | no                    | yes            | no                 |               0 |
 | `SegmentedControl`       | controls | yes   | yes                | inherited-global-root | yes            | no                 |               9 |
 | `Select`                 | controls | yes   | yes                | inherited-global-root | yes            | no                 |               2 |
-| `Sheet`                  | layout   | yes   | yes                | inherited-global-root | yes            | no                 |              27 |
+| `Sheet`                  | layout   | yes   | yes                | inherited-global-root | yes            | no                 |              26 |
 | `Skeleton`               | feedback | yes   | yes                | inherited-global-root | yes            | no                 |               6 |
 | `SourceDesignationBadge` | source   | yes   | yes                | inherited-global-root | yes            | no                 |               1 |
 | `SourceProvenance`       | source   | yes   | yes                | inherited-global-root | yes            | no                 |               1 |
diff --git a/docs/design-system/adoption-manifest.json b/docs/design-system/adoption-manifest.json
index 3b0db9464e..3cae58c960 100644
--- a/docs/design-system/adoption-manifest.json
+++ b/docs/design-system/adoption-manifest.json
@@ -1513,7 +1513,6 @@
         "src/components/in-page-nav/in-page-nav-header.tsx",
         "src/components/mode-nav/mode-nav.tsx",
         "src/components/services/service-group-nav.tsx",
-        "src/components/therapy-compass/filter-sheet.tsx",
         "src/components/ui/confirm-dialog.tsx"
       ],
       "productImportFiles": [
@@ -1542,8 +1541,7 @@
         "src/components/forms/forms-search-results-page.tsx",
         "src/components/in-page-nav/in-page-nav-header.tsx",
         "src/components/mode-nav/mode-nav.tsx",
-        "src/components/services/service-group-nav.tsx",
-        "src/components/therapy-compass/filter-sheet.tsx"
+        "src/components/services/service-group-nav.tsx"
       ],
       "designSync": {
         "listedInSourceMap": true,
diff --git a/docs/filter-contract.md b/docs/filter-contract.md
index 4b6e27e327..147db93a95 100644
--- a/docs/filter-contract.md
+++ b/docs/filter-contract.md
@@ -145,10 +145,11 @@ rather than showing an empty heading.
 - **`footerNote` counts what the filters actually govern.** Specifiers currently reports
   `results.length + catalogueMatches.length` while the groups narrow only `results` — the sheet
   claims to scope a list it half controls. A mode must not report a total its filters cannot move.
-- **`onClearAll` never touches the query.** Therapy-compass's clear wipes the search box; the
-  shared sheet's does not. Clearing filters and clearing a search are different intentions.
-- **One trigger component.** `ResultFilterTrigger`. Therapy-compass re-implements it with a
-  different icon, a hardcoded test id and a different label-hiding breakpoint.
+- **`onClearAll` never touches the query.** Clearing filters and clearing a search are different
+  intentions. Therapy-compass now uses the shared sheet's filter-only clear; the composer's
+  explicit "Clear search" action remains responsible for deleting the query.
+- **One trigger component.** `ResultFilterTrigger`. Therapy-compass now uses the shared trigger
+  at the phone breakpoint and the shared facet chips on desktop.
 - **Tap targets are `min-h-tap` (48px) on phone.** Do not relax to 44px for generic WCAG
   guidance; it reintroduces a known `ui-smoke` flake.
 
@@ -183,6 +184,11 @@ Contract first, then one PR per mode:
    `src/lib/service-facets.ts`), a URL round-trip alongside `q`/`group`, and the scope segment
    (section 4). Services is also the first mode dense enough (5 facet groups) to exercise the
    `> 3 groups` chrome added to the shared sheet for this — see section 5.
-4. **Documents last** — port its needle and collapse up into the shared component as the
+4. **Therapy-compass** — converge runtime use of the bespoke phone-only filter sheet and trigger
+   onto `ResultFilterSheet`, `ResultFilterTrigger`, and `ResultFilterFacetChips`. Topics are OR
+   within their group. Review status and handout availability are independent one-option groups
+   that AND with Topics and with each other. Option counts and filtering share
+   `matchesTopics`/`matchesAvailability`, and Clear filters preserves the query.
+5. **Documents last** — port its needle and collapse up into the shared component as the
    `> 20` tier, then converge. It is the largest surface and should move once the contract is
    proven elsewhere.
diff --git a/src/components/therapy-compass/bindings.tsx b/src/components/therapy-compass/bindings.tsx
index d4c39556e1..8649b377e7 100644
--- a/src/components/therapy-compass/bindings.tsx
+++ b/src/components/therapy-compass/bindings.tsx
@@ -112,6 +112,13 @@ export type TcBindings = {
   // ---- search ---------------------------------------------------------
   search: SearchOptions;
   searchResults: Therapy[];
+  /**
+   * Query-only matches — same query, tags/reviewedOnly/briefOnly reset to
+   * `EMPTY_SEARCH`. The base for a facet option's count ("how many would I
+   * have if I ticked this as well" — docs/filter-contract.md section 3),
+   * which must never be narrowed by the very selection it is counting.
+   */
+  queryMatches: Therapy[];
   setQuery: (q: string) => void;
   submitQuery: (q: string) => void; // set query + go search
   toggleTag: (tag: string) => void;
@@ -321,6 +328,16 @@ export function TcProvider({ children }: { children: ReactNode }) {
     // match aria-pressed state without waiting for useDeferredValue.
     return searchTherapies(therapies, { ...search, query: deferredSearch.query });
   }, [therapies, deferredSearch.query, search]);
+  // Same query-deferral shape as `searchResults`, tags/reviewedOnly/briefOnly
+  // reset — so a facet count never lags behind or races ahead of the query
+  // typing the reader can see.
+  const queryMatches = useMemo(() => {
+    const liveQuery = search.query.trim();
+    const deferredQuery = deferredSearch.query.trim();
+    if (!liveQuery) return searchTherapies(therapies, EMPTY_SEARCH);
+    if (!deferredQuery) return [];
+    return searchTherapies(therapies, { ...EMPTY_SEARCH, query: deferredSearch.query });
+  }, [therapies, deferredSearch.query, search.query]);
   const compareTherapies = useMemo(
     () => compareSlugs.map((sl) => bySlug.get(sl)).filter((t): t is Therapy => Boolean(t)),
     [compareSlugs, bySlug],
@@ -422,6 +439,7 @@ export function TcProvider({ children }: { children: ReactNode }) {
 
       search,
       searchResults,
+      queryMatches,
       setQuery: (q) => patchSearch({ query: q }),
       submitQuery: (q) => {
         patchSearch({ query: q });
@@ -538,6 +556,7 @@ export function TcProvider({ children }: { children: ReactNode }) {
     relatedForSelected,
     search,
     searchResults,
+    queryMatches,
     compareSlugs,
     compareTherapies,
     recQuery,
diff --git a/src/components/therapy-compass/data/select.ts b/src/components/therapy-compass/data/select.ts
index cc60850dde..c0321faaa6 100644
--- a/src/components/therapy-compass/data/select.ts
+++ b/src/components/therapy-compass/data/select.ts
@@ -124,7 +124,7 @@ export function complexityLabel(complexity: string | null): string {
 
 export type SearchOptions = {
   query: string;
-  tags: string[]; // therapy must carry ALL selected tags
+  tags: string[]; // therapy must carry ANY selected tag (OR within the group — see matchesTopics)
   briefOnly: boolean;
   sheetOnly: boolean;
   reviewedOnly: boolean;
@@ -138,6 +138,36 @@ export const EMPTY_SEARCH: SearchOptions = {
   reviewedOnly: false,
 };
 
+/**
+ * Topics facet predicate — OR within the group, matching every other adopted
+ * facet in the app (docs/filter-contract.md section 1). Picking both CBT and
+ * DBT means "either", not "a therapy tagged with both": AND-within-group is
+ * the exact defect class already fixed for document tags, where it made a
+ * second selection within one group a dead affordance instead of a widen.
+ *
+ * Exported so the filter sheet's option counts (`searchTherapies`'s own
+ * `hint` predicate) and the real filter run through one function — the count
+ * must be produced by the same predicate as the filter, or the two drift
+ * apart the moment the combination rule changes (section 3).
+ */
+export function matchesTopics(therapy: Therapy, topics: ReadonlySet<string>): boolean {
+  if (topics.size === 0) return true;
+  const wanted = [...topics].map(lc);
+  return therapy.tags.some((tag) => wanted.includes(lc(tag)));
+}
+
+/**
+ * Availability facet predicate — reviewed status and brief-intervention
+ * availability are independent constraints that AND together (they are two
+ * separate one-option facet groups, not options inside one group), and each
+ * ANDs against Topics in turn. Neither combines with the other by OR.
+ */
+export function matchesAvailability(therapy: Therapy, reviewedOnly: boolean, briefOnly: boolean): boolean {
+  if (reviewedOnly && therapy.reviewStatus !== "reviewed") return false;
+  if (briefOnly && !therapy.briefInterventionAvailable) return false;
+  return true;
+}
+
 function scoreTherapy(t: Therapy, q: string): number {
   if (!q) return 1;
   const name = lc(t.name);
@@ -158,13 +188,12 @@ function scoreTherapy(t: Therapy, q: string): number {
 
 export function searchTherapies(therapies: Therapy[], opts: SearchOptions): Therapy[] {
   const q = opts.query.trim().toLowerCase();
-  const wantTags = opts.tags.map(lc);
+  const topics = new Set(opts.tags);
   const scored = therapies
     .filter((t) => {
-      if (opts.briefOnly && !t.briefInterventionAvailable) return false;
+      if (!matchesAvailability(t, opts.reviewedOnly, opts.briefOnly)) return false;
       if (opts.sheetOnly && !t.patientSheetAvailable) return false;
-      if (opts.reviewedOnly && t.reviewStatus !== "reviewed") return false;
-      if (wantTags.length && !wantTags.every((wt) => t.tags.some((tag) => lc(tag) === wt))) return false;
+      if (!matchesTopics(t, topics)) return false;
       return scoreTherapy(t, q) > 0;
     })
     .map((t) => ({ t, s: scoreTherapy(t, q) }));
diff --git a/src/components/therapy-compass/filter-sheet.tsx b/src/components/therapy-compass/filter-sheet.tsx
deleted file mode 100644
index b130960e11..0000000000
--- a/src/components/therapy-compass/filter-sheet.tsx
+++ /dev/null
@@ -1,175 +0,0 @@
-"use client";
-
-import { Sheet } from "@/components/ui/sheet";
-
-import { outlineControl, softControl } from "./controls";
-import { CheckIcon, SlidersIcon, XIcon } from "./icons";
-
-/**
- * The phone filtering surface for therapy search.
- *
- * It replaces two native `<select>`s that were faking multi-select: options
- * carried a literal `"✓ "` prefix to show selection, `value` was pinned to `""`
- * so nothing was ever actually selected, and the placeholder row did the
- * reporting ("3 topics selected"). Assistive technology was told "combobox, no
- * selection" while the visible text said otherwise, choosing an already-chosen
- * option silently deselected it, and the availability select carried a
- * "Clear filters" *action* among its options. None of that is expressible in a
- * listbox.
- *
- * The controls here are the same `aria-pressed` toggles the wide viewport has
- * always used, so both breakpoints now describe the same state the same way.
- * Selected / success visuals come from the softControl recipe (`aria-pressed`
- * and `data-tone=success`) — no parallel `tc-is-*` classes.
- */
-export function TherapyFilterSheet({
-  open,
-  panelId,
-  onClose,
-  query,
-  topics,
-  activeTopics,
-  onToggleTopic,
-  reviewedOnly,
-  onToggleReviewed,
-  briefOnly,
-  onToggleBrief,
-  onClear,
-  resultCount,
-}: {
-  open: boolean;
-  panelId: string;
-  onClose: () => void;
-  /** Live search query — counts toward Clear all, matching wide-viewport Clear. */
-  query: string;
-  topics: readonly string[];
-  activeTopics: readonly string[];
-  onToggleTopic: (topic: string) => void;
-  reviewedOnly: boolean;
-  onToggleReviewed: () => void;
-  briefOnly: boolean;
-  onToggleBrief: () => void;
-  onClear: () => void;
-  resultCount: number;
-}) {
-  // Include the query so a query-only phone session still gets Clear all.
-  // The sheet's Clear all is the phone control that resets the query
-  // (`onClear` → `clearSearch`). The wide-viewport quick-filter Clear uses
-  // `clearSearchFilters` and deliberately leaves the query alone — so the
-  // sheet is not "the phone equivalent of the ribbon Clear"; it is the only
-  // Clear that wipes the query, and only on phones.
-  const clearableCount = activeTopics.length + Number(reviewedOnly) + Number(briefOnly) + (query.trim() ? 1 : 0);
-
-  return (
-    <Sheet
-      open={open}
-      onClose={onClose}
-      title="Filter therapies"
-      portal
-      id={panelId}
-      testId="therapy-filter-panel"
-      headerActions={
-        clearableCount > 0 ? (
-          <button type="button" onClick={onClear} data-testid="therapy-filter-clear" className={outlineControl}>
-            <XIcon size={15} strokeWidth={1.8} />
-            Clear all
-          </button>
-        ) : null
-      }
-      footer={
-        <div className="flex flex-wrap items-center justify-end gap-2">
-          <span aria-live="polite" className="nums mr-auto text-2xs font-semibold">
-            {resultCount} therap{resultCount === 1 ? "y" : "ies"}
-          </span>
-          <button type="button" onClick={onClose} data-testid="therapy-filter-done" className={softControl}>
-            Show {resultCount} therap{resultCount === 1 ? "y" : "ies"}
-          </button>
-        </div>
-      }
-    >
-      <section className="min-w-0">
-        <h3 className="text-2xs font-bold uppercase tracking-eyebrow">Topics</h3>
-        <div role="group" aria-label="Therapy topics" className="mt-2 flex flex-wrap gap-1.5">
-          {topics.map((topic) => {
-            const on = activeTopics.includes(topic);
-            return (
-              <button
-                key={topic}
-                type="button"
-                onClick={() => onToggleTopic(topic)}
-                aria-pressed={on}
-                className={`${softControl} min-h-12`}
-              >
-                {on ? <CheckIcon size={14} strokeWidth={2} /> : null}
-                {topic}
-              </button>
-            );
-          })}
-        </div>
-      </section>
-
-      <section className="mt-4 min-w-0">
-        <h3 className="text-2xs font-bold uppercase tracking-eyebrow">Availability</h3>
-        <div role="group" aria-label="Therapy availability" className="mt-2 flex flex-wrap gap-1.5">
-          <button
-            type="button"
-            onClick={onToggleReviewed}
-            aria-pressed={reviewedOnly}
-            data-tone={reviewedOnly ? "success" : undefined}
-            className={`${softControl} min-h-12`}
-          >
-            {reviewedOnly ? <CheckIcon size={14} strokeWidth={2} /> : null}
-            Reviewed only
-          </button>
-          <button type="button" onClick={onToggleBrief} aria-pressed={briefOnly} className={`${softControl} min-h-12`}>
-            {briefOnly ? <CheckIcon size={14} strokeWidth={2} /> : null}
-            Brief available
-          </button>
-        </div>
-      </section>
-    </Sheet>
-  );
-}
-
-/** Opens the therapy filter sheet and reports how many filters are active. */
-export function TherapyFilterTrigger({
-  panelId,
-  open,
-  activeCount,
-  onToggle,
-}: {
-  panelId: string;
-  open: boolean;
-  activeCount: number;
-  onToggle: () => void;
-}) {
-  return (
-    <button
-      type="button"
-      onClick={onToggle}
-      aria-expanded={open}
-      aria-pressed={activeCount > 0}
-      aria-haspopup="dialog"
-      aria-controls={open ? panelId : undefined}
-      data-testid="therapy-filter-trigger"
-      title="Filter therapies"
-      className={softControl}
-    >
-      <SlidersIcon size={15} strokeWidth={1.8} />
-      {/* The label is the first thing to go when the line is tight — below 430px
-          the count and the query need every pixel and a badged glyph is
-          unambiguous. The accessible name below is unchanged either way. */}
-      <span className="max-[429px]:sr-only">Filter</span>
-      {activeCount > 0 ? (
-        // A tinted pill, not a solid disc: a saturated filled circle is the
-        // loudest signal on a bar that is otherwise hairlines and type.
-        <span className="search-band-badge nums grid h-[1.0625rem] min-w-[1.0625rem] place-items-center rounded-full bg-[color:var(--search-band-badge-bg)] px-1 text-2xs font-bold text-[color:var(--clinical-accent)]">
-          {activeCount}
-        </span>
-      ) : null}
-      <span className="sr-only">
-        {activeCount > 0 ? `${activeCount} filter${activeCount === 1 ? "" : "s"} active` : "No filters active"}
-      </span>
-    </button>
-  );
-}
diff --git a/src/components/therapy-compass/screens/search-screen.tsx b/src/components/therapy-compass/screens/search-screen.tsx
index dcc1c11a16..894554c24f 100644
--- a/src/components/therapy-compass/screens/search-screen.tsx
+++ b/src/components/therapy-compass/screens/search-screen.tsx
@@ -1,21 +1,31 @@
 "use client";
 
-import { useId, useState } from "react";
+import { useId, useMemo, useState } from "react";
 
 import {
   SearchResultsEmptyState,
   SearchResultsHeaderBand,
 } from "@/components/clinical-dashboard/search-results-header-band";
+import {
+  ResultFilterFacetChips,
+  ResultFilterSheet,
+  ResultFilterTrigger,
+  resultFilterFacetGroup,
+} from "@/components/clinical-dashboard/result-filter-control";
 import { pageContainer } from "@/components/ui-primitives";
 
 import { useTcBindings } from "../bindings";
-import { TherapyFilterSheet, TherapyFilterTrigger } from "../filter-sheet";
-import { softControl, therapyBtn } from "../controls";
+import { matchesAvailability, matchesTopics } from "../data/select";
+import { therapyBtn } from "../controls";
 import { XIcon } from "../icons";
 import { LoadingState } from "../ui";
 import { ResultCard } from "../therapy-card";
 
 // Curated quick-filter tags surfaced as chips (all exist in the tag set).
+// None of the six is ever zero across the whole 205-therapy catalogue, so the
+// "derive the option list from the data" rule (docs/filter-contract.md
+// section 3) — aimed at a permanently empty option — does not apply here; a
+// deliberately curated subset of a larger tag vocabulary is a different thing.
 const QUICK_TAGS = ["CBT", "Anxiety", "Mood", "Trauma", "DBT", "Crisis/risk"];
 const MAX_CARDS = 24;
 
@@ -24,20 +34,16 @@ export function SearchScreen() {
   const q = b.search.query;
   const results = b.searchResults;
   const shown = results.slice(0, MAX_CARDS);
-  const availabilityFilterCount = Number(b.search.reviewedOnly) + Number(b.search.briefOnly);
-  // Match the sheet: a non-empty query is an active narrowing control on phone,
-  // where Clear only lives inside the filter sheet (wide keeps a ribbon Clear).
+  const topics = useMemo(() => new Set(b.search.tags), [b.search.tags]);
   // Filters only — the query is deliberately excluded. It counts toward the
-  // sheet's Clear all (see `filter-sheet.tsx`), because `clearSearch` resets it,
-  // but the trigger badge is labelled "N filters active" and a search term is
-  // not a filter. Counting it there makes the control announce a state the page
-  // is not in, which is the exact defect this screen's sheet was built to fix.
-  const activeFilterCount = b.search.tags.length + availabilityFilterCount;
+  // sheet's Clear all (see below), because `clearSearch` resets it, but the
+  // trigger badge is labelled "N filters active" and a search term is not a
+  // filter. Counting it there makes the control announce a state the page is
+  // not in, which is the exact defect this screen's sheet was built to fix.
+  const activeFilterCount = b.search.tags.length + Number(b.search.reviewedOnly) + Number(b.search.briefOnly);
   // Topics and availability both narrow the same list, so both belong on the
   // shelf. The query is deliberately absent: it is stated in the composer and
-  // removing it is not a filter operation. The shelf's trailing Clear therefore
-  // uses `clearSearchFilters`, not `clearSearch` — a row labelled "Filtered by"
-  // must not delete the search term the user is reading.
+  // removing it is not a filter operation.
   const appliedFilters = [
     ...b.search.tags.map((tag) => ({ id: `topic-${tag}`, label: tag, onRemove: () => b.toggleTag(tag) })),
     ...(b.search.reviewedOnly ? [{ id: "reviewed", label: "Reviewed only", onRemove: b.toggleReviewedOnly }] : []),
@@ -46,6 +52,85 @@ export function SearchScreen() {
   const filterPanelId = useId();
   const [filterOpen, setFilterOpen] = useState(false);
 
+  // "How many would I have if I ticked this as well" — the same predicate as
+  // the filter, run against the query-only match set with the candidate
+  // added, so a count is never derived by narrowing the already-filtered
+  // subset. See docs/filter-contract.md section 3 and the two shared
+  // predicates in `data/select.ts` that both this and `searchTherapies` run
+  // through, so the count and the filter cannot drift apart.
+  const topicsGroup = useMemo(
+    () =>
+      resultFilterFacetGroup({
+        id: "topics",
+        label: "Topics",
+        selected: topics,
+        options: QUICK_TAGS.map((tag) => {
+          const withCandidate = topics.has(tag) ? topics : new Set([...topics, tag]);
+          const count = b.queryMatches.filter(
+            (t) => matchesTopics(t, withCandidate) && matchesAvailability(t, b.search.reviewedOnly, b.search.briefOnly),
+          ).length;
+          return { value: tag, label: tag, hint: String(count), disabled: count === 0 && !topics.has(tag) };
+        }),
+        onToggle: b.toggleTag,
+      }),
+    [topics, b.queryMatches, b.search.reviewedOnly, b.search.briefOnly, b.toggleTag],
+  );
+  // Reviewed-only and brief-available are independent AND constraints, not
+  // alternatives — see `matchesAvailability`. Modelled as two separate
+  // one-option facet groups rather than options inside one group, because a
+  // shared group would OR them together (docs/filter-contract.md section 1),
+  // which `searchTherapies` does not: selecting both narrows to therapies
+  // that are both reviewed and have a brief, not either.
+  const reviewedGroup = useMemo(
+    () =>
+      resultFilterFacetGroup({
+        id: "review-status",
+        label: "Review status",
+        selected: b.search.reviewedOnly ? new Set(["reviewed"]) : new Set<string>(),
+        options: [
+          {
+            value: "reviewed",
+            label: "Reviewed only",
+            hint: String(
+              b.queryMatches.filter((t) => matchesTopics(t, topics) && matchesAvailability(t, true, b.search.briefOnly))
+                .length,
+            ),
+            disabled:
+              b.queryMatches.filter((t) => matchesTopics(t, topics) && matchesAvailability(t, true, b.search.briefOnly))
+                .length === 0 && !b.search.reviewedOnly,
+          },
+        ],
+        onToggle: b.toggleReviewedOnly,
+      }),
+    [b.search.reviewedOnly, b.search.briefOnly, b.queryMatches, topics, b.toggleReviewedOnly],
+  );
+  const handoutGroup = useMemo(
+    () =>
+      resultFilterFacetGroup({
+        id: "handout",
+        label: "Handout",
+        selected: b.search.briefOnly ? new Set(["brief"]) : new Set<string>(),
+        options: [
+          {
+            value: "brief",
+            label: "Brief available",
+            hint: String(
+              b.queryMatches.filter(
+                (t) => matchesTopics(t, topics) && matchesAvailability(t, b.search.reviewedOnly, true),
+              ).length,
+            ),
+            disabled:
+              b.queryMatches.filter(
+                (t) => matchesTopics(t, topics) && matchesAvailability(t, b.search.reviewedOnly, true),
+              ).length === 0 && !b.search.briefOnly,
+          },
+        ],
+        onToggle: b.toggleBriefOnly,
+      }),
+    [b.search.briefOnly, b.search.reviewedOnly, b.queryMatches, topics, b.toggleBriefOnly],
+  );
+  const filterGroups = [topicsGroup, reviewedGroup, handoutGroup];
+
   return (
     <section data-screen-label="Search" className={`${pageContainer} space-y-2.5 sm:space-y-3`}>
       <SearchResultsHeaderBand
@@ -62,68 +147,41 @@ export function SearchScreen() {
         // A compact badged trigger, so it shares the count line.
         mobileControlsPlacement="inline"
         mobileControls={
-          <TherapyFilterTrigger
+          <ResultFilterTrigger
             panelId={filterPanelId}
+            testId="therapy-filter-trigger-phone"
+            title="Filter therapy results"
             open={filterOpen}
             activeCount={activeFilterCount}
             onToggle={() => setFilterOpen((current) => !current)}
           />
         }
         filterControls={
-          <div className="mb-1 flex flex-wrap gap-2.5 sm:mb-2">
-            {QUICK_TAGS.map((tag) => {
-              const on = b.search.tags.includes(tag);
-              return (
-                <button
-                  key={tag}
-                  type="button"
-                  className={`${therapyBtn} ${softControl}`}
-                  onClick={() => b.toggleTag(tag)}
-                  aria-pressed={on}
-                >
-                  {tag}
-                </button>
-              );
-            })}
-            <button
-              type="button"
-              className={`${therapyBtn} ${softControl}`}
-              onClick={b.toggleReviewedOnly}
-              aria-pressed={b.search.reviewedOnly}
-            >
-              Reviewed only
-            </button>
-            <button
-              type="button"
-              className={`${therapyBtn} ${softControl}`}
-              onClick={b.toggleBriefOnly}
-              aria-pressed={b.search.briefOnly}
-            >
-              Brief available
-            </button>
+          // `ResultFilterFacetChips` carries a `border-t` meant for groups
+          // stacked vertically inside the sheet (`first:border-t-0` zeroes
+          // only the very first one). Side by side here, that put a hairline
+          // above the second and third group only — a floating tick mark, not
+          // a real divider. Neutralised per-child rather than touching the
+          // shared component, which formulation's single-group desktop rail
+          // still needs unmodified.
+          <div className="mb-1 flex flex-wrap items-start gap-x-5 gap-y-1.5 sm:mb-2 [&>section]:border-t-0 [&>section]:pt-0">
+            {filterGroups.map((group) => (
+              <ResultFilterFacetChips key={group.id} group={group} idPrefix={`${filterPanelId}-desktop`} />
+            ))}
             {/* Rendered only when there is something to clear. Rewiring this to
                 `clearSearchFilters` fixed the label/handler mismatch but created
                 a second one: with no topics and neither availability toggle on —
                 the ordinary "typed a query, got results" case — clicking `Clear`
                 produced no observable change at all. A control that advertises an
-                action must perform one; the sheet's `Clear all` is already gated
-                on `clearableCount > 0` for the same reason. */}
+                action must perform one. */}
             {activeFilterCount > 0 ? (
               <button
                 type="button"
                 className={`${therapyBtn} inline-flex items-center gap-2 min-h-tap py-0 px-4 border border-dashed border-[color:var(--border-strong)] rounded-lg bg-transparent text-[color:var(--text-muted)] text-sm-minus font-medium cursor-pointer`}
-                // `clearSearchFilters`, not `clearSearch`. This control sits at the
-                // end of the quick-filter chip row and is labelled `Clear`, so it
-                // reads as "clear these filters" — but `clearSearch` also wipes the
-                // query, deleting the search the reader is looking at. Same defect
-                // #1611 fixed on the shelf's Clear; the binding it introduced
-                // (`bindings.tsx:441`) is reused rather than duplicated.
-                // The sheet's `Clear all` is deliberately different and stays on
-                // `clearSearch` — it is labelled for what it does.
-                //
-                // Both sides of the v2 merge agreed on `--text-muted`, so this
-                // hunk reduced to the handler alone; `main` still carries the
-                // query-wiping version because #1616 branched before the fix.
+                // `clearSearchFilters`, not `clearSearch`. This control is
+                // labelled `Clear` and sits beside the filter chips, so it
+                // reads as "clear these filters" — `clearSearch` also wipes
+                // the query, deleting the search the reader is looking at.
                 onClick={b.clearSearchFilters}
               >
                 <XIcon size={15} strokeWidth={1.8} className="text-[color:var(--decoration-soft)]" />
@@ -134,20 +192,19 @@ export function SearchScreen() {
         }
       />
 
-      <TherapyFilterSheet
+      <ResultFilterSheet
         open={filterOpen}
-        panelId={filterPanelId}
         onClose={() => setFilterOpen(false)}
-        query={q}
-        topics={QUICK_TAGS}
-        activeTopics={b.search.tags}
-        onToggleTopic={b.toggleTag}
-        reviewedOnly={b.search.reviewedOnly}
-        onToggleReviewed={b.toggleReviewedOnly}
-        briefOnly={b.search.briefOnly}
-        onToggleBrief={b.toggleBriefOnly}
-        onClear={b.clearSearch}
-        resultCount={results.length}
+        panelId={filterPanelId}
+        testId="therapy-filter-panel"
+        title="Filter therapies"
+        groups={filterGroups}
+        // Never `clearSearch` — the shared sheet's Clear all must not touch
+        // the query (docs/filter-contract.md section 6). The composer's own
+        // "Clear search" control (every breakpoint) already covers wiping the
+        // query; this sheet only ever clears what it itself narrows.
+        onClearAll={activeFilterCount > 0 ? b.clearSearchFilters : undefined}
+        footerNote={`${results.length} therap${results.length === 1 ? "y" : "ies"}`}
       />
 
       {/* The band's fault panel owns the failure. Without this guard an error
@@ -158,12 +215,6 @@ export function SearchScreen() {
       ) : (
         <>
           {results.length === 0 ? (
-            // The shared surface, so the filtered-to-zero reader gets the same
-            // route out here as in documents. What it replaces was a single
-            // button labelled `Clear filters` wired to `clearSearch`, which also
-            // deleted the query — the label promised one thing and the handler
-            // did another. `Remove "X"` and `Clear all filters` are now separate
-            // controls, so each label matches its own action.
             <SearchResultsEmptyState
               modeId="therapy-compass"
               query={q}
diff --git a/tests/therapy-compass-mode-wiring.test.ts b/tests/therapy-compass-mode-wiring.test.ts
index 30fdb5607b..b150c2255f 100644
--- a/tests/therapy-compass-mode-wiring.test.ts
+++ b/tests/therapy-compass-mode-wiring.test.ts
@@ -273,8 +273,7 @@ describe("Therapy Compass production-mode wiring", () => {
     // trailing Clear was wired to `clearSearch`, which resets EMPTY_SEARCH —
     // including `query: ""`. So Clear silently deleted the search term the user
     // was reading, while the code comment beside it claimed the query was
-    // deliberately excluded. The sheet's own "Clear all" still resets
-    // everything on purpose; only the shelf is filter-only.
+    // deliberately excluded.
     const searchScreenSrc = readFileSync(
       new URL("../src/components/therapy-compass/screens/search-screen.tsx", import.meta.url),
       "utf8",
@@ -285,8 +284,14 @@ describe("Therapy Compass production-mode wiring", () => {
     expect(bindingsSrc).toContain(
       "clearSearchFilters: () => setSearch((prev) => ({ ...EMPTY_SEARCH, query: prev.query }))",
     );
-    // The sheet keeps the full reset.
-    expect(searchScreenSrc).toContain("onClear={b.clearSearch}");
+    // Filter-contract adoption (docs/filter-contract.md section 6): the phone
+    // sheet converged onto the shared `ResultFilterSheet`, whose `onClearAll`
+    // must never touch the query either — "Therapy-compass's clear wipes the
+    // search box; the shared sheet's does not" was the exact defect being
+    // fixed. The sheet's own full reset is no longer wired at all; the
+    // composer's "Clear search" control covers the query on every breakpoint.
+    expect(searchScreenSrc).toContain("onClearAll={activeFilterCount > 0 ? b.clearSearchFilters : undefined}");
+    expect(searchScreenSrc).not.toContain("onClear={b.clearSearch}");
   });
 
   it("keeps the quick-filter row's Clear filter-only too", () => {
@@ -307,14 +312,16 @@ describe("Therapy Compass production-mode wiring", () => {
     // instead made a correctly-labelled `Clear search` look like a regression,
     // which is the wrong signal from a guard whose whole point is intent.
     const fullResetProps = Array.from(searchScreenSrc.matchAll(/(\w+)=\{b\.clearSearch\}/g)).map((match) => match[1]);
-    expect(fullResetProps.length).toBeGreaterThan(0);
+    // Filter-contract adoption removed the sheet's own full reset (see the
+    // test above), so the only remaining `clearSearch` wiring is the empty
+    // state's explicit "Clear search" escape — correctly named for what it
+    // does, and the one case this guard exists to allow.
+    expect(fullResetProps).toEqual(["onClearSearch"]);
     expect(
       fullResetProps.filter((prop) => !["onClear", "onClearSearch"].includes(prop)),
       "A control wired to `clearSearch` must be labelled for clearing the search. " +
         "`onClearFilters`, `onRemove` or a bare `onClick` promising to clear filters must use " +
         "`clearSearchFilters`, or it deletes the search term the reader is looking at.",
     ).toEqual([]);
-    // The sheet keeps its deliberate full reset.
-    expect(searchScreenSrc).toContain("onClear={b.clearSearch}");
   });
 });
diff --git a/tests/therapy-compass-search-filters.dom.test.tsx b/tests/therapy-compass-search-filters.dom.test.tsx
new file mode 100644
index 0000000000..630cded06f
--- /dev/null
+++ b/tests/therapy-compass-search-filters.dom.test.tsx
@@ -0,0 +1,179 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import type { Therapy } from "@/components/therapy-compass/data/types";
+
+function therapy(overrides: Partial<Therapy> = {}): Therapy {
+  return {
+    slug: "act",
+    name: "Acceptance and Commitment Therapy (ACT)",
+    tags: ["Mood", "Anxiety", "CBT"],
+    reviewStatus: "needs_review",
+    briefInterventionAvailable: true,
+    patientSheetAvailable: true,
+    ...overrides,
+  } as Therapy;
+}
+
+const bindingsState = vi.hoisted(() => ({
+  query: "",
+  tags: [] as string[],
+  reviewedOnly: false,
+  briefOnly: false,
+  queryMatches: [] as Therapy[],
+  searchResults: [] as Therapy[],
+}));
+
+const toggleTag = vi.fn();
+const toggleReviewedOnly = vi.fn();
+const toggleBriefOnly = vi.fn();
+const clearSearch = vi.fn();
+const clearSearchFilters = vi.fn();
+
+vi.mock("@/components/therapy-compass/bindings", () => ({
+  useTcBindings: () => ({
+    error: null,
+    loading: false,
+    retryData: vi.fn(),
+    search: {
+      query: bindingsState.query,
+      tags: bindingsState.tags,
+      reviewedOnly: bindingsState.reviewedOnly,
+      briefOnly: bindingsState.briefOnly,
+      sheetOnly: false,
+    },
+    searchResults: bindingsState.searchResults,
+    queryMatches: bindingsState.queryMatches,
+    toggleTag,
+    toggleReviewedOnly,
+    toggleBriefOnly,
+    clearSearch,
+    clearSearchFilters,
+  }),
+}));
+
+import { SearchScreen } from "@/components/therapy-compass/screens/search-screen";
+
+describe("therapy-compass search filter contract adoption", () => {
+  // `bindingsState` and the handler spies are module-level, so they would
+  // otherwise leak call counts and stale values between cases.
+  afterEach(() => {
+    bindingsState.query = "";
+    bindingsState.tags = [];
+    bindingsState.reviewedOnly = false;
+    bindingsState.briefOnly = false;
+    bindingsState.queryMatches = [];
+    bindingsState.searchResults = [];
+    vi.clearAllMocks();
+  });
+
+  it("renders Topics, Review status, and Handout as three separate facet groups", () => {
+    bindingsState.query = "";
+    bindingsState.tags = [];
+    bindingsState.reviewedOnly = false;
+    bindingsState.briefOnly = false;
+    bindingsState.queryMatches = [therapy({ slug: "a", tags: ["CBT"] }), therapy({ slug: "b", tags: ["Anxiety"] })];
+    bindingsState.searchResults = [];
+
+    render(<SearchScreen />);
+
+    expect(screen.getByRole("group", { name: "Topics" })).toBeInTheDocument();
+    expect(screen.getByRole("group", { name: "Review status" })).toBeInTheDocument();
+    expect(screen.getByRole("group", { name: "Handout" })).toBeInTheDocument();
+  });
+
+  it("counts a Topics option against the query-only match set, not the already-filtered one", () => {
+    bindingsState.query = "";
+    bindingsState.tags = [];
+    bindingsState.reviewedOnly = false;
+    bindingsState.briefOnly = false;
+    bindingsState.queryMatches = [
+      therapy({ slug: "a", tags: ["CBT"] }),
+      therapy({ slug: "b", tags: ["CBT"] }),
+      therapy({ slug: "c", tags: ["Anxiety"] }),
+    ];
+    bindingsState.searchResults = [];
+
+    render(<SearchScreen />);
+
+    expect(screen.getAllByRole("button", { name: /^CBT \(2\)$/ })[0]).toBeInTheDocument();
+    expect(screen.getAllByRole("button", { name: /^Anxiety \(1\)$/ })[0]).toBeInTheDocument();
+  });
+
+  it("clicking a Topics chip calls toggleTag with that tag", async () => {
+    const user = userEvent.setup();
+    bindingsState.query = "";
+    bindingsState.tags = [];
+    bindingsState.queryMatches = [therapy({ tags: ["CBT"] })];
+    bindingsState.searchResults = [];
+    toggleTag.mockClear();
+
+    render(<SearchScreen />);
+
+    await user.click(screen.getAllByRole("button", { name: /^CBT/ })[0]);
+    expect(toggleTag).toHaveBeenCalledWith("CBT");
+  });
+
+  it("Reviewed only and Brief available toggle independently, never through one shared onToggle", async () => {
+    const user = userEvent.setup();
+    bindingsState.query = "";
+    bindingsState.tags = [];
+    bindingsState.queryMatches = [therapy({ reviewStatus: "reviewed" })];
+    bindingsState.searchResults = [];
+    toggleReviewedOnly.mockClear();
+    toggleBriefOnly.mockClear();
+
+    render(<SearchScreen />);
+
+    await user.click(screen.getAllByRole("button", { name: /^Reviewed only/ })[0]);
+    expect(toggleReviewedOnly).toHaveBeenCalledTimes(1);
+    expect(toggleBriefOnly).not.toHaveBeenCalled();
+
+    await user.click(screen.getAllByRole("button", { name: /^Brief available/ })[0]);
+    expect(toggleBriefOnly).toHaveBeenCalledTimes(1);
+  });
+
+  it("Clear all in the phone sheet clears filters only, never the query", async () => {
+    const user = userEvent.setup();
+    bindingsState.query = "anxiety";
+    bindingsState.tags = ["CBT"];
+    bindingsState.reviewedOnly = false;
+    bindingsState.briefOnly = false;
+    bindingsState.queryMatches = [therapy()];
+    // Empty, not `[therapy()]`: `ResultCard` reads several more `useTcBindings`
+    // fields (compare selection, favourites) this test's mock does not stub,
+    // and this suite is scoped to the filter sheet's own wiring, not the
+    // result list it sits above.
+    bindingsState.searchResults = [];
+    clearSearch.mockClear();
+    clearSearchFilters.mockClear();
+
+    render(<SearchScreen />);
+
+    await user.click(screen.getByTestId("therapy-filter-trigger-phone"));
+    await user.click(screen.getByTestId("therapy-filter-panel-clear"));
+
+    expect(clearSearchFilters).toHaveBeenCalledTimes(1);
+    expect(clearSearch).not.toHaveBeenCalled();
+  });
+
+  it("hides Clear all in the phone sheet for a query-only session — nothing for it to clear", async () => {
+    const user = userEvent.setup();
+    bindingsState.query = "anxiety";
+    bindingsState.tags = [];
+    bindingsState.reviewedOnly = false;
+    bindingsState.briefOnly = false;
+    bindingsState.queryMatches = [therapy()];
+    // Empty, not `[therapy()]`: `ResultCard` reads several more `useTcBindings`
+    // fields (compare selection, favourites) this test's mock does not stub,
+    // and this suite is scoped to the filter sheet's own wiring, not the
+    // result list it sits above.
+    bindingsState.searchResults = [];
+
+    render(<SearchScreen />);
+
+    await user.click(screen.getByTestId("therapy-filter-trigger-phone"));
+    expect(screen.queryByTestId("therapy-filter-panel-clear")).not.toBeInTheDocument();
+  });
+});
diff --git a/tests/therapy-filter-sheet.dom.test.tsx b/tests/therapy-filter-sheet.dom.test.tsx
deleted file mode 100644
index fdc2a75366..0000000000
--- a/tests/therapy-filter-sheet.dom.test.tsx
+++ /dev/null
@@ -1,74 +0,0 @@
-import { render, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { TherapyFilterSheet, TherapyFilterTrigger } from "@/components/therapy-compass/filter-sheet";
-
-const baseProps = {
-  open: true,
-  panelId: "therapy-filter-panel-test",
-  onClose: vi.fn(),
-  topics: ["CBT", "Anxiety"] as const,
-  activeTopics: [] as string[],
-  onToggleTopic: vi.fn(),
-  reviewedOnly: false,
-  onToggleReviewed: vi.fn(),
-  briefOnly: false,
-  onToggleBrief: vi.fn(),
-  onClear: vi.fn(),
-  resultCount: 3,
-};
-
-describe("TherapyFilterSheet Clear all", () => {
-  // `baseProps` holds module-level mocks, so call counts would otherwise leak
-  // between cases.
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("shows Clear all when only a search query is active", () => {
-    // Phone Clear lives in this sheet; wide always has a ribbon Clear. Omitting
-    // the query from activeCount hid Clear all for the common query-only case.
-    render(<TherapyFilterSheet {...baseProps} query="cbt" />);
-
-    expect(screen.getByTestId("therapy-filter-clear")).toBeInTheDocument();
-    expect(screen.getByTestId("therapy-filter-clear")).toHaveTextContent("Clear all");
-  });
-
-  it("hides Clear all when nothing is narrowing results", () => {
-    render(<TherapyFilterSheet {...baseProps} query="   " />);
-
-    expect(screen.queryByTestId("therapy-filter-clear")).toBeNull();
-  });
-
-  it("invokes onClear from Clear all in the query-only state", async () => {
-    const user = userEvent.setup();
-    const onClear = vi.fn();
-    render(<TherapyFilterSheet {...baseProps} query="anxiety" onClear={onClear} />);
-
-    await user.click(screen.getByTestId("therapy-filter-clear"));
-    expect(onClear).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("TherapyFilterTrigger badge", () => {
-  // The badge is labelled "N filters active". A search term is not a filter, so
-  // it must not be counted here even though it counts toward the sheet's Clear
-  // all. Counting it made the trigger announce "1 filter active" on a plain
-  // search with nothing filtered — a control describing a state the page is not
-  // in, which is the same class of defect this screen's sheet replaced.
-  const triggerProps = { panelId: "p", open: false, onToggle: vi.fn() };
-
-  it("announces no filters when only a query is present", () => {
-    render(<TherapyFilterTrigger {...triggerProps} activeCount={0} />);
-
-    expect(screen.getByTestId("therapy-filter-trigger")).toHaveAccessibleName(/No filters active/);
-    expect(screen.getByTestId("therapy-filter-trigger")).not.toHaveTextContent(/\b1\b/);
-  });
-
-  it("counts real filters", () => {
-    render(<TherapyFilterTrigger {...triggerProps} activeCount={2} />);
-
-    expect(screen.getByTestId("therapy-filter-trigger")).toHaveAccessibleName(/2 filters active/);
-  });
-});
diff --git a/tests/therapy-search-facets.test.ts b/tests/therapy-search-facets.test.ts
new file mode 100644
index 0000000000..08ee7fa9c3
--- /dev/null
+++ b/tests/therapy-search-facets.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+
+import therapiesFixture from "@/data/therapies-index.json";
+import {
+  EMPTY_SEARCH,
+  matchesAvailability,
+  matchesTopics,
+  searchTherapies,
+} from "@/components/therapy-compass/data/select";
+import type { Therapy } from "@/components/therapy-compass/data/types";
+
+const therapies = therapiesFixture as unknown as Therapy[];
+
+describe("therapy-compass Topics facet — OR within group (docs/filter-contract.md section 1)", () => {
+  it("has a non-empty catalogue to test against (premise)", () => {
+    expect(therapies.length).toBeGreaterThan(0);
+  });
+
+  it("widens rather than narrows when a second topic is selected", () => {
+    const cbtOnly = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT"] }).length;
+    const cbtOrAnxiety = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT", "Anxiety"] }).length;
+    expect(cbtOrAnxiety).toBeGreaterThanOrEqual(cbtOnly);
+  });
+
+  it("matches the exact union of both tags, not some other combination", () => {
+    const cbt = new Set(therapies.filter((t) => t.tags.includes("CBT")).map((t) => t.slug));
+    const anxiety = new Set(therapies.filter((t) => t.tags.includes("Anxiety")).map((t) => t.slug));
+    const union = new Set([...cbt, ...anxiety]);
+    // Sanity: the two tags are not identical sets, or a union test could pass
+    // by coincidence even with buggy AND logic.
+    expect(cbt).not.toEqual(anxiety);
+
+    const result = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT", "Anxiety"] });
+    expect(new Set(result.map((t) => t.slug))).toEqual(union);
+  });
+
+  it("an empty selection is no constraint", () => {
+    expect(therapies.every((t) => matchesTopics(t, new Set()))).toBe(true);
+  });
+
+  it("is case-insensitive, matching the original tag comparison", () => {
+    const upper = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["cbt"] }).length;
+    const asStored = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT"] }).length;
+    expect(upper).toBe(asStored);
+    expect(upper).toBeGreaterThan(0);
+  });
+});
+
+describe("therapy-compass availability facets — independent AND constraints, never OR", () => {
+  // `matchesAvailability` is tested against synthetic fixtures rather than the
+  // real catalogue: every therapy in the current corpus has `reviewStatus`
+  // "needs_review" (none has cleared clinical review yet), so a real-data test
+  // of "reviewed AND brief-available" would vacuously pass with zero matches
+  // either way and prove nothing about the predicate itself.
+  const reviewedNoBrief = { reviewStatus: "reviewed", briefInterventionAvailable: false } as Therapy;
+  const reviewedWithBrief = { reviewStatus: "reviewed", briefInterventionAvailable: true } as Therapy;
+  const unreviewedWithBrief = { reviewStatus: "needs_review", briefInterventionAvailable: true } as Therapy;
+
+  it("requires both flags independently — reviewed alone does not satisfy briefOnly", () => {
+    expect(matchesAvailability(reviewedNoBrief, true, false)).toBe(true);
+    expect(matchesAvailability(reviewedNoBrief, true, true)).toBe(false);
+  });
+
+  it("requires both flags independently — brief alone does not satisfy reviewedOnly", () => {
+    expect(matchesAvailability(unreviewedWithBrief, false, true)).toBe(true);
+    expect(matchesAvailability(unreviewedWithBrief, true, true)).toBe(false);
+  });
+
+  it("passes when both flags are set and both conditions hold", () => {
+    expect(matchesAvailability(reviewedWithBrief, true, true)).toBe(true);
+  });
+
+  it("imposes no constraint when neither flag is set", () => {
+    expect(matchesAvailability(reviewedNoBrief, false, false)).toBe(true);
+  });
+
+  it("narrows (or holds even) when a second availability flag is added on real data, never widens", () => {
+    const briefOnly = searchTherapies(therapies, { ...EMPTY_SEARCH, briefOnly: true }).length;
+    const both = searchTherapies(therapies, { ...EMPTY_SEARCH, briefOnly: true, reviewedOnly: true }).length;
+    expect(both).toBeLessThanOrEqual(briefOnly);
+  });
+
+  it("does not combine with Topics by OR either — both must hold", () => {
+    const cbtCount = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT"] }).length;
+    const cbtAndBrief = searchTherapies(therapies, { ...EMPTY_SEARCH, tags: ["CBT"], briefOnly: true }).length;
+    expect(cbtAndBrief).toBeLessThanOrEqual(cbtCount);
+  });
+});
+
+describe("the six curated Topics chips (docs/filter-contract.md 'derive vs curate')", () => {
+  // These are a deliberate editorial subset of a larger tag vocabulary, not a
+  // declared list standing in for the data — so none may be permanently zero
+  // across the whole catalogue, which is what the "derive, don't declare" rule
+  // actually guards against (a control that can never return anything).
+  const QUICK_TAGS = ["CBT", "Anxiety", "Mood", "Trauma", "DBT", "Crisis/risk"];
+
+  it.each(QUICK_TAGS)("%s matches at least one therapy in the whole catalogue", (tag) => {
+    expect(therapies.some((t) => matchesTopics(t, new Set([tag])))).toBe(true);
+  });
+});
diff --git a/tests/ui-accessibility.spec.ts b/tests/ui-accessibility.spec.ts
index 406cdaf208..bd899723f8 100644
--- a/tests/ui-accessibility.spec.ts
+++ b/tests/ui-accessibility.spec.ts
@@ -585,9 +585,10 @@ test.describe("Clinical KB accessibility coverage", () => {
     // multi-select: `value` pinned to "", a literal "✓ " prefix in option text,
     // and the placeholder row doing the reporting ("1 topics selected"). A
     // listbox cannot express "three of these are on", so assistive technology
-    // was told the opposite of what the visible text said. Both are now
-    // `aria-pressed` toggles inside a dialog, matching the wide viewport.
-    const therapyFilterTrigger = therapyRibbon.getByTestId("therapy-filter-trigger");
+    // was told the opposite of what the visible text said. Both are now the
+    // shared `aria-pressed` facet toggles every adopted mode uses, converged
+    // onto `ResultFilterSheet`/`ResultFilterTrigger` (docs/filter-contract.md).
+    const therapyFilterTrigger = therapyRibbon.getByTestId("therapy-filter-trigger-phone");
     await expect(therapyFilterTrigger).toBeVisible();
     await expect(therapyFilterTrigger).toHaveAccessibleName(/Filter/);
     await expect(therapyFilterTrigger).toHaveAttribute("aria-haspopup", "dialog");
@@ -623,35 +624,44 @@ test.describe("Clinical KB accessibility coverage", () => {
     await expect(therapyFilterTrigger).toHaveAttribute("aria-controls", therapyPanelId!);
 
     // The state the old select could not express: selection is on the control
-    // itself, and turning one on leaves the others alone.
-    const cbtToggle = therapyFilterPanel.getByRole("button", { name: "CBT" });
-    const reviewedToggle = therapyFilterPanel.getByRole("button", { name: "Reviewed only" });
+    // itself, and turning one on leaves the others alone. Names carry a
+    // trailing count ("CBT (158)") via the shared facet chip's `aria-label` —
+    // section 3's "how many would I have if I ticked this as well" — so match
+    // on the prefix rather than the exact string.
+    const cbtToggle = therapyFilterPanel.getByRole("button", { name: /^CBT/ });
+    const reviewedToggle = therapyFilterPanel.getByRole("button", { name: /^Reviewed only/ });
     await expect(cbtToggle).toHaveAttribute("aria-pressed", "false");
     await cbtToggle.click();
     await expect(cbtToggle).toHaveAttribute("aria-pressed", "true");
-    await reviewedToggle.click();
-    await expect(reviewedToggle).toHaveAttribute("aria-pressed", "true");
+    // The current catalogue has no reviewed records, so the shared facet
+    // contract correctly disables a zero-count option rather than offering a
+    // control that can never produce results.
+    await expect(reviewedToggle).toBeDisabled();
+    await expect(reviewedToggle).toHaveAttribute("aria-pressed", "false");
     await expect(cbtToggle).toHaveAttribute("aria-pressed", "true");
 
-    await therapyFilterPanel.getByTestId("therapy-filter-clear").click();
+    await therapyFilterPanel.getByTestId("therapy-filter-panel-clear").click();
     await expect(cbtToggle).toHaveAttribute("aria-pressed", "false");
     await expect(reviewedToggle).toHaveAttribute("aria-pressed", "false");
 
-    await therapyFilterPanel.getByTestId("therapy-filter-done").click();
+    await therapyFilterPanel.getByTestId("therapy-filter-panel-done").click();
     await expect(therapyFilterPanel).toHaveCount(0);
 
     // End-to-end guard the component tests cannot give: it is `SearchScreen`
-    // that decides what the trigger counts. A query-only session must offer
-    // Clear all (the phone's only route to `clearSearch`) while the badge still
-    // reports no filters, because a search term is not a filter.
+    // that decides what the trigger counts, and what the sheet's Clear all
+    // can reach. A query-only session has nothing for the filter sheet to
+    // clear — the composer's own "Clear search" already covers the query, on
+    // every breakpoint — so Clear all must be absent rather than present and
+    // wiping a search the reader cannot see it is about to lose
+    // (docs/filter-contract.md section 6: "onClearAll never touches the query").
     await page.goto("/therapy-compass/search?q=anxiety", { waitUntil: "domcontentloaded" });
     await expect(therapyRibbon.getByRole("heading", { level: 1 })).toBeVisible({ timeout: 60_000 });
-    const queryOnlyTrigger = therapyRibbon.getByTestId("therapy-filter-trigger");
+    const queryOnlyTrigger = therapyRibbon.getByTestId("therapy-filter-trigger-phone");
     await expect(queryOnlyTrigger).toHaveAccessibleName(/No filters active/);
     await queryOnlyTrigger.click();
     const queryOnlyPanel = page.getByTestId("therapy-filter-panel");
-    await expect(queryOnlyPanel.getByTestId("therapy-filter-clear")).toBeVisible();
-    await queryOnlyPanel.getByTestId("therapy-filter-done").click();
+    await expect(queryOnlyPanel.getByTestId("therapy-filter-panel-clear")).toHaveCount(0);
+    await queryOnlyPanel.getByTestId("therapy-filter-panel-done").click();
 
     await expectNoPageHorizontalOverflow(page);