diff --git a/docs/proposals/repeated-word-check/checks-ui-integration-suggestion.md b/docs/proposals/repeated-word-check/checks-ui-integration-suggestion.md
index 43756f3a..dac70a6d 100644
--- a/docs/proposals/repeated-word-check/checks-ui-integration-suggestion.md
+++ b/docs/proposals/repeated-word-check/checks-ui-integration-suggestion.md
@@ -24,14 +24,14 @@ This document's own decisions are numbered **W1–W12** (W = web) to avoid colli
 
 Revisions made in response to PR [#305](https://github.com/eten-tech-foundation/fluent-web/pull/305) review (reviewers: kaseywright, chadw-eten; product input via joelthe1/Ulf). The cards themselves were edited mid-review; this revision tracks the **current** card text and mocks (re-pulled 2026-06-16).
 
-| Change | Driver | Where |
-| --- | --- | --- |
-| Settings endpoint moves from `GET/PUT /users/settings` to a new **`self` domain**: `GET/PUT /self/settings`, guarded by `authenticateUser` alone. | kaseywright (CHANGES_REQUESTED): clean semantic separation, no redundant `{id}` param, no over-exposure risk, simpler middleware (no `requireSelf`/`requireUserAccess`/`UserPolicy`). | W7, §7.2, §8 |
-| Button labels become **"Ignore Here" / "Ignore Everywhere"**. | joelthe1/Ulf (card #278 comment); chadw updated the #278 mocks to match. | W6, §5, §6.5 |
-| **"Ignore Everywhere" now shows a confirmation dialog**, while remaining reversible via `[Undo ▾]`. | card #278 ("Ignore Always should have a standard confirm dialog"). Kept the three-layer cascade & undo (no explicit directive against it; ambiguity of "undo" with surface/suppress entries at multiple layers is better resolved by the cascade — see §6.4/§6.5); added the dialog. | W6, §5.3, §6.5 |
-| **"Show Ignored" toggle**: now default **OFF** and **not persisted** (resets per session). Ignored items show the ignore-type label (e.g. _"Ignore Here"_, _"Ignore Everywhere"_, _"Default Ignore"_) + an **"Undo Ignore"** control. | card #278 was revised to specify exactly this; we drop our earlier default-ON/persisted proposal and the `showResolvedChecks` editor-state key. | W5, W6, W11, §5.3, §6.4, §6.6, §7.1 |
-| §5.2 mock/text inconsistencies **S1 (zero-state dot)** and **S2 (language dropdown)** are **resolved**: chadw fixed the zero-state mock and removed the language dropdown from the #278 Checks mocks. | chadw-eten ("Fixed." / "good idea… I have adjusted the mocks."). | §5.2, §12 |
-| New requirement adopted: **highlight repeated words in the verse text** (underline/color). | joelthe1/Ulf (card #278 comment). We will implement it; because it touches the verse-rendering pane (outside the left panel this proposal builds) and warrants its own design pass, it ships as a **separate, follow-on PR** so the tab/panel work can land independently. §5.3 item 4 records the intent; the visual/interaction details are specced just before that PR. | §5.3, §11 |
+| Change                                                                                                                                                                                                                                | Driver                                                                                                                                                                                                                                                                                                                                                                     | Where                               |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- |
+| Settings endpoint moves from `GET/PUT /users/settings` to a new **`self` domain**: `GET/PUT /self/settings`, guarded by `authenticateUser` alone.                                                                                     | kaseywright (CHANGES_REQUESTED): clean semantic separation, no redundant `{id}` param, no over-exposure risk, simpler middleware (no `requireSelf`/`requireUserAccess`/`UserPolicy`).                                                                                                                                                                                      | W7, §7.2, §8                        |
+| Button labels become **"Ignore Here" / "Ignore Everywhere"**.                                                                                                                                                                         | joelthe1/Ulf (card #278 comment); chadw updated the #278 mocks to match.                                                                                                                                                                                                                                                                                                   | W6, §5, §6.5                        |
+| **"Ignore Everywhere" now shows a confirmation dialog**, while remaining reversible via `[Undo ▾]`.                                                                                                                                   | card #278 ("Ignore Always should have a standard confirm dialog"). Kept the three-layer cascade & undo (no explicit directive against it; ambiguity of "undo" with surface/suppress entries at multiple layers is better resolved by the cascade — see §6.4/§6.5); added the dialog.                                                                                       | W6, §5.3, §6.5                      |
+| **"Show Ignored" toggle**: now default **OFF** and **not persisted** (resets per session). Ignored items show the ignore-type label (e.g. _"Ignore Here"_, _"Ignore Everywhere"_, _"Default Ignore"_) + an **"Undo Ignore"** control. | card #278 was revised to specify exactly this; we drop our earlier default-ON/persisted proposal and the `showResolvedChecks` editor-state key.                                                                                                                                                                                                                            | W5, W6, W11, §5.3, §6.4, §6.6, §7.1 |
+| §5.2 mock/text inconsistencies **S1 (zero-state dot)** and **S2 (language dropdown)** are **resolved**: chadw fixed the zero-state mock and removed the language dropdown from the #278 Checks mocks.                                 | chadw-eten ("Fixed." / "good idea… I have adjusted the mocks.").                                                                                                                                                                                                                                                                                                           | §5.2, §12                           |
+| New requirement adopted: **highlight repeated words in the verse text** (underline/color).                                                                                                                                            | joelthe1/Ulf (card #278 comment). We will implement it; because it touches the verse-rendering pane (outside the left panel this proposal builds) and warrants its own design pass, it ships as a **separate, follow-on PR** so the tab/panel work can land independently. §5.3 item 4 records the intent; the visual/interaction details are specced just before that PR. | §5.3, §11                           |
 
 ---
 
@@ -54,12 +54,12 @@ The ignore actions require server-side persistence that does not exist yet. #172
 
 ### 1.2 Repos touched
 
-| Repo | Touched | What changes |
-| --- | --- | --- |
-| **fluent-web** | yes (bulk) | Left-panel tab container, Checks panel feature, check-trigger hook, suppression cascade, editor-state keys. |
-| **fluent-api** | yes (small) | New `user_settings` table + a new `self` domain exposing `GET/PUT /self/settings`; Zod-schema extension of the editor-state `resources` blob (no migration). |
-| **fluent-ai** | no | The check itself is unchanged. |
-| **fluent-platform** | no | No new services or env vars. |
+| Repo                | Touched     | What changes                                                                                                                                                 |
+| ------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **fluent-web**      | yes (bulk)  | Left-panel tab container, Checks panel feature, check-trigger hook, suppression cascade, editor-state keys.                                                  |
+| **fluent-api**      | yes (small) | New `user_settings` table + a new `self` domain exposing `GET/PUT /self/settings`; Zod-schema extension of the editor-state `resources` blob (no migration). |
+| **fluent-ai**       | no          | The check itself is unchanged.                                                                                                                               |
+| **fluent-platform** | no          | No new services or env vars.                                                                                                                                 |
 
 ---
 
@@ -92,20 +92,20 @@ The ignore actions require server-side persistence that does not exist yet. #172
 
 Restated conclusions; supporting analysis in the cited sections.
 
-| # | Decision | Short rationale |
-| --- | --- | --- |
-| **W1** | Suppression persistence ships as an extension of #172's scope; no new product card. | #172's wording covers backend dependencies of the UI work; D1's deferral was about caching tool results, not user preferences. See §1.1. |
-| **W2** | Hybrid storage: "Ignore This Time" lives in the existing per-chapter editor-state JSONB (schema-key addition, no migration); "Ignore Always" lives in a new `user_settings` table (one row per user, single Zod-typed JSONB column). Findings are filtered **client-side**. | Each rule is stored at exactly the scope it governs. Client-side filtering keeps the AI proxy a pure pass-through (D8/D9). `user_settings` deliberately establishes Fluent's user-global preference store: future settings become schema extensions, not migrations. See §7. |
-| **W3** | Chapter-wide check on every successful verse save: a TanStack `useQuery` keyed on `(chapterAssignmentId, saveCounter)`, where `saveCounter` increments in the verse-save mutation's `onSuccess`. The request sends **all currently drafted verses** of the chapter. No extra coalescing debounce. | The dot needs chapter-wide awareness; per-verse merging is more code for no user-visible gain. The existing 2 s per-verse save debounce already rate-limits; the check is <1 s. KISS — optimize if heavier checks arrive. See §6.2. |
-| **W4** | `snt_id` = `"{bookCode} {chapter}:{verse}"` (USFM book code, e.g. `JDG 4:3`), matching the convention already used by the repo smoke tests. Occurrence identity for suppressions = `(snt_id, repeated_word, ordinal)` where ordinal is the index of the finding among same-`repeated_word` findings in the verse, ordered by `start_position`. | Ordinals survive unrelated edits (positions don't); adding/removing an earlier same-pair occurrence conservatively re-flags, the safe failure direction. We count Greek Room's findings, never tokenize text ourselves, so Greek Room's equivalence policy is inherited consistently. See §6.3. |
-| **W5** | Every finding resolves to **active/inactive** via a three-layer cascade — Greek Room verdict (`legitimate`), user-global word-pair rule, occurrence rule — where the **most specific non-silent verdict wins**. Rules are tri-state maps (`absent / 'suppress' / 'surface'`). The dot counts active findings only. Inactive findings are hidden by default and revealed by the **"Show Ignored" toggle** (default OFF, not persisted, per revised #278); when shown they render greyed with the ignore-type label. | One mechanism explains machine-legitimate and user-ignored alike ("pre-ignored by Greek Room"). Specificity, not temporal order, keeps resolution deterministic. Greyed-not-removed (under the toggle) keeps undo discoverable. See §6.4. |
-| **W6** | Active findings show `[Ignore Here] [Ignore Everywhere]` (per revised card). `[Ignore Everywhere]` opens a **standard confirm dialog** before writing the global rule. Inactive findings show one `[Undo ▾]` split button: default click acts at the occurrence layer (delete own rule, or write an occurrence `surface` override); the chevron menu offers explicit global actions with consequence-naming labels. Any global write first purges the user's occurrence rules for that pair **in the current chapter's editor state only**. | Default click never silently edits global state. The card asks for a confirm on the global action because it reads as irreversible; we add the dialog **and** keep the `[Undo ▾]` reversibility — the two are complementary (confirm guards the click; undo guards the mistake). Purge-local prevents the just-clicked panel from appearing to ignore the action; other chapters' specific pronouncements deliberately stand. See §6.5. |
-| **W7** | Settings endpoint lives in a **new `self` domain**: **`GET /self/settings` + `PUT /self/settings`**, session-implicit user (no user in URL), guarded by `authenticateUser` alone, full-replace upsert of one Zod-typed JSONB blob. File quartet `domains/self/settings/self-settings.{route,service,repository,types}.ts`. | Per kaseywright: a `self` domain gives clean semantic separation, avoids the redundant `{userId}` param (and the `requireSelf`/`UserPolicy` middleware that `/users/{id}/…` routes carry), and prevents accidental over-exposure (no `{id}` to misuse). Last-writer-wins on concurrent tabs is inherited from editor-state and accepted. See §8. |
-| **W8** | Graceful degradation by feature detection: if `GET /self/settings` 404s, the session records `globalIgnoresAvailable = false` and the `[Ignore Everywhere]` button plus global menu entries are **not rendered** (capability hidden, never a dead control). Unknown/absent JSONB keys parse as empty on both sides. Either repo's PR can land first. | The UI must not assume the backend half exists. An invisible capability is honest; a dead button is a bug report. See §9. |
-| **W9** | Check-call failure surfaces as a single inline `text-sm text-red-500` line at the top of the Checks panel ("Checks failed to refresh"); the panel keeps rendering the last successful findings (TanStack keeps `query.data` on refetch failure) and the dot reflects that last-known state. Failures log via the existing `Logger`. No toast/banner/popup. | Matches the drafting page's own inline-status precedent ("Auto-save failed"). Failure mode degrades to "results are one save behind." See §9.2. |
-| **W10** | The check runs in drafting mode only — not in the read-only `/view` route — and is skipped (`enabled: false`) when no verse has content and while the settings feature-detection probe (§9.1) is unresolved. | Card scope is the drafting view; empty chapters have nothing to check; the probe is one fast `GET`, and waiting for it means the first findings render is already cascade-correct. Review-stage checks are future work. See §6.2. |
-| **W11** | Left-panel architecture follows the mocks: a text-tab header row ("Resources \| Checks", blue underline active state, blue dot after "Checks"), dot visible from either tab; Checks content = per-check accordion sections with verse-grouped snippets, the two buttons, and a "Show Ignored" toggle at the bottom; zero state inside the accordion. Only `activeLeftTab` is persisted in editor state (the "Show Ignored" state resets per session, per revised #278). Proposed deviation for sign-off: when the whole panel is closed, the dot is mirrored on the panel-toggle button. | Mock-faithful where the mocks speak; the toggle-button dot preserves #277's intent (translator is notified) when the panel is hidden. See §5. |
-| **W12** | One proposal document (this file) covering both repos; two implementation PRs (fluent-web, fluent-api), cross-referencing each other and the cards. | Splitting the proposal doubles reviewer overhead for a design whose halves only make sense together. See §9.4. |
+| #       | Decision                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Short rationale                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **W1**  | Suppression persistence ships as an extension of #172's scope; no new product card.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | #172's wording covers backend dependencies of the UI work; D1's deferral was about caching tool results, not user preferences. See §1.1.                                                                                                                                                                                                                                                                                                |
+| **W2**  | Hybrid storage: "Ignore This Time" lives in the existing per-chapter editor-state JSONB (schema-key addition, no migration); "Ignore Always" lives in a new `user_settings` table (one row per user, single Zod-typed JSONB column). Findings are filtered **client-side**.                                                                                                                                                                                                                                                                                                              | Each rule is stored at exactly the scope it governs. Client-side filtering keeps the AI proxy a pure pass-through (D8/D9). `user_settings` deliberately establishes Fluent's user-global preference store: future settings become schema extensions, not migrations. See §7.                                                                                                                                                            |
+| **W3**  | Chapter-wide check on every successful verse save: a TanStack `useQuery` keyed on `(chapterAssignmentId, saveCounter)`, where `saveCounter` increments in the verse-save mutation's `onSuccess`. The request sends **all currently drafted verses** of the chapter. No extra coalescing debounce.                                                                                                                                                                                                                                                                                        | The dot needs chapter-wide awareness; per-verse merging is more code for no user-visible gain. The existing 2 s per-verse save debounce already rate-limits; the check is <1 s. KISS — optimize if heavier checks arrive. See §6.2.                                                                                                                                                                                                     |
+| **W4**  | `snt_id` = `"{bookCode} {chapter}:{verse}"` (USFM book code, e.g. `JDG 4:3`), matching the convention already used by the repo smoke tests. Occurrence identity for suppressions = `(snt_id, repeated_word, ordinal)` where ordinal is the index of the finding among same-`repeated_word` findings in the verse, ordered by `start_position`.                                                                                                                                                                                                                                           | Ordinals survive unrelated edits (positions don't); adding/removing an earlier same-pair occurrence conservatively re-flags, the safe failure direction. We count Greek Room's findings, never tokenize text ourselves, so Greek Room's equivalence policy is inherited consistently. See §6.3.                                                                                                                                         |
+| **W5**  | Every finding resolves to **active/inactive** via a three-layer cascade — Greek Room verdict (`legitimate`), user-global word-pair rule, occurrence rule — where the **most specific non-silent verdict wins**. Rules are tri-state maps (`absent / 'suppress' / 'surface'`). The dot counts active findings only. Inactive findings are hidden by default and revealed by the **"Show Ignored" toggle** (default OFF, not persisted, per revised #278); when shown they render greyed with the ignore-type label.                                                                       | One mechanism explains machine-legitimate and user-ignored alike ("pre-ignored by Greek Room"). Specificity, not temporal order, keeps resolution deterministic. Greyed-not-removed (under the toggle) keeps undo discoverable. See §6.4.                                                                                                                                                                                               |
+| **W6**  | Active findings show `[Ignore Here] [Ignore Everywhere]` (per revised card). `[Ignore Everywhere]` opens a **standard confirm dialog** before writing the global rule. Inactive findings show one `[Undo ▾]` split button: default click acts at the occurrence layer (delete own rule, or write an occurrence `surface` override); the chevron menu offers explicit global actions with consequence-naming labels. Any global write first purges the user's occurrence rules for that pair **in the current chapter's editor state only**.                                              | Default click never silently edits global state. The card asks for a confirm on the global action because it reads as irreversible; we add the dialog **and** keep the `[Undo ▾]` reversibility — the two are complementary (confirm guards the click; undo guards the mistake). Purge-local prevents the just-clicked panel from appearing to ignore the action; other chapters' specific pronouncements deliberately stand. See §6.5. |
+| **W7**  | Settings endpoint lives in a **new `self` domain**: **`GET /self/settings` + `PUT /self/settings`**, session-implicit user (no user in URL), guarded by `authenticateUser` alone, full-replace upsert of one Zod-typed JSONB blob. File quartet `domains/self/settings/self-settings.{route,service,repository,types}.ts`.                                                                                                                                                                                                                                                               | Per kaseywright: a `self` domain gives clean semantic separation, avoids the redundant `{userId}` param (and the `requireSelf`/`UserPolicy` middleware that `/users/{id}/…` routes carry), and prevents accidental over-exposure (no `{id}` to misuse). Last-writer-wins on concurrent tabs is inherited from editor-state and accepted. See §8.                                                                                        |
+| **W8**  | Graceful degradation by feature detection: if `GET /self/settings` 404s, the session records `globalIgnoresAvailable = false` and the `[Ignore Everywhere]` button plus global menu entries are **not rendered** (capability hidden, never a dead control). Unknown/absent JSONB keys parse as empty on both sides. Either repo's PR can land first.                                                                                                                                                                                                                                     | The UI must not assume the backend half exists. An invisible capability is honest; a dead button is a bug report. See §9.                                                                                                                                                                                                                                                                                                               |
+| **W9**  | Check-call failure surfaces as a single inline `text-sm text-red-500` line at the top of the Checks panel ("Checks failed to refresh"); the panel keeps rendering the last successful findings (TanStack keeps `query.data` on refetch failure) and the dot reflects that last-known state. Failures log via the existing `Logger`. No toast/banner/popup.                                                                                                                                                                                                                               | Matches the drafting page's own inline-status precedent ("Auto-save failed"). Failure mode degrades to "results are one save behind." See §9.2.                                                                                                                                                                                                                                                                                         |
+| **W10** | The check runs in drafting mode only — not in the read-only `/view` route — and is skipped (`enabled: false`) when no verse has content and while the settings feature-detection probe (§9.1) is unresolved.                                                                                                                                                                                                                                                                                                                                                                             | Card scope is the drafting view; empty chapters have nothing to check; the probe is one fast `GET`, and waiting for it means the first findings render is already cascade-correct. Review-stage checks are future work. See §6.2.                                                                                                                                                                                                       |
+| **W11** | Left-panel architecture follows the mocks: a text-tab header row ("Resources \| Checks", blue underline active state, blue dot after "Checks"), dot visible from either tab; Checks content = per-check accordion sections with verse-grouped snippets, the two buttons, and a "Show Ignored" toggle at the bottom; zero state inside the accordion. Only `activeLeftTab` is persisted in editor state (the "Show Ignored" state resets per session, per revised #278). Proposed deviation for sign-off: when the whole panel is closed, the dot is mirrored on the panel-toggle button. | Mock-faithful where the mocks speak; the toggle-button dot preserves #277's intent (translator is notified) when the panel is hidden. See §5.                                                                                                                                                                                                                                                                                           |
+| **W12** | One proposal document (this file) covering both repos; two implementation PRs (fluent-web, fluent-api), cross-referencing each other and the cards.                                                                                                                                                                                                                                                                                                                                                                                                                                      | Splitting the proposal doubles reviewer overhead for a design whose halves only make sense together. See §9.4.                                                                                                                                                                                                                                                                                                                          |
 
 ---
 
@@ -141,7 +141,7 @@ The response envelope is consumed whole (D9): the hook inspects `status` and `re
 
 The cards' mockups (drafting page, Judges 4, Gujarati IRV project) define the visual target. The #278 mocks were updated during the first review round (§0); the description below tracks the **current** mocks:
 
-- **Tab header (#277 mock):** the left panel's current `Resources` heading is replaced by a text-tab row — **"Resources | Checks"** — active tab in blue with a blue underline, inactive tab plain. The **notification dot is a solid blue filled circle immediately right of the "Checks" label**, and the mock shows it while the *Resources* tab is active: the dot is visible from either tab whenever the panel is open.
+- **Tab header (#277 mock):** the left panel's current `Resources` heading is replaced by a text-tab row — **"Resources | Checks"** — active tab in blue with a blue underline, inactive tab plain. The **notification dot is a solid blue filled circle immediately right of the "Checks" label**, and the mock shows it while the _Resources_ tab is active: the dot is visible from either tab whenever the panel is open.
 - **Checks content (#278 mocks):** below the tab header, a card containing a **collapsible "Repeated Words" accordion section** (expanded by default). The accordion-per-check structure anticipates future sibling checks (the board already holds draft cards for Greek Room Wildebeest and Spell checks) without UI rework. Inside the section, findings are grouped by verse:
   - bold **"Verse N"** heading per verse that has findings (verses without findings get no group);
   - one row per occurrence: a one-line context snippet showing the repeated pair in context;
@@ -221,14 +221,14 @@ useQuery({
 - **Request body** is the full `RepeatedWordsRequest` (D8 shape): `lang_code`/`lang_name` from the project's target language, `project_id`/`project_name` from `projectItem`, and `verses[]` covering **all currently drafted verses** of the chapter (content from the drafting state, not a refetch — what the translator sees is what gets checked).
 - **`snt_id` = `"{bookCode} {chapter}:{verse}"`** with the USFM book code (e.g. `JDG 4:3`), the convention the repo smoke tests already use. Implementation note: verify the field carrying the USFM code on the drafting page's `projectItem` (vs. display name) and thread it into the builder.
 - **Where it runs (W10):** drafting route only; `enabled` is false in the read-only `/view` route (reviewers see no Checks activity in v1), when no verse has content, and while the settings feature-detection probe (§9.1) is unresolved — the probe is a single fast `GET`, and waiting for it means the first findings render is already cascade-correct (the user's global rules are known, present or absent).
-- **Emptied chapters resolve naturally:** any save of emptied text triggers a fresh check whose empty findings clear the panel and dot. (When *every* verse is emptied the query disables instead; the panel and dot then treat findings as empty rather than rendering stale data.)
+- **Emptied chapters resolve naturally:** any save of emptied text triggers a fresh check whose empty findings clear the panel and dot. (When _every_ verse is emptied the query disables instead; the panel and dot then treat findings as empty rather than rendering stale data.)
 
 ### 6.3 Occurrence identity (W4)
 
 A suppression must survive verse edits without our re-parsing text. The key is **`(snt_id, repeated_word, ordinal)`**:
 
 - `ordinal` = index of this finding among findings in the same verse with the same `repeated_word`, ordered by `start_position` ("x of n"). Computed from **Greek Room's findings only** — we never tokenize verse text ourselves, so Greek Room's case/diacritic equivalence policy is inherited and consistent between runs.
-- Ordinals survive unrelated edits (`start_position` does not). Adding or removing an *earlier* same-pair occurrence shifts later ordinals and conservatively re-flags — the safe failure direction.
+- Ordinals survive unrelated edits (`start_position` does not). Adding or removing an _earlier_ same-pair occurrence shifts later ordinals and conservatively re-flags — the safe failure direction.
 - String comparison between a stored rule's `repeated_word` and a fresh finding's: **NFC-normalize both, compare exactly, no case folding of our own.** Unicode case folding is locale-sensitive (the Turkish dotless-ı problem) and Fluent targets minority languages; NFC handles composed/decomposed accent variation. Note that Greek Room already delivers `repeated_word` lowercased ("word word" form, per the fluent-ai schema) — original casing lives only in `surf`, which we display but never compare — so case equivalence is wholly Greek Room's policy, inherited rather than re-implemented.
 - Documented caveat: a triple repetition ("the the the") yields two overlapping findings (ordinals 1 and 2). Mechanically fine; slightly odd UX; accepted for v1.
 
@@ -236,11 +236,11 @@ A suppression must survive verse edits without our re-parsing text. The key is *
 
 Every finding resolves through three layers; the **most specific non-silent verdict wins** (specificity, not temporal order — deterministic and reproducible from stored state):
 
-| Layer | Scope | Verdicts |
-| --- | --- | --- |
-| 0 — Greek Room | this finding | `active` (suspicious) / `inactive` (`legitimate: true`) — always present |
-| 1 — User global | word pair, all the user's projects | _silent_ / `suppress` / `surface` |
-| 2 — Occurrence | `(snt_id, repeated_word, ordinal)`, this chapter assignment | _silent_ / `suppress` / `surface` |
+| Layer           | Scope                                                       | Verdicts                                                                 |
+| --------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------ |
+| 0 — Greek Room  | this finding                                                | `active` (suspicious) / `inactive` (`legitimate: true`) — always present |
+| 1 — User global | word pair, all the user's projects                          | _silent_ / `suppress` / `surface`                                        |
+| 2 — Occurrence  | `(snt_id, repeated_word, ordinal)`, this chapter assignment | _silent_ / `suppress` / `surface`                                        |
 
 - Stored rules are **tri-state maps** (`key → 'suppress' | 'surface'`, absent = silent), not bare suppression sets — `surface` is what makes per-occurrence undo of a global rule (or of a Greek Room `legitimate` verdict) possible.
 - A machine-legitimate finding is conceptually "pre-ignored by Greek Room": same inactive state as user-ignored, different actor, same undo affordance.
@@ -253,17 +253,18 @@ Every finding resolves through three layers; the **most specific non-silent verd
 - **Confirm dialog on `[Ignore Everywhere]`** (revised #278): the card asks for it because the action reads as global and irreversible. We honor the request **and** keep the action reversible via `[Undo ▾]` below — the dialog guards the deliberate click; the undo guards a mistake that slips past it. The two are not redundant: confirm is pre-action friction, undo is post-action recourse.
 
   Why reversibility falls out of the design rather than being an extra feature we chose to bolt on — the implication chain (see also §6.4, which this depends on):
-  1. Greek Room reports **both** polarities: repetitions it flags (suspicious) and repetitions it judges `legitimate` (a *negative* / "don't flag" verdict).
+  1. Greek Room reports **both** polarities: repetitions it flags (suspicious) and repetitions it judges `legitimate` (a _negative_ / "don't flag" verdict).
   2. Once we decide to **show** the legitimate ones (§5.3 item 2 — so the translator can see what the checker waved through), it's natural to let the translator disagree and mark one **illegitimate** (re-surface it).
   3. Expressing "re-surface this" requires a **positive** record (`surface`), not only the negative (`suppress`) records an ignore-list would hold. So the stores must be tri-state, not suppression-only (§6.4).
-  4. Given positive *and* negative records at more than one scope, a **layered** model is the natural fit: a local (occurrence) record can override a global (word-pair) one, and the override works in **both polarities** (locally surface something suppressed globally, or locally suppress something surfaced).
-  5. With that layering in place, a single bare "undo" is **ambiguous** — at which layer, in which polarity? Resolving that ambiguity (the `[Undo ▾]` split button: default = act at the occurrence layer; chevron = act globally) is what the design *has* to do anyway — and the same mechanism incidentally gives the translator the "oops, I hit the wrong button" recourse for `[Ignore Everywhere]`. Reversibility is therefore inherited, not added.
+  4. Given positive _and_ negative records at more than one scope, a **layered** model is the natural fit: a local (occurrence) record can override a global (word-pair) one, and the override works in **both polarities** (locally surface something suppressed globally, or locally suppress something surfaced).
+  5. With that layering in place, a single bare "undo" is **ambiguous** — at which layer, in which polarity? Resolving that ambiguity (the `[Undo ▾]` split button: default = act at the occurrence layer; chevron = act globally) is what the design _has_ to do anyway — and the same mechanism incidentally gives the translator the "oops, I hit the wrong button" recourse for `[Ignore Everywhere]`. Reversibility is therefore inherited, not added.
 
   We are not requesting that this override the card's "cannot be undone" framing; it is documented here for anyone who wants to follow the reasoning, and the implemented PR is reviewed again before merge.
+
 - **Inactive finding:** one `[Undo ▾]` split button (shadcn `dropdown-menu`, already in the codebase — no hidden gestures):
-  - **Default click** acts at the occurrence layer: if inactive via its *own* occurrence rule → delete that entry; if inactive via a global rule or Greek Room's verdict → write an occurrence-level `surface` override (the global rule / machine verdict survives; only this occurrence resurfaces).
+  - **Default click** acts at the occurrence layer: if inactive via its _own_ occurrence rule → delete that entry; if inactive via a global rule or Greek Room's verdict → write an occurrence-level `surface` override (the global rule / machine verdict survives; only this occurrence resurfaces).
   - **Chevron menu** offers the deliberate global actions with consequence-naming labels, e.g. _"Stop ignoring 'the the' everywhere"_ (deletes the global entry).
-- **Global writes purge local rules — current chapter only.** Executing any global (everywhere) suppress or surface first deletes the user's occurrence-level rules for that word pair in the *current chapter assignment's* editor state, then writes the global rule. This is purely UI coherence: without it, the just-clicked panel would appear to ignore the action (occurrence beats global in the cascade). Occurrence rules in **other** chapters/projects deliberately stand — they were specific pronouncements, and we don't revert decisions from afar. Client-side operation; no special endpoint semantics.
+- **Global writes purge local rules — current chapter only.** Executing any global (everywhere) suppress or surface first deletes the user's occurrence-level rules for that word pair in the _current chapter assignment's_ editor state, then writes the global rule. This is purely UI coherence: without it, the just-clicked panel would appear to ignore the action (occurrence beats global in the cascade). Occurrence rules in **other** chapters/projects deliberately stand — they were specific pronouncements, and we don't revert decisions from afar. Client-side operation; no special endpoint semantics.
 - **Direct edits resolve silently** (card #278): if the translator fixes the text, the next auto-save's fresh findings simply no longer contain the occurrence — no action needed, panel and dot update.
 
 ### 6.6 Left-panel container and persisted UI state (W11)
@@ -273,7 +274,7 @@ Every finding resolves through three layers; the **most specific non-silent verd
 - **`LeftPanel`** owns the tab header row ("Resources | Checks", blue underline on the active tab, blue dot right of "Checks" when active findings exist) and renders either the existing `ResourcePanel` or the new `ChecksPanel` below it. `ResourcePanel` loses only its `<h3>Resources</h3>` heading (the tab row replaces it); its content, language dropdown, and accordion are untouched.
 - The dot's state comes from the cascade-resolved active count (§6.4), which `DraftingPage` computes once and threads to both `LeftPanel` (tab dot) and the header toggle button (mirror dot, §5.3 item 3). The check query runs at `DraftingPage` level — **not** inside `ChecksPanel` — so the dot stays live while the Resources tab (or a closed panel) is showing.
 - **Persisted UI state.** One new key rides the same per-chapter editor-state blob the page already saves (debounced 500 ms, §7.1): `activeLeftTab: 'resources' | 'checks'` (reopen where you left off). The **"Show Ignored"** toggle is deliberately **not** persisted — per revised #278 it resets to off each session — so it lives in component state only. The persisted key is cosmetic; failure to persist degrades to defaults.
-- The panel's existing resize/drag behavior and 20–40 % width constraints are inherited unchanged — `LeftPanel` lives *inside* the resizable container.
+- The panel's existing resize/drag behavior and 20–40 % width constraints are inherited unchanged — `LeftPanel` lives _inside_ the resizable container.
 
 ---
 
@@ -299,7 +300,7 @@ export const editorStateResourcesSchema = z
   .nullable();
 ```
 
-"Ignore This Time" is scoped to *this user's view of this chapter assignment* — precisely this table's grain. The fluent-api PR extends the schema with **optional** keys (old rows parse unchanged; **no SQL migration** — the column is already JSONB):
+"Ignore This Time" is scoped to _this user's view of this chapter assignment_ — precisely this table's grain. The fluent-api PR extends the schema with **optional** keys (old rows parse unchanged; **no SQL migration** — the column is already JSONB):
 
 ```ts
 export const editorStateResourcesSchema = z
@@ -312,9 +313,7 @@ export const editorStateResourcesSchema = z
     tabStatus: z.boolean(),
     // --- NEW, all optional (backward/forward compatible) ---
     activeLeftTab: z.enum(['resources', 'checks']).optional(),
-    checkOccurrenceRules: z
-      .record(z.string(), z.enum(['suppress', 'surface']))
-      .optional(),
+    checkOccurrenceRules: z.record(z.string(), z.enum(['suppress', 'surface'])).optional(),
   })
   .nullable();
 ```
@@ -331,9 +330,7 @@ export const editorStateResourcesSchema = z
 // fluent-api/src/db/schema.ts — NEW
 export const userSettingsSchema = z
   .object({
-    checkIgnoredWordPairs: z
-      .record(z.string(), z.enum(['suppress', 'surface']))
-      .optional(),
+    checkIgnoredWordPairs: z.record(z.string(), z.enum(['suppress', 'surface'])).optional(),
   })
   .catch({}); // unknown/old shapes parse as empty, never throw (W8)
 
@@ -359,7 +356,7 @@ export const user_settings = pgTable('user_settings', {
 The alternative — teaching the AI proxy to subtract suppressed findings server-side — was rejected:
 
 1. It breaks the proxy's reviewed role as a **verbatim pass-through** (D8: contract mirrored exactly; D9: envelope passthrough). Filtering injects Fluent domain state into an AI-contract endpoint.
-2. The cascade needs *all* findings anyway to render inactive items with reason labels (§5.3 item 1) — a server that pre-filters would have to return them annotated regardless, which is the client cascade with extra steps.
+2. The cascade needs _all_ findings anyway to render inactive items with reason labels (§5.3 item 1) — a server that pre-filters would have to return them annotated regardless, which is the client cascade with extra steps.
 3. Suppression maps are small (a translator's ignore list, not a corpus) and already at the client's fingertips via blobs it loads for other reasons.
 
 The proxy therefore remains untouched by this proposal.
@@ -370,7 +367,7 @@ The proxy therefore remains untouched by this proposal.
 
 The settings endpoint lives in a **new `self` domain**, requested by kaseywright in review. `self` is the authenticated caller acting on their own resources — the route never names a user. This is cleaner than hanging settings off `/users/{userId}/…`:
 
-- **Clean semantic separation** — `self/*` is unambiguously "me," leaving the `users/*` domain for (future) admin-style tooling that operates on *other* users by id.
+- **Clean semantic separation** — `self/*` is unambiguously "me," leaving the `users/*` domain for (future) admin-style tooling that operates on _other_ users by id.
 - **No redundant `{userId}` param** — the user comes from the session, not the URL (the same source `user-chapter-assignment-editor-state.route.ts` already uses).
 - **No accidental over-exposure** — with no `{id}` in the path there is nothing to mis-scope; contrast `/users/{userId}/projects`, which must add `requireSelf()` to stop one user reading another's data.
 - **Simpler middleware** — just `authenticateUser`. No `requireSelf`, no `requireUserAccess`, no `UserPolicy`.
@@ -379,10 +376,10 @@ Otherwise it keeps the editor-state idiom: **full-replace upsert** on PUT, one Z
 
 ### 8.1 Routes
 
-| Method | Path | Auth | Body | Response |
-| --- | --- | --- | --- | --- |
-| `GET` | `/self/settings` | `authenticateUser` only | — | `200` `{ settings: UserSettings \| null, updatedAt }` — `settings: null` when the user has no row yet (mirrors editor-state's no-state-yet response; **not** a 404) |
-| `PUT` | `/self/settings` | `authenticateUser` only | `{ settings: UserSettings }` | `200` saved state; `400` on schema violation |
+| Method | Path             | Auth                    | Body                         | Response                                                                                                                                                            |
+| ------ | ---------------- | ----------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GET`  | `/self/settings` | `authenticateUser` only | —                            | `200` `{ settings: UserSettings \| null, updatedAt }` — `settings: null` when the user has no row yet (mirrors editor-state's no-state-yet response; **not** a 404) |
+| `PUT`  | `/self/settings` | `authenticateUser` only | `{ settings: UserSettings }` | `200` saved state (`{ settings, updatedAt }`); `422` on schema violation (a well-formed request whose body fails validation)                                        |
 
 - **No permission middleware beyond `authenticateUser`.** Every caller owns exactly their own settings row, and the handler scopes all reads/writes to `currentUser.id` from context. (Editor-state additionally guards with `CONTENT_UPDATE` + chapter-assignment participation because it is tied to a chapter resource; `self/settings` has no resource to scope, so session identity alone is the right guard — and the `self` prefix makes that explicit.)
 - **PUT is full-replace.** The client GETs, merges in memory, PUTs the whole blob — the editor-state write pattern. Concurrent tabs are last-writer-wins, identical to editor-state's accepted behavior; for an ignore-list this worst case is "one ignore from another tab is lost until re-clicked."
@@ -398,7 +395,7 @@ fluent-api/src/domains/self/settings/
 └── self-settings.types.ts        # response schema; re-exports UserSettings from db schema
 ```
 
-Plus: the `user_settings` table + `userSettingsSchema` in `src/db/schema.ts` (§7.2), one numbered migration in `src/db/migrations/`, and route registration in `src/app.ts`. (The table is still named `user_settings` — it stores per-user rows; only the *route* surface is `self`. The repository upserts on the `userId` PK using the session user's id.)
+Plus: the `user_settings` table + `userSettingsSchema` in `src/db/schema.ts` (§7.2), one numbered migration in `src/db/migrations/`, and route registration in `src/app.ts`. (The table is still named `user_settings` — it stores per-user rows; only the _route_ surface is `self`. The repository upserts on the `userId` PK using the session user's id.)
 
 ### 8.3 What fluent-api explicitly does **not** do
 
@@ -426,14 +423,14 @@ When the repeated-words query errors (network, 502 `AI_SERVICE_UNAVAILABLE` / `A
 - A single inline line renders at the top of the Checks panel: `Checks failed to refresh` in `text-sm text-red-500` — the drafting page's own status idiom (it already shows "Auto-save failed" inline in the header). **No toast, banner, or popup**; none exist in this codebase and a transient check hiccup doesn't warrant introducing one.
 - TanStack Query retains the last successful `data` on refetch failure, so the panel **keeps rendering the last-known findings** below the error line, and the dot reflects that last-known state. The failure mode is "results are one save behind," not "results vanish."
 - The error is logged via the existing `Logger` for diagnosis; the next successful auto-save naturally retries (new `saveCounter` key).
-- A failure on the *initial* load (no previous data) renders the error line over an empty section — not the "No issues found" zero state, which must never appear on error.
+- A failure on the _initial_ load (no previous data) renders the error line over an empty section — not the "No issues found" zero state, which must never appear on error.
 
 ### 9.3 Suppression-write failure
 
 Ignore actions apply **optimistically** (the finding greys immediately) and roll back on write failure:
 
 - Occurrence rules ride the debounced editor-state save; a failed save leaves the in-memory rule intact and retries with the next editor-state write (the page already tolerates editor-state save failures this way).
-- Global rules PUT immediately; on failure the optimistic update is reverted (the finding returns to active) and the action can be re-clicked. No queued retry for v1 — the user sees the flag come back, which *is* the failure notification.
+- Global rules PUT immediately; on failure the optimistic update is reverted (the finding returns to active) and the action can be re-clicked. No queued retry for v1 — the user sees the flag come back, which _is_ the failure notification.
 
 ### 9.4 Rollout / landing order (W12)
 
@@ -451,21 +448,21 @@ Ignore actions apply **optimistically** (the finding greys immediately) and roll
 
 The repo now ships test infrastructure under `src/test/` (`msw/server.ts`, `render.tsx`, `setup.ts`); all UI tests use it — MSW intercepts at the network boundary, so the hooks under test exercise their real fetch paths.
 
-| Area | Representative cases |
-| --- | --- |
-| `useResolvedFindings` (pure) | Cascade precedence table: machine-legitimate vs. global vs. occurrence, `suppress`/`surface`/silent at each layer, most-specific-wins; ordinal assignment incl. "the the the" overlap; NFC composed/decomposed key equivalence. |
-| `useRepeatedWordsCheck` | Fires on `saveCounter` change; request body shape (snake_case verbatim, `snt_id` format, all drafted verses); `enabled` gating (readOnly, empty chapter); previous data retained on 502 (MSW error handler). |
-| `useSuppressions` | Feature-detect: 404 ⇒ `globalIgnoresAvailable=false`; 200-with-null ⇒ available; occurrence rule round-trip through editor-state blob; global write purges current-chapter occurrence rules for the pair; optimistic rollback on PUT failure. |
-| `ChecksPanel` / `FindingRow` | Verse grouping + separators; zero state (and *not* on error); inline error line; active `[Ignore Here]`/`[Ignore Everywhere]` vs. greyed-with-label + `[Undo ▾]`; "Show Ignored" toggle defaults off and is not persisted; `[Ignore Everywhere]` opens confirm dialog and only writes on confirm; `[Ignore Everywhere]` absent when capability unavailable. |
-| `LeftPanel` / dot | Dot iff cascade-active > 0, visible from Resources tab; tab switch persistence key written; toggle-button mirror dot when panel closed. |
+| Area                         | Representative cases                                                                                                                                                                                                                                                                                                                                        |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `useResolvedFindings` (pure) | Cascade precedence table: machine-legitimate vs. global vs. occurrence, `suppress`/`surface`/silent at each layer, most-specific-wins; ordinal assignment incl. "the the the" overlap; NFC composed/decomposed key equivalence.                                                                                                                             |
+| `useRepeatedWordsCheck`      | Fires on `saveCounter` change; request body shape (snake_case verbatim, `snt_id` format, all drafted verses); `enabled` gating (readOnly, empty chapter); previous data retained on 502 (MSW error handler).                                                                                                                                                |
+| `useSuppressions`            | Feature-detect: 404 ⇒ `globalIgnoresAvailable=false`; 200-with-null ⇒ available; occurrence rule round-trip through editor-state blob; global write purges current-chapter occurrence rules for the pair; optimistic rollback on PUT failure.                                                                                                               |
+| `ChecksPanel` / `FindingRow` | Verse grouping + separators; zero state (and _not_ on error); inline error line; active `[Ignore Here]`/`[Ignore Everywhere]` vs. greyed-with-label + `[Undo ▾]`; "Show Ignored" toggle defaults off and is not persisted; `[Ignore Everywhere]` opens confirm dialog and only writes on confirm; `[Ignore Everywhere]` absent when capability unavailable. |
+| `LeftPanel` / dot            | Dot iff cascade-active > 0, visible from Resources tab; tab switch persistence key written; toggle-button mirror dot when panel closed.                                                                                                                                                                                                                     |
 
 ### 10.2 fluent-api (Vitest, route-level — same style as the ai-tools and editor-state tests)
 
-| Area | Representative cases |
-| --- | --- |
-| `GET /self/settings` | 401 unauthenticated; `settings: null` for new user (200, not 404); returns saved blob; user isolation (only own row, scoped to session user). |
-| `PUT /self/settings` | Upsert create + replace; 400 on schema violation; full-replace semantics (omitted keys gone); `.catch({})` tolerance on read of unknown-shaped stored blobs. |
-| Editor-state schema extension | Existing editor-state tests still pass unchanged (proves backward compatibility); round-trip of `checkOccurrenceRules` / `activeLeftTab`. |
+| Area                          | Representative cases                                                                                                                                         |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `GET /self/settings`          | 401 unauthenticated; `settings: null` for new user (200, not 404); returns saved blob; user isolation (only own row, scoped to session user).                |
+| `PUT /self/settings`          | Upsert create + replace; 400 on schema violation; full-replace semantics (omitted keys gone); `.catch({})` tolerance on read of unknown-shaped stored blobs. |
+| Editor-state schema extension | Existing editor-state tests still pass unchanged (proves backward compatibility); round-trip of `checkOccurrenceRules` / `activeLeftTab`.                    |
 
 Manual verification continues to use the stack via `fluent-platform` compose plus the existing repeated-words smoke script for the proxy half.
 
@@ -486,16 +483,16 @@ Manual verification continues to use the stack via `fluent-platform` compose plu
 
 Items needing explicit confirmation in review (referenced from §5.2/§5.3); none block reading the rest of the design. Status reflects the first review round (§0):
 
-| # | Item | Proposed resolution | Status |
-| --- | --- | --- | --- |
-| S1 | Zero-state mock showed the notification dot; #277 text says no flags ⇒ no dot | Follow the text: no dot at zero active flags | ✅ Resolved — chadw fixed the mock |
-| S2 | #278 mocks showed a language dropdown above checks content | Omit it on the Checks tab (no function for checks) | ✅ Resolved — chadw removed it from the mocks |
-| S3 | Card originally said ignored items are "removed from the panel" | Reveal them dimmed under a "Show Ignored" toggle (default off, not persisted) with "Undo Ignore"; dot unaffected | ✅ Largely card-aligned — revised #278 added the toggle; confirm the labels match |
-| S4 | Cards did not enumerate Greek-Room-`legitimate` findings | Show as ignored items labeled **"Default Ignore"** (the revised #278 mock's term), per-occurrence surfaceable | ☑ Confirm "Default Ignore" = machine-legitimate |
-| S5 | Dot is invisible when the whole left panel is closed | Mirror the dot on the panel-toggle button while closed | ☐ Open |
-| S6 | Suppression persistence has no card of its own | Ship as extension of #172's scope (W1) — backend dependency of the UI cards | ☐ Open |
-| S7 | Revised #278 confirm dialog says "Ignore Everywhere" "cannot be undone" | Add the confirm dialog **and** keep `[Undo ▾]` reversibility (§6.5); the two are complementary | ☐ Confirm we may retain undo |
-| S8 | Highlight repeated words in the verse text (joelthe1/Ulf) | We will implement it as a **follow-on PR** layered on this one (verse-pane scope; §5.3 item 4) | ☐ Confirm follow-on-PR sequencing |
+| #   | Item                                                                          | Proposed resolution                                                                                              | Status                                                                            |
+| --- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| S1  | Zero-state mock showed the notification dot; #277 text says no flags ⇒ no dot | Follow the text: no dot at zero active flags                                                                     | ✅ Resolved — chadw fixed the mock                                                |
+| S2  | #278 mocks showed a language dropdown above checks content                    | Omit it on the Checks tab (no function for checks)                                                               | ✅ Resolved — chadw removed it from the mocks                                     |
+| S3  | Card originally said ignored items are "removed from the panel"               | Reveal them dimmed under a "Show Ignored" toggle (default off, not persisted) with "Undo Ignore"; dot unaffected | ✅ Largely card-aligned — revised #278 added the toggle; confirm the labels match |
+| S4  | Cards did not enumerate Greek-Room-`legitimate` findings                      | Show as ignored items labeled **"Default Ignore"** (the revised #278 mock's term), per-occurrence surfaceable    | ☑ Confirm "Default Ignore" = machine-legitimate                                   |
+| S5  | Dot is invisible when the whole left panel is closed                          | Mirror the dot on the panel-toggle button while closed                                                           | ☐ Open                                                                            |
+| S6  | Suppression persistence has no card of its own                                | Ship as extension of #172's scope (W1) — backend dependency of the UI cards                                      | ☐ Open                                                                            |
+| S7  | Revised #278 confirm dialog says "Ignore Everywhere" "cannot be undone"       | Add the confirm dialog **and** keep `[Undo ▾]` reversibility (§6.5); the two are complementary                   | ☐ Confirm we may retain undo                                                      |
+| S8  | Highlight repeated words in the verse text (joelthe1/Ulf)                     | We will implement it as a **follow-on PR** layered on this one (verse-pane scope; §5.3 item 4)                   | ☐ Confirm follow-on-PR sequencing                                                 |
 
 Engineering-side confirmations sought from reviewers (same spirit as the D-series confirmations in the fluent-api proposal):
 
@@ -505,4 +502,4 @@ Engineering-side confirmations sought from reviewers (same spirit as the D-serie
 
 ---
 
-*Prepared against fluent-web `main` (post `2e936d1`), fluent-api `main` (post `7c7f63d`), and the approved fluent-api proposal (PR #173). Revised 2026-06-16 after the first review round on PR #305. Author: JEdward7777.*
+_Prepared against fluent-web `main` (post `2e936d1`), fluent-api `main` (post `7c7f63d`), and the approved fluent-api proposal (PR #173). Revised 2026-06-16 after the first review round on PR #305. Author: JEdward7777._
diff --git a/docs/proposals/repeated-word-check/checks-ui-integration-summary.md b/docs/proposals/repeated-word-check/checks-ui-integration-summary.md
index 12af7694..e51a1fe1 100644
--- a/docs/proposals/repeated-word-check/checks-ui-integration-summary.md
+++ b/docs/proposals/repeated-word-check/checks-ui-integration-summary.md
@@ -18,7 +18,7 @@ Give translators the user-facing half of the Repeated Word Check: a **Checks tab
 
 4. **Chapter-wide check on every successful verse auto-save** (W3/W4): a TanStack `useQuery` keyed on `(chapterAssignmentId, saveCounter)` sending all drafted verses; `snt_id` = `"{bookCode} {chapter}:{verse}"` (USFM, the smoke-test convention); no extra debounce beyond the existing 2 s save debounce. Drafting mode only (W10).
 
-5. **Three-layer active/inactive cascade, most-specific-non-silent-wins** (W5/W6): Greek Room's `legitimate` verdict → user-global word-pair rule → occurrence rule `(snt_id, repeated_word, ordinal)`; rules are tri-state maps (`absent/'suppress'/'surface'`), which is what makes per-occurrence **undo** of a global rule or machine verdict possible. The dot counts active findings only; ignored items are hidden by default and revealed dimmed (with "Default Ignore"/"Ignore Here"/"Ignore Always" reason labels and "Undo Ignore") under a **"Show Ignored" toggle** (default off, not persisted), matching the revised #278.
+5. **Three-layer active/inactive cascade, most-specific-non-silent-wins** (W5/W6): Greek Room's `legitimate` verdict → user-global word-pair rule → occurrence rule `(snt_id, repeated_word, ordinal)`; rules are tri-state maps (`absent/'suppress'/'surface'`), which is what makes per-occurrence **undo** of a global rule or machine verdict possible. The dot counts active findings only; ignored items are hidden by default and revealed dimmed (with "Default Ignore"/"Ignore Here"/"Ignore Everywhere" reason labels and "Undo Ignore") under a **"Show Ignored" toggle** (default off, not persisted), matching the revised #278.
 
 6. **Graceful degradation, either-PR-lands-first** (W8/W9): the UI feature-detects `GET /self/settings` (404 ⇒ "Ignore Everywhere" simply not rendered — capability hidden, never a dead control); check failures surface as one inline red line in the panel while the last successful findings stay rendered (TanStack default). No toasts/banners — none exist in this codebase. **"Ignore Everywhere" shows a confirm dialog** (per revised #278) while still being reversible via undo.
 
diff --git a/docs/proposals/repeated-word-check/highlight-in-verse-suggestion.md b/docs/proposals/repeated-word-check/highlight-in-verse-suggestion.md
new file mode 100644
index 00000000..560e4513
--- /dev/null
+++ b/docs/proposals/repeated-word-check/highlight-in-verse-suggestion.md
@@ -0,0 +1,304 @@
+# Highlight Repeated Words in Verse Text — Design Options & Recommendation
+
+**Status:** Proposal / decision-requested. Docs-only. No implementation yet.
+**Type:** Follow-on to the Repeated Word Check UI (cards
+[fluent-web#277](https://github.com/eten-tech-foundation/fluent-web/issues/277) /
+[fluent-web#278](https://github.com/eten-tech-foundation/fluent-web/issues/278)), which
+shipped the **Checks tab + panel**
+([PR #320](https://github.com/eten-tech-foundation/fluent-web/pull/320),
+[fluent-api #203](https://github.com/eten-tech-foundation/fluent-api/pull/203)).
+**Relates to #277, #278.** The tab/panel design this layers on is
+[`checks-ui-integration-suggestion.md`](checks-ui-integration-suggestion.md) (decisions
+**W1–W12**).
+
+> **Why this is a proposal PR and not just an implementation PR.** The highlight-in-verse work
+> was agreed to in the #305 review, and it _looked_ like a small presentational add-on. On
+> close inspection of the actual drafting editor it is **not** small: it forces a real decision
+> about how editable verse text is rendered. That decision is bigger than one feature and will
+> outlive it, so the team should weigh in **before** implementation rather than have an
+> architecture picked unilaterally on an experimental branch.
+
+---
+
+## 0. The original request (what Joel/Ulf asked for)
+
+During the Repeated Word Check proposal review (PR #305), **joelthe1 (Joel) and Ulf** asked
+that, in addition to _listing_ repeated-word findings in the Checks panel, the repeated words
+be **visually marked in the verse text itself** — an underline or color on the offending words
+where they appear, so the translator sees the problem in place, not only in a side list.
+
+It was agreed to, and **deliberately carved out as a separate follow-on PR** so the tab/panel
+(#277/#278) could land first without being blocked on verse-rendering changes. This document is
+that follow-on, brought forward for a design decision.
+
+The concrete visual target discussed on the product side of this thread: **the only visible
+change should be that the flagged (active) repeated words turn red** — no new chrome, no layout
+shift, the editing experience otherwise identical.
+
+---
+
+## 1. TL;DR / recommendation
+
+- Coloring words _inside the box the translator is typing into_ is the hard part. Today that
+  box is a **plain `<textarea>`**, and a `<textarea>` **physically cannot** color individual
+  words — its contents are one uniform color by definition (see §3).
+- Every way to get colored words into an editable field means **changing how the editable verse
+  is rendered** — from a trivial CSS overlay hack up to replacing the editor with a real
+  text-editing engine. The options differ enormously in risk (§5).
+- Fluent is **translation software for minority languages**, so unusual scripts, combining marks
+  / complex shaping, and eventually right-to-left (RTL) text must be assumed. That requirement
+  is what turns the cheap options from "clever hack" into "fragile in exactly the cases the
+  users live in" (§4).
+- **Recommendation:** treat this as an editor-foundation decision. The recommended path is
+  **Option D — adopt a real text-editor engine (CodeMirror 6 preferred, ProseMirror/TipTap
+  alternative), behind a feature flag** — because it is the only option that is _correct_ for
+  arbitrary scripts and RTL and provides a decoration layer reusable by future checks (spell
+  check, Wildebeest). Because that is a significant change, the cheaper options and the **"don't
+  color anything yet"** option (Option A) are documented fully, and the team is asked to choose
+  (§7).
+- **Nothing in this PR ships behavior.** It is a design record + option analysis only.
+
+---
+
+## 2. Background — what already exists (and works)
+
+The Repeated Word Check pipeline is already in place and is **not** what this proposal changes:
+
+- [`useRepeatedWordsCheck.ts`](../../../src/features/checks/hooks/useRepeatedWordsCheck.ts) —
+  fires the check on each auto-save, keyed on `(chapterAssignmentId, saveCounter)`.
+- [`useResolvedFindings.ts`](../../../src/features/checks/hooks/useResolvedFindings.ts) — the
+  pure three-layer suppression cascade that decides which findings are **active** vs.
+  **inactive** (ignored / "Default Ignore"). It also assigns each finding a stable **ordinal**
+  and an **occurrence key** `"{snt_id}|{repeated_word}|{ordinal}"`.
+- [`ChecksPanel.tsx`](../../../src/features/checks/components/ChecksPanel.tsx) — the side list.
+
+Each finding carries `snt_id` (verse), `repeated_word` (NFC + lowercased pair), `surf` (original
+surface text), `start_position` (character offset **as Greek Room counted it**), and
+`legitimate`. **The highlight feature is a pure consumer of the existing `resolved.active`
+list** — it adds a _rendering/decoration layer_, no new API, no new data.
+
+So the data problem is solved. The **rendering problem** is the entire subject of this doc.
+
+---
+
+## 3. The core constraint — words inside a `<textarea>` cannot be colored
+
+The drafting page renders the target (the text the translator is writing) as a native
+`<textarea>`
+([`DraftingPage.tsx` target column](../../../src/features/bible/components/DraftingPage.tsx)).
+A `<textarea>`:
+
+- renders its value as **one uniform run of text** — there is no way to make the third word red
+  and the rest black. HTML simply does not allow child markup inside a `<textarea>`.
+- is also doing a lot of quiet work that must not be lost: **native caret**, text selection,
+  **IME / dead-key composition** (essential for many target languages), spellcheck,
+  autocapitalize/autocorrect, auto-resize on input
+  ([`useDrafting.ts`](../../../src/features/bible/hooks/useDrafting.ts)), focus/caret restoration
+  when switching verses, and Enter-to-advance.
+
+Therefore **any** colored-word solution requires rendering the editable verse _differently_. The
+question is only **how far** to go, and each step up costs risk.
+
+> Note: the **source** column (the reference Bible) is already a styled `<p>`, so highlighting
+> read-only source text would be easy — but Greek Room checks the **target** (the translator's
+> own draft), so that's not where the findings live. The findings are in the editable box.
+
+---
+
+## 4. Why "translation software" makes this harder than a normal highlighter
+
+Most "highlight words in a textarea" tutorials quietly assume English: fixed-width-ish Latin
+text, one code unit per visible character, left-to-right. Fluent cannot assume any of that.
+
+1. **`start_position` is a character offset from Greek Room, not a DOM offset.** Coloring the
+   right glyphs requires mapping that offset onto the rendered text. If the app's idea of
+   "character N" differs from Greek Room's (JS strings count **UTF-16 code units**, so
+   emoji/rare CJK/some historic scripts are 2 units; combining accents and many Indic/complex
+   scripts render **one visual cluster from several code points**), the highlight lands on the
+   wrong glyphs. The cascade already NFC-normalizes, but position math is a separate hazard.
+2. **Combining marks & complex shaping.** Devanagari, Arabic, Khmer, etc. reshape glyphs in
+   context; a naive "wrap characters `start..end` in a span" can split a grapheme cluster and
+   visibly break the script. (Greek Room ships a Devanagari cost-rules file — these scripts are
+   real target languages here, not hypotheticals.)
+3. **RTL is coming.** The assumed product intent is to eventually support right-to-left
+   languages. Any overlay/mirror technique that hand-positions colored text has to get **bidi**
+   right (mixed LTR/RTL runs, the Unicode bidi algorithm). Hand-rolled positioning is where this
+   breaks first.
+4. **Variable fonts / line-wrapping.** An overlay must match the editor's font metrics, padding,
+   line-height, and wrapping **pixel-for-pixel**, per language, or the colors drift off the
+   glyphs. Minority-language fonts are exactly where metrics surprise you.
+
+**Conclusion:** the cheap techniques are cheap _because_ they assume a benign script. For this
+user base they are fragile in precisely the languages the product exists to serve. This is the
+crux of why the decision is being surfaced before building.
+
+---
+
+## 5. The options (with complexity and danger of each)
+
+Ordered from "do nothing" to "do it properly." Each lists what it is, the real cost, and the
+danger — stated honestly.
+
+### Option A — Do **not** color words yet (keep the panel-only experience)
+
+- **What:** ship nothing here. The Checks tab + panel + notification dot already tell the
+  translator which verses/words repeat. In-text coloring is formally recorded as deferred until
+  the editor foundation is decided.
+- **Complexity:** none.
+- **Danger:** none technically. The only cost is that Joel/Ulf's specific ask ("see it in the
+  text") stays unmet for now. **This is a legitimate choice**, not a cop-out: it avoids
+  committing to an editor architecture under time pressure, and the panel already delivers the
+  core check value.
+- **When this is right:** if the team is not ready to change the drafting editor and would
+  rather not carry a hack.
+
+### Option B — CSS overlay / "backdrop" (transparent `<textarea>` + mirrored colored div)
+
+- **What:** keep the real `<textarea>` for input but make its **text color transparent** (caret
+  still visible); behind it render a `<div>` containing the _same_ text with the active repeated
+  words wrapped in red `<span>`s. Both layers are driven by the **same React state in the same
+  render**, so there is _no_ temporal lag between them (addressing the "two sets of text out of
+  sync while typing" worry — they update in one commit).
+- **Complexity:** moderate. The hard part is not lag; it's **pixel-perfect alignment**: the
+  mirror `<div>` must replicate the textarea's font, size, padding, border, line-height,
+  letter-spacing, wrapping, and **auto-resize** behavior exactly, or the red drifts off the
+  words. Plus the offset→span mapping from §4.
+- **Danger (this is where "translation software" bites):**
+  - Alignment is brittle across **fonts/scripts** — the exact scenario (unusual scripts) where
+    correctness matters most is where mirrors most easily misalign.
+  - **RTL and bidi** overlays are notoriously hard to keep aligned.
+  - **Grapheme-cluster splitting** (§4.2) can visibly corrupt complex scripts even though the
+    underlying text is fine.
+  - Long-term maintenance tax: every editor style change must be mirrored in two places.
+- **Verdict:** cheapest way to get red words _today_, but it degrades in exactly the target
+  scripts. Acceptable only as a knowingly-temporary stopgap with a plan to replace it.
+
+### Option C — Raw `contenteditable` (one text layer, red spans on matches)
+
+- **What:** replace the `<textarea>` with a `contenteditable` element; render the text with red
+  spans directly (one layer, no mirror, no alignment math).
+- **Complexity:** high. `contenteditable` is famously painful: the DOM must be serialized back
+  to plain text on every edit, and re-rendering spans **mid-edit can move the caret** unless
+  selection is carefully saved/restored — which is the "messy while typing" failure mode in a
+  new disguise.
+- **Danger:** caret jumps; **IME/composition** breakage (dead keys, complex input) — a serious
+  regression for many target languages; inconsistent spellcheck; browser-specific quirks; paste
+  sanitization. This amounts to hand-building a text editor, badly.
+- **Verdict:** **not recommended.** More effort than Option B for _more_ risk. Listed for
+  completeness because it's the "obvious" idea that turns out worse than both neighbors.
+
+### Option D — Adopt a real text-editor engine, decorate the ranges (RECOMMENDED)
+
+- **What:** replace the target `<textarea>` with a purpose-built editor engine and apply the red
+  as **decorations** (presentational overlays the engine positions itself — they do **not**
+  mutate the document, so they can't corrupt the saved text). Candidates:
+  - **CodeMirror 6** _(preferred)_ — designed for exactly "editable text + decorations,"
+    excellent for large/plain text, first-class **RTL/bidi**, robust selection/IME handling,
+    tree-shakeable modular packages, a clean `Decoration.mark` API for coloring ranges. Lighter
+    and more line/character-oriented than a rich-document editor — a good fit since verses are
+    plain text, not rich documents.
+  - **ProseMirror / TipTap** — rich-document editor with a decorations API; heavier and
+    document-model-oriented (overkill for plain verse text, but viable). **Note:** the existing
+    `TipTapRenderer` in `features/resources` is a _hand-rolled JSON renderer_, **not** the real
+    TipTap library — adopting TipTap would still be a brand-new dependency.
+- **Complexity:** significant up front. The drafting input's behavior (auto-resize, focus/caret
+  restore across verses, Enter-to-advance, controlled value ↔ engine state, spellcheck) must be
+  ported onto the engine, a dependency added, and the whole drafting flow re-tested.
+- **Danger:** the risk is **scope/effort and a temporary editing-behavior regression during the
+  port**, not correctness of the coloring itself — a mature engine handles offsets, bidi, and
+  grapheme clusters far better than a hand-rolled solution. Mitigated by shipping **behind a
+  feature flag** (see §6) so the current `<textarea>` stays the default until the new editor is
+  proven.
+- **Verdict:** the **correct** long-term foundation. It's the only option that is right for
+  arbitrary scripts + RTL, and its decoration layer is **reusable** for every future check
+  (spell check, Wildebeest) — those will want in-text marks too. A full, correct solution is
+  likely required eventually regardless, so investing here avoids building Option B twice.
+
+### Option comparison
+
+| Option                  | Effort            | In-text red? | Correct for odd scripts / RTL      | Editing-behavior risk         | Reusable for future checks |
+| ----------------------- | ----------------- | ------------ | ---------------------------------- | ----------------------------- | -------------------------- |
+| A — do nothing          | none              | no           | n/a                                | none                          | n/a                        |
+| B — CSS overlay         | moderate          | yes          | **poor** (alignment/bidi/clusters) | low (native textarea kept)    | partly                     |
+| C — raw contenteditable | high              | yes          | poor–medium                        | **high** (caret/IME)          | partly                     |
+| D — real editor engine  | **high up front** | yes          | **good**                           | medium during port, low after | **yes**                    |
+
+---
+
+## 6. Cross-cutting concerns (apply to whichever option is chosen)
+
+- **HL1 — Only active findings are colored.** Reuse `resolved.active` from
+  [`useResolvedFindings`](../../../src/features/checks/hooks/useResolvedFindings.ts). Ignored /
+  "Ignore Everywhere" / "Default Ignore" (`legitimate`) words render **normal** — red means
+  "still flagged," mirroring the notification dot. This keeps the highlight and the panel in
+  lockstep by construction (single source of truth).
+- **HL2 — Refresh on the same trigger as the panel.** Decorations recompute when
+  `resolved.active` changes, which is already driven by `saveCounter` + the suppression cascade.
+  No new trigger.
+- **HL3 — Offset mapping is a shared hazard.** Whichever option, the mapping from Greek Room's
+  `start_position` (+ `repeated_word` length / `surf`) onto rendered ranges must be
+  grapheme-aware and NFC-consistent with the cascade (§4). Spec this explicitly during
+  implementation and unit-test it against combining-mark and surrogate-pair fixtures.
+- **HL4 — Ship behind a feature flag.** This is an editor-touching change; it should default
+  **off** until proven. There is an in-flight **feature-flags** proposal
+  ([`fluent-api/docs/proposals/feature-flags/`](../../../../fluent-api/docs/proposals/feature-flags/feature-flags-suggestion.md));
+  if that lands, use it. If not yet available, a local build-time/config flag is acceptable for
+  the experiment. Either way the current `<textarea>` stays the default path.
+- **HL5 — Read-only `/view` mode.** In read-only stages the verse is a `<p>`, not a textarea, so
+  `/view` highlighting is **simpler on the editing-behavior axis** (no caret / IME / auto-resize /
+  editor-engine concerns) and is **independent of the editable-field Option A–D decision**. It is
+  **not**, however, independent of the mapping work: it still relies on the **same
+  `start_position`→rendered-range mapping and grapheme/NFC handling described in HL3 and §4**, so
+  it can't be treated as a zero-cost shortcut past the hard part. Confirm whether product wants
+  highlighting in `/view` too.
+
+---
+
+## 7. Decision requested
+
+This is **not** a request to approve an implementation; it's a request for the team to pick the
+direction so the eventual implementation PR isn't a surprise.
+
+**Q1 (primary).** Which option should be pursued?
+
+- **A** — defer in-text coloring (panel only) for now.
+- **B** — CSS overlay stopgap, knowingly accepting the odd-script/RTL fragility.
+- **C** — raw contenteditable _(recommended against)_.
+- **D** — adopt a real editor engine (the recommendation), **CodeMirror 6** preferred.
+
+**Q2.** If **D**, is **CodeMirror 6** acceptable as the engine, or does anyone prefer
+**ProseMirror/TipTap**? (CM6 is favored here: verses are plain text, and CM6's bidi/decoration
+story is strong.)
+
+**Q3.** Feature-flag mechanism: gate behind the pending feature-flags work, or a temporary local
+flag until that lands? (HL4)
+
+**Q4.** Scope of coloring: active-only (HL1) confirmed? Any desire to also mark ignored words
+differently (dimmed)? Highlight in read-only `/view` too? (HL5)
+
+**Q5.** Sequencing/appetite: is this next now, or parked behind other priorities? (Option A is
+the honest "park it" answer if appetite is low.)
+
+---
+
+## 8. Decisions (to be filled in from review — this is the record)
+
+> Reviewer-confirmed decisions get an ID (**HV1…**) and a `(name, date, link)` note here, per
+> the team's docs convention, and are then referenced from code comments at the edit sites at
+> implementation time.
+
+- **HV1 — Chosen option:** _pending review._
+- **HV2 — Engine (if Option D):** _pending review._
+- **HV3 — Flag mechanism:** _pending review._
+- **HV4 — Coloring scope (active-only / ignored treatment / `/view`):** _pending review._
+
+---
+
+## 9. Explicitly out of scope
+
+- One-click "drop duplicate" quick-fix (already out of scope in the panel v1).
+- Feeding suppressions back to Greek Room.
+- Any change to fluent-ai or the proxy contract — the highlight is a pure client-side consumer
+  of findings already in hand.
+- Highlighting for _other_ checks (spell check, Wildebeest) — but Option D is favored partly
+  because its decoration layer would serve them later.
diff --git a/package.json b/package.json
index d9ca7632..75656486 100644
--- a/package.json
+++ b/package.json
@@ -38,6 +38,7 @@
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-separator": "^1.1.7",
     "@radix-ui/react-slot": "^1.2.2",
+    "@radix-ui/react-switch": "^1.3.1",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@radix-ui/react-visually-hidden": "^1.2.3",
     "@tanstack/react-query": "^5.84.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ddb97cd0..6139410d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -42,6 +42,9 @@ importers:
       '@radix-ui/react-slot':
         specifier: ^1.2.2
         version: 1.2.4(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-switch':
+        specifier: ^1.3.1
+        version: 1.3.1(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@radix-ui/react-tooltip':
         specifier: ^1.2.8
         version: 1.2.8(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -799,6 +802,9 @@ packages:
   '@radix-ui/primitive@1.1.3':
     resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
 
+  '@radix-ui/primitive@1.1.4':
+    resolution: {integrity: sha512-7AdCK9PQyiljKoBDbN8OuctCbd/esdwZPQ8RtOE3SsyQtUpiPb+ND75q0jEhC1m1ecBI0MFNeLJvwIh9iKHRcQ==}
+
   '@radix-ui/react-accordion@1.2.12':
     resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
     peerDependencies:
@@ -873,6 +879,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-compose-refs@1.1.3':
+    resolution: {integrity: sha512-rYOP8OMnuuPMQF1uhPVlGNcCDlkokKqGFE3JcxFViIkAXP7EvFWUliJAstrapypaBLJNHbZL6jGhbVDGTwmVhA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-context@1.1.2':
     resolution: {integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==}
     peerDependencies:
@@ -882,6 +897,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-context@1.1.4':
+    resolution: {integrity: sha512-QwH4PO5urrbO+FaGd5Aglg+YJgWTyyuZ3g/6mKvsqraLkglDdckw9JafgL5McL5VEJ6EPNduPaT3ZE9BttDAqg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-dialog@1.1.15':
     resolution: {integrity: sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==}
     peerDependencies:
@@ -1065,6 +1089,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-primitive@2.1.6':
+    resolution: {integrity: sha512-wetd0QI77DbvrPpTAvH1SqOxsYF2wZe5TNxqwOd5Ty4XDpV3dpV0s8K/1MGMJBeY5o7lg8ub5VIt1Ub+yVen6g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-roving-focus@1.1.11':
     resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
     peerDependencies:
@@ -1122,6 +1159,28 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-slot@1.3.0':
+    resolution: {integrity: sha512-MojKku4U/miO8Av4Dkb+ctMAQx7JmY96LmtDQlAarCRtd7rN52QCSzBF+XAvr5S6coSVj9HEPBgHAHKEJVk/WA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-switch@1.3.1':
+    resolution: {integrity: sha512-55bQtCnOB0BohomSHi6qvQXpJEEqUGDm6hRrM0Bph5OXwhSegqkd8IqgBAQkM1IlgUlWZIxpxRcpOEfRIgimyw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-tooltip@1.2.8':
     resolution: {integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==}
     peerDependencies:
@@ -1153,6 +1212,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-controllable-state@1.2.3':
+    resolution: {integrity: sha512-PLzC90MS+ReootmjC597dvopoelpZ8Q61HJkDXZSExitIq7PL55vHNnesAHwguHK0aPfBnpdNzQtv1uliaqQrA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-use-effect-event@0.0.2':
     resolution: {integrity: sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==}
     peerDependencies:
@@ -1162,6 +1230,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-effect-event@0.0.3':
+    resolution: {integrity: sha512-6c8ZqvPTWILEKnyVkP53EGRCcpnJiKTC21sS/6R1GF5xKyHJJWQEPfkqlcgUkdRQivd6tb23abUwe4ngWmY0JA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-use-escape-keydown@1.1.1':
     resolution: {integrity: sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==}
     peerDependencies:
@@ -1180,6 +1257,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-layout-effect@1.1.2':
+    resolution: {integrity: sha512-jrBWOxZITuGcnjRCM2t2U5ZPkCLxD+Ym6DjfssS5haTj2iiak/DOb64JeN6OdLfLgptb6/e2kKR+ZuTrGoZTPA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-use-previous@1.1.1':
     resolution: {integrity: sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==}
     peerDependencies:
@@ -1189,6 +1275,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-previous@1.1.2':
+    resolution: {integrity: sha512-IGBQPtRFdhN6MQ8dbegVmBq1LVZluya3F1jWY+puIcQC3MHctRwTDSBWCkL/3ZcnMJLTMJ++Z+ktmvg0F89iCw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-use-rect@1.1.1':
     resolution: {integrity: sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==}
     peerDependencies:
@@ -1207,6 +1302,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-size@1.1.2':
+    resolution: {integrity: sha512-giWQp+4mxjBPt4KZ0MmyuykFNWfbDxKt4x+fPkRYmgRFJSbCZFzUglvMb/Kjn38tm10YP4ufiQZDx3zna4LU6w==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-visually-hidden@1.2.3':
     resolution: {integrity: sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==}
     peerDependencies:
@@ -4571,6 +4675,8 @@ snapshots:
 
   '@radix-ui/primitive@1.1.3': {}
 
+  '@radix-ui/primitive@1.1.4': {}
+
   '@radix-ui/react-accordion@1.2.12(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -4647,12 +4753,24 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-compose-refs@1.1.3(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-context@1.1.2(@types/react@18.3.28)(react@18.3.1)':
     dependencies:
       react: 18.3.1
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-context@1.1.4(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-dialog@1.1.15(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -4847,6 +4965,15 @@ snapshots:
       '@types/react': 18.3.28
       '@types/react-dom': 18.3.7(@types/react@18.3.28)
 
+  '@radix-ui/react-primitive@2.1.6(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@radix-ui/react-slot': 1.3.0(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.3.28
+      '@types/react-dom': 18.3.7(@types/react@18.3.28)
+
   '@radix-ui/react-roving-focus@1.1.11(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -4916,6 +5043,28 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-slot@1.3.0(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
+  '@radix-ui/react-switch@1.3.1(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.4
+      '@radix-ui/react-compose-refs': 1.1.3(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-context': 1.1.4(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-primitive': 2.1.6(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.2.3(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-use-previous': 1.1.2(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-use-size': 1.1.2(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.3.28
+      '@types/react-dom': 18.3.7(@types/react@18.3.28)
+
   '@radix-ui/react-tooltip@1.2.8(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -4950,6 +5099,14 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-use-controllable-state@1.2.3(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      '@radix-ui/react-use-effect-event': 0.0.3(@types/react@18.3.28)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-use-effect-event@0.0.2(@types/react@18.3.28)(react@18.3.1)':
     dependencies:
       '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@18.3.28)(react@18.3.1)
@@ -4957,6 +5114,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-use-effect-event@0.0.3(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-use-escape-keydown@1.1.1(@types/react@18.3.28)(react@18.3.1)':
     dependencies:
       '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@18.3.28)(react@18.3.1)
@@ -4970,12 +5134,24 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-use-layout-effect@1.1.2(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-use-previous@1.1.1(@types/react@18.3.28)(react@18.3.1)':
     dependencies:
       react: 18.3.1
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-use-previous@1.1.2(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-use-rect@1.1.1(@types/react@18.3.28)(react@18.3.1)':
     dependencies:
       '@radix-ui/rect': 1.1.1
@@ -4990,6 +5166,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 18.3.28
 
+  '@radix-ui/react-use-size@1.1.2(@types/react@18.3.28)(react@18.3.1)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.2(@types/react@18.3.28)(react@18.3.1)
+      react: 18.3.1
+    optionalDependencies:
+      '@types/react': 18.3.28
+
   '@radix-ui/react-visually-hidden@1.2.3(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
       '@radix-ui/react-primitive': 2.1.3(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
diff --git a/src/components/ui/switch.test.tsx b/src/components/ui/switch.test.tsx
new file mode 100644
index 00000000..a7433124
--- /dev/null
+++ b/src/components/ui/switch.test.tsx
@@ -0,0 +1,86 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { Switch } from './switch';
+
+describe('Switch', () => {
+  it('renders without crashing', () => {
+    render(<Switch />);
+    expect(document.querySelector('[data-slot="switch"]')).toBeInTheDocument();
+  });
+
+  it('renders the thumb element', () => {
+    render(<Switch />);
+    expect(document.querySelector('[data-slot="switch-thumb"]')).toBeInTheDocument();
+  });
+
+  it('is unchecked by default', () => {
+    render(<Switch />);
+    const switchEl = document.querySelector('[data-slot="switch"]');
+    expect(switchEl).toHaveAttribute('data-state', 'unchecked');
+  });
+
+  it('renders checked when the checked prop is true', () => {
+    render(<Switch checked onCheckedChange={() => {}} />);
+    const switchEl = document.querySelector('[data-slot="switch"]');
+    expect(switchEl).toHaveAttribute('data-state', 'checked');
+  });
+
+  it('renders unchecked when the checked prop is false', () => {
+    render(<Switch checked={false} onCheckedChange={() => {}} />);
+    const switchEl = document.querySelector('[data-slot="switch"]');
+    expect(switchEl).toHaveAttribute('data-state', 'unchecked');
+  });
+
+  it('calls onCheckedChange when clicked', async () => {
+    const onCheckedChange = vi.fn();
+    render(<Switch checked={false} onCheckedChange={onCheckedChange} />);
+    const switchEl = document.querySelector('[data-slot="switch"]') as HTMLElement;
+    fireEvent.click(switchEl);
+    expect(onCheckedChange).toHaveBeenCalledTimes(1);
+    expect(onCheckedChange).toHaveBeenCalledWith(true);
+  });
+
+  it('calls onCheckedChange with false when toggled off', () => {
+    const onCheckedChange = vi.fn();
+    render(<Switch checked onCheckedChange={onCheckedChange} />);
+    const switchEl = document.querySelector('[data-slot="switch"]') as HTMLElement;
+    fireEvent.click(switchEl);
+    expect(onCheckedChange).toHaveBeenCalledWith(false);
+  });
+
+  it('is accessible as a switch role', () => {
+    render(<Switch aria-label='Toggle feature' />);
+    expect(screen.getByRole('switch', { name: 'Toggle feature' })).toBeInTheDocument();
+  });
+
+  it('merges extra className into the root element', () => {
+    render(<Switch className='custom-class' />);
+    const switchEl = document.querySelector('[data-slot="switch"]');
+    expect(switchEl).toHaveClass('custom-class');
+  });
+
+  it('is disabled when the disabled prop is set', () => {
+    render(<Switch disabled />);
+    const switchEl = document.querySelector('[data-slot="switch"]') as HTMLButtonElement;
+    expect(switchEl).toBeDisabled();
+  });
+
+  it('does not call onCheckedChange when disabled', () => {
+    const onCheckedChange = vi.fn();
+    render(<Switch disabled checked={false} onCheckedChange={onCheckedChange} />);
+    const switchEl = document.querySelector('[data-slot="switch"]') as HTMLElement;
+    fireEvent.click(switchEl);
+    expect(onCheckedChange).not.toHaveBeenCalled();
+  });
+
+  it('can be identified by an id linked from a label', () => {
+    render(
+      <>
+        <label htmlFor='my-switch'>My Switch</label>
+        <Switch id='my-switch' />
+      </>
+    );
+    expect(screen.getByRole('switch', { name: 'My Switch' })).toBeInTheDocument();
+  });
+});
diff --git a/src/components/ui/switch.tsx b/src/components/ui/switch.tsx
new file mode 100644
index 00000000..86da2355
--- /dev/null
+++ b/src/components/ui/switch.tsx
@@ -0,0 +1,27 @@
+import * as React from 'react';
+
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+
+import { cn } from '@/lib/ui/utils';
+
+function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>) {
+  return (
+    <SwitchPrimitive.Root
+      className={cn(
+        'peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50',
+        className
+      )}
+      data-slot='switch'
+      {...props}
+    >
+      <SwitchPrimitive.Thumb
+        className={cn(
+          'bg-background dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block size-4 rounded-full ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0'
+        )}
+        data-slot='switch-thumb'
+      />
+    </SwitchPrimitive.Root>
+  );
+}
+
+export { Switch };
diff --git a/src/features/bible/components/DraftingHeader.tsx b/src/features/bible/components/DraftingHeader.tsx
index 48eb6454..15c3d613 100644
--- a/src/features/bible/components/DraftingHeader.tsx
+++ b/src/features/bible/components/DraftingHeader.tsx
@@ -23,6 +23,10 @@ interface DraftingHeaderProps {
   isComplete: boolean;
   isDraft: boolean;
   buttonText: string | undefined;
+  /** Cascade-resolved active-finding count (Repeated Word Check, §6.4). Drives
+   *  the S5 mirror notification dot on the resource-toggle button while the
+   *  left panel is closed (#277). */
+  activeFindingsCount: number;
   onBack: () => void;
   onToggleResources: () => void;
   onSubmit: () => Promise<void>;
@@ -39,6 +43,7 @@ export const DraftingHeader: React.FC<DraftingHeaderProps> = ({
   isComplete,
   isDraft,
   buttonText,
+  activeFindingsCount,
   onBack,
   onToggleResources,
   onSubmit,
@@ -99,12 +104,29 @@ export const DraftingHeader: React.FC<DraftingHeaderProps> = ({
               <Tooltip>
                 <TooltipTrigger asChild>
                   <Button
+                    aria-label={
+                      showResources
+                        ? t('hideResources', 'Hide Resources')
+                        : t('showResources', 'Show Resources')
+                    }
                     aria-pressed={showResources}
-                    className='bg-primary flex cursor-pointer items-center gap-2'
+                    className='bg-primary relative flex cursor-pointer items-center gap-2'
                     type='button'
                     onClick={onToggleResources}
                   >
                     <BookText color='#ffffff' />
+                    {/* S5: mirror the active-checks notification dot on the
+                        panel-toggle button while the panel is closed, so the
+                        translator is still notified (#277). The dot is
+                        decorative (aria-hidden) so a screen reader announces the
+                        button action, not the dot (CR-10). */}
+                    {!showResources && activeFindingsCount > 0 && (
+                      <span
+                        aria-hidden='true'
+                        className='absolute -top-1 -right-1 inline-block h-2.5 w-2.5 rounded-full bg-blue-600 ring-2 ring-white'
+                        data-testid='checks-toggle-notification-dot'
+                      />
+                    )}
                   </Button>
                 </TooltipTrigger>
                 <TooltipContent
diff --git a/src/features/bible/components/DraftingResourceSidebar.tsx b/src/features/bible/components/DraftingResourceSidebar.tsx
index b76bceec..12c5510f 100644
--- a/src/features/bible/components/DraftingResourceSidebar.tsx
+++ b/src/features/bible/components/DraftingResourceSidebar.tsx
@@ -1,7 +1,9 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
+import React, { type ReactNode, useCallback, useEffect, useRef, useState } from 'react';
 
 import { GripVertical } from 'lucide-react';
 
+import { type LeftTab } from '@/features/bible/hooks/useResourceStatePersistence';
+import { LeftPanel } from '@/features/checks/components/LeftPanel';
 import { ResourcePanel } from '@/features/resources/components/ResourcePanel';
 import { type BibleVerse } from '@/features/resources/hooks/hooks';
 import { type ProjectItem, type ResourceName } from '@/lib/types';
@@ -21,6 +23,19 @@ interface DraftingResourceSidebarProps {
   setBibleVerses: (verses: BibleVerse[]) => void;
   setCurrentLanguage: (lang: string) => void;
   setCurrentResource: (res: ResourceName) => void;
+  /** Controlled active left-panel tab (Resources | Checks), persisted by the
+   *  parent in the editor-state blob (Repeated Word Check, W11/§6.6). */
+  activeLeftTab: LeftTab;
+  /** Called when the translator switches tabs; the parent persists it. */
+  onTabChange: (tab: LeftTab) => void;
+  /** Cascade-resolved active-finding count; drives the tab notification dot. */
+  activeFindingsCount: number;
+  /** Body for the Checks tab (the `ChecksPanel`, composed by the parent). */
+  checksContent: ReactNode;
+  /** Whether the Checks tab is shown at all. When the Repeated Word Check
+   *  feature is disabled (feature-flags proposal D6/D7) the tab is hidden so it
+   *  looks unimplemented; forwarded straight to `LeftPanel`. Defaults to true. */
+  showChecksTab?: boolean;
 }
 
 export const DraftingResourceSidebar: React.FC<DraftingResourceSidebarProps> = ({
@@ -38,6 +53,11 @@ export const DraftingResourceSidebar: React.FC<DraftingResourceSidebarProps> = (
   setBibleVerses,
   setCurrentLanguage,
   setCurrentResource,
+  activeLeftTab,
+  onTabChange,
+  activeFindingsCount,
+  checksContent,
+  showChecksTab = true,
 }) => {
   const [resourcePanelWidth, setResourcePanelWidth] = useState(25); // percentage
   const isDraggingRef = useRef(false);
@@ -101,22 +121,31 @@ export const DraftingResourceSidebar: React.FC<DraftingResourceSidebarProps> = (
   return (
     <>
       <div className='min-w-0 shrink-0 overflow-hidden' style={{ width: `${resourcePanelWidth}%` }}>
-        <ResourcePanel
-          activeVerseId={resourceVerseId}
-          bibleResourceName={setBibleTabLabel}
-          initialLanguage={currentLanguage}
-          initialResource={currentResource}
-          openResourceBiblePanel={setOpenResourcePanel}
-          registerClearBible={fn => {
-            clearBibleRef.current = fn;
-          }}
-          resourceNames={resourceNames}
-          selectPanel={panel => setSelectedPanel(panel as 1 | 2)}
-          sourceData={projectItem}
-          onBibleLoadingChange={setBibleContentLoading}
-          onBibleVersesChange={setBibleVerses}
-          onLanguageChange={setCurrentLanguage}
-          onResourceChange={setCurrentResource}
+        <LeftPanel
+          activeFindingsCount={activeFindingsCount}
+          activeTab={activeLeftTab}
+          checksContent={checksContent}
+          resourcesContent={
+            <ResourcePanel
+              activeVerseId={resourceVerseId}
+              bibleResourceName={setBibleTabLabel}
+              initialLanguage={currentLanguage}
+              initialResource={currentResource}
+              openResourceBiblePanel={setOpenResourcePanel}
+              registerClearBible={fn => {
+                clearBibleRef.current = fn;
+              }}
+              resourceNames={resourceNames}
+              selectPanel={panel => setSelectedPanel(panel as 1 | 2)}
+              sourceData={projectItem}
+              onBibleLoadingChange={setBibleContentLoading}
+              onBibleVersesChange={setBibleVerses}
+              onLanguageChange={setCurrentLanguage}
+              onResourceChange={setCurrentResource}
+            />
+          }
+          showChecksTab={showChecksTab}
+          onTabChange={onTabChange}
         />
       </div>
       {/* Drag handle */}
diff --git a/src/features/bible/components/DraftingUI.test.tsx b/src/features/bible/components/DraftingUI.test.tsx
index 37a70ee5..faf16435 100644
--- a/src/features/bible/components/DraftingUI.test.tsx
+++ b/src/features/bible/components/DraftingUI.test.tsx
@@ -64,6 +64,44 @@ vi.mock('@/features/bible/hooks/usePericope', () => ({
   usePericope: (props: unknown) => mockUsePericope(props) as unknown,
 }));
 
+// Mock the Repeated Word Check hooks (Phase 4). These wrap TanStack Query /
+// fetch; this suite exercises drafting/pericope/resource behavior, not the
+// check itself (which is unit-tested in `useRepeatedWordsCheck.test.ts` and the
+// checks-feature component tests). Mocking them keeps DraftingUI renderable
+// without a QueryClientProvider and with no network I/O.
+vi.mock('@/features/checks/hooks/useSuppressions', () => ({
+  useSuppressions: () => ({
+    occurrenceRules: {},
+    globalRules: {},
+    globalIgnoresAvailable: false,
+    settingsProbeResolved: true,
+    ignoreHere: vi.fn(),
+    ignoreEverywhere: vi.fn(),
+    undoOccurrence: vi.fn(),
+    stopIgnoringEverywhere: vi.fn(),
+  }),
+}));
+
+vi.mock('@/features/checks/hooks/useRepeatedWordsCheck', () => ({
+  useRepeatedWordsCheck: () => ({ data: undefined, isError: false }),
+}));
+
+vi.mock('@/features/checks/hooks/useResolvedFindings', () => ({
+  useResolvedFindings: () => ({ active: [], inactive: [] }),
+}));
+
+// Mock the feature-flags selector. The Repeated Word Check tab/query are gated
+// on `useFeatureFlag('repeatedWordCheck')` (feature-flags proposal D5–D7); this
+// hook wraps TanStack Query / fetch, so mocking it keeps DraftingUI renderable
+// with no network I/O. Default: feature ON, so the existing tests exercise the
+// full Checks surface; individual tests flip `mockFeatureFlag` to false to
+// assert the hidden state.
+const mockFeatureFlag = vi.fn<(name: string) => boolean>(() => true);
+
+vi.mock('@/features/flags', () => ({
+  useFeatureFlag: (name: string) => mockFeatureFlag(name) as unknown,
+}));
+
 // Mock ResourcePanel
 vi.mock('@/features/resources/components/ResourcePanel', () => ({
   ResourcePanel: ({
@@ -105,6 +143,7 @@ const mockProjectItem: ProjectItem = {
   bibleId: 1,
   bibleName: 'WEB',
   targetLanguage: 'Spanish',
+  targetLangCode: 'spa',
   bookId: 1,
   book: 'Genesis',
   chapterStatus: ChapterAssignmentStatus.DRAFT,
@@ -176,6 +215,9 @@ describe('DraftingUI', () => {
   beforeEach(() => {
     vi.clearAllMocks();
 
+    // Default: Repeated Word Check feature ON (see mock definition above).
+    mockFeatureFlag.mockReturnValue(true);
+
     mockUseAddTranslatedVerse.mockReturnValue({
       mutateAsync: vi.fn(),
       isPending: false,
@@ -392,4 +434,64 @@ describe('DraftingUI', () => {
 
     expect(handleNextClickMock).toHaveBeenCalled();
   });
+
+  // --- Repeated Word Check feature flag (feature-flags proposal D5–D7) -------
+  describe('Repeated Word Check feature flag', () => {
+    const openResourcePanel = async (user: ReturnType<typeof userEvent.setup>) => {
+      const toggleButton = screen.getByRole('button', { pressed: false });
+      await user.click(toggleButton);
+    };
+
+    it('shows the Checks tab when the feature is enabled', async () => {
+      const user = userEvent.setup();
+      mockFeatureFlag.mockReturnValue(true);
+
+      render(
+        <DraftingUI
+          projectItem={mockProjectItem}
+          sourceVerses={mockSourceVerses}
+          targetVerses={mockTargetVerses}
+          userdetail={{ id: 1 } as unknown as User}
+        />
+      );
+
+      await openResourcePanel(user);
+
+      expect(screen.getByRole('tab', { name: 'Resources' })).toBeInTheDocument();
+      expect(screen.getByRole('tab', { name: 'Checks' })).toBeInTheDocument();
+    });
+
+    it('hides the Checks tab (feature looks unimplemented) when the feature is disabled', async () => {
+      const user = userEvent.setup();
+      mockFeatureFlag.mockReturnValue(false);
+
+      render(
+        <DraftingUI
+          projectItem={mockProjectItem}
+          sourceVerses={mockSourceVerses}
+          targetVerses={mockTargetVerses}
+          userdetail={{ id: 1 } as unknown as User}
+        />
+      );
+
+      await openResourcePanel(user);
+
+      // Resources tab remains; the Checks tab is gone entirely.
+      expect(screen.getByRole('tab', { name: 'Resources' })).toBeInTheDocument();
+      expect(screen.queryByRole('tab', { name: 'Checks' })).not.toBeInTheDocument();
+    });
+
+    it('only queries the flag for the repeatedWordCheck feature', () => {
+      render(
+        <DraftingUI
+          projectItem={mockProjectItem}
+          sourceVerses={mockSourceVerses}
+          targetVerses={mockTargetVerses}
+          userdetail={{ id: 1 } as unknown as User}
+        />
+      );
+
+      expect(mockFeatureFlag).toHaveBeenCalledWith('repeatedWordCheck');
+    });
+  });
 });
diff --git a/src/features/bible/components/DraftingUI.tsx b/src/features/bible/components/DraftingUI.tsx
index f973ea30..97e45325 100644
--- a/src/features/bible/components/DraftingUI.tsx
+++ b/src/features/bible/components/DraftingUI.tsx
@@ -11,9 +11,16 @@ import { useChapterPresence } from '@/features/bible/hooks/useChapterPresence';
 import { useDrafting } from '@/features/bible/hooks/useDrafting';
 import { usePericope } from '@/features/bible/hooks/usePericope';
 import {
+  type LeftTab,
   useResourceState,
   useSaveResourceState,
 } from '@/features/bible/hooks/useResourceStatePersistence';
+import { type OccurrenceRules } from '@/features/checks/checks.types';
+import { ChecksPanel } from '@/features/checks/components/ChecksPanel';
+import { useRepeatedWordsCheck } from '@/features/checks/hooks/useRepeatedWordsCheck';
+import { useResolvedFindings } from '@/features/checks/hooks/useResolvedFindings';
+import { useSuppressions } from '@/features/checks/hooks/useSuppressions';
+import { useFeatureFlag } from '@/features/flags';
 import { type BibleVerse } from '@/features/resources/hooks/hooks';
 import { Logger } from '@/lib/services/logger';
 import {
@@ -64,6 +71,17 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
   const [bibleVerses, setBibleVerses] = useState<BibleVerse[]>([]);
   const [bibleContentLoading, setBibleContentLoading] = useState(false);
 
+  // Which left-panel tab is showing (Resources | Checks). Persisted in the
+  // editor-state blob as `activeLeftTab` (W11, §6.6).
+  const [activeLeftTab, setActiveLeftTab] = useState<LeftTab>('resources');
+  // Occurrence-level suppression rules for the Repeated Word Check (cascade
+  // layer 2). Held here so they ride the existing debounced editor-state save
+  // — the single writer for the blob (§7.1).
+  const [occurrenceRules, setOccurrenceRules] = useState<OccurrenceRules>({});
+  // Increments on every successful verse auto-save; part of the check query key
+  // so the check re-fires exactly on the auto-save event (W3, card #172).
+  const [saveCounter, setSaveCounter] = useState(0);
+
   const containerRef = useRef<HTMLDivElement>(null);
   const clearBibleRef = useRef<(() => void) | null>(null);
 
@@ -78,6 +96,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
     activeResource: string;
     languageCode: string;
     tabStatus: boolean;
+    activeLeftTab: LeftTab;
+    checkOccurrenceRules: OccurrenceRules;
   } | null>(null);
   const saveTimeoutRef = useRef<NodeJS.Timeout | null>(null);
 
@@ -119,6 +139,11 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
           assignedUserId: userdetail.id,
         },
       });
+
+      // Bump on the successful auto-save event so the Repeated Word Check
+      // re-fires (W3, card #172). `useAddTranslatedVerse` doesn't forward
+      // mutate-time `onSuccess`, so we bump after the awaited resolve.
+      setSaveCounter(c => c + 1);
     },
     [addVerseMutation, projectItem.projectUnitId, sourceVerses, userdetail]
   );
@@ -170,6 +195,80 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
     revealNextVerse,
   });
 
+  // --- Repeated Word Check wiring (Phase 4, §6.2/§6.6, W3/W10/W11) ----------
+
+  // Feature flag: is the Repeated Word Check enabled in this environment? The
+  // whole Checks feature depends on fluent-ai, which isn't hosted everywhere,
+  // so the flag lets this code ship hidden until AI is wired (feature-flags
+  // proposal D6/D7). Fail-closed: `useFeatureFlag` returns false while loading
+  // or on endpoint error, so the tab and the AI query stay off by default. This
+  // is the single consumption point — the flag is threaded down as booleans so
+  // the leaf components stay flag-agnostic.
+  const checksEnabled = useFeatureFlag('repeatedWordCheck');
+
+  // The single writer for the occurrence-rule map: `useSuppressions` does the
+  // read-modify-write and hands the next full map back here; updating state
+  // makes it ride the existing debounced editor-state save (one writer, §7.1).
+  const saveOccurrenceRules = useCallback((next: OccurrenceRules) => {
+    setOccurrenceRules(next);
+  }, []);
+
+  const {
+    occurrenceRules: liveOccurrenceRules,
+    globalRules,
+    globalIgnoresAvailable,
+    settingsProbeResolved,
+    ignoreHere,
+    ignoreEverywhere,
+    undoOccurrence,
+    stopIgnoringEverywhere,
+    // Gate the once-per-session `GET /self/settings` probe on the same feature
+    // flag as the check query: when the Repeated Word Check is off (or still
+    // loading / errored — fail-closed) the Checks UI is hidden, so there is no
+    // reason to fetch user settings for it (W2, feature-flags proposal D5/D7).
+  } = useSuppressions({ occurrenceRules, saveOccurrenceRules, enabled: checksEnabled });
+
+  // What the translator currently sees is what gets checked (§6.2) — feed the
+  // live drafting verses, not a refetch.
+  const checkVerses = verses.map(v => ({ verseNumber: v.verseNumber, content: v.content }));
+  const hasContent = checkVerses.some(v => v.content.trim() !== '');
+
+  const checkQuery = useRepeatedWordsCheck({
+    projectItem,
+    verses: checkVerses,
+    saveCounter,
+    // Wait for the settings probe so the first render is cascade-correct, and
+    // never run in read-only `/view` or when the chapter is empty (W10/§9.1).
+    // Also gate on the feature flag: when the Repeated Word Check is off (or
+    // still loading / errored — fail-closed) we suppress the query entirely so
+    // no known-failing POST to /ai/tools/... fires in environments where
+    // fluent-ai isn't wired (feature-flags proposal D5/D7).
+    enabled: checksEnabled && !readOnly && hasContent && settingsProbeResolved,
+  });
+
+  const resolved = useResolvedFindings({
+    findings: checkQuery.data?.result?.findings ?? [],
+    occurrenceRules: liveOccurrenceRules,
+    globalRules,
+  });
+
+  // Active-finding count drives both notification dots; computed once here and
+  // threaded to the tab and the closed-panel toggle button (S5, §6.4). When the
+  // Checks feature is disabled it is forced to 0 so neither dot can flash while
+  // the flag is resolving (the query is already suppressed above; this guards
+  // the count explicitly).
+  const activeFindingsCount = checksEnabled ? resolved.active.length : 0;
+
+  // When the Checks tab is hidden (feature off), a persisted `activeLeftTab ===
+  // 'checks'` must not strand the panel on an empty/absent tab — fall back to
+  // Resources for rendering. The persisted value itself is left untouched, so
+  // if the feature is later enabled the translator's last tab is restored.
+  const effectiveActiveLeftTab: LeftTab = checksEnabled ? activeLeftTab : 'resources';
+
+  const handleTabChange = useCallback((tab: LeftTab) => {
+    setActiveLeftTab(tab);
+  }, []);
+
   const handleBack = useCallback(() => {
     clearCurrentProjectItem();
 
@@ -186,12 +285,19 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
     if (!isFetched || isInitializedRef.current) return;
 
     if (savedResourceState) {
-      const { languageCode, tabStatus } = savedResourceState;
+      const { languageCode, tabStatus, activeLeftTab: savedTab } = savedResourceState;
+      const savedOccurrenceRules = savedResourceState.checkOccurrenceRules ?? {};
 
       if (typeof tabStatus === 'boolean') {
         setShowResources(tabStatus);
       }
 
+      if (savedTab === 'resources' || savedTab === 'checks') {
+        setActiveLeftTab(savedTab);
+      }
+
+      setOccurrenceRules(savedOccurrenceRules);
+
       setCurrentLanguage(languageCode || projectItem.sourceLangCode);
 
       lastSavedStateRef.current = {
@@ -201,6 +307,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
         activeResource: RESOURCE_NAMES[0].id,
         languageCode: languageCode || projectItem.sourceLangCode,
         tabStatus: typeof tabStatus === 'boolean' ? tabStatus : false,
+        activeLeftTab: savedTab === 'checks' ? 'checks' : 'resources',
+        checkOccurrenceRules: savedOccurrenceRules,
       };
     } else {
       setCurrentLanguage(projectItem.sourceLangCode);
@@ -212,6 +320,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
         activeResource: RESOURCE_NAMES[0].id,
         languageCode: projectItem.sourceLangCode,
         tabStatus: false,
+        activeLeftTab: 'resources',
+        checkOccurrenceRules: {},
       };
     }
 
@@ -236,6 +346,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
       activeResource: currentResource.id,
       languageCode: currentLanguage || projectItem.sourceLangCode,
       tabStatus: showResources,
+      activeLeftTab,
+      checkOccurrenceRules: occurrenceRules,
     };
 
     if (lastSavedStateRef.current) {
@@ -245,7 +357,11 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
         lastSavedStateRef.current.verseNumber !== currentState.verseNumber ||
         lastSavedStateRef.current.activeResource !== currentState.activeResource ||
         lastSavedStateRef.current.languageCode !== currentState.languageCode ||
-        lastSavedStateRef.current.tabStatus !== currentState.tabStatus;
+        lastSavedStateRef.current.tabStatus !== currentState.tabStatus ||
+        lastSavedStateRef.current.activeLeftTab !== currentState.activeLeftTab ||
+        // Occurrence rules are replaced by-reference on every write (the hook
+        // returns a fresh map), so an identity check is sufficient and cheap.
+        lastSavedStateRef.current.checkOccurrenceRules !== currentState.checkOccurrenceRules;
 
       if (!hasChanged) return;
     }
@@ -271,6 +387,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
     currentResource.id,
     currentLanguage,
     showResources,
+    activeLeftTab,
+    occurrenceRules,
     activeVerseId,
     projectItem.chapterAssignmentId,
     projectItem.book,
@@ -406,6 +524,7 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
   return (
     <div className='flex h-full flex-col overflow-hidden'>
       <DraftingHeader
+        activeFindingsCount={activeFindingsCount}
         buttonText={buttonText}
         hasAnyError={hasAnyError}
         isAnythingSaving={isAnythingSaving}
@@ -424,6 +543,19 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
       <div ref={containerRef} className='flex h-full overflow-hidden'>
         {showResources && isInitializedRef.current && (
           <DraftingResourceSidebar
+            activeFindingsCount={activeFindingsCount}
+            activeLeftTab={effectiveActiveLeftTab}
+            checksContent={
+              <ChecksPanel
+                globalIgnoresAvailable={globalIgnoresAvailable}
+                isError={checkQuery.isError}
+                resolved={resolved}
+                onIgnoreEverywhere={ignoreEverywhere}
+                onIgnoreHere={ignoreHere}
+                onStopIgnoringEverywhere={stopIgnoringEverywhere}
+                onUndo={undoOccurrence}
+              />
+            }
             clearBibleRef={clearBibleRef}
             containerRef={containerRef}
             currentLanguage={currentLanguage}
@@ -438,6 +570,8 @@ export const DraftingUI: React.FC<DraftingUIProps> = ({
             setCurrentResource={setCurrentResource}
             setOpenResourcePanel={setOpenResourcePanel}
             setSelectedPanel={setSelectedPanel}
+            showChecksTab={checksEnabled}
+            onTabChange={handleTabChange}
           />
         )}
 
diff --git a/src/features/bible/hooks/useResourceStatePersistence.test.ts b/src/features/bible/hooks/useResourceStatePersistence.test.ts
new file mode 100644
index 00000000..5619c84b
--- /dev/null
+++ b/src/features/bible/hooks/useResourceStatePersistence.test.ts
@@ -0,0 +1,385 @@
+import { createElement, type ReactNode } from 'react';
+
+import { QueryClientProvider } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { describe, expect, it, vi } from 'vitest';
+
+import { config } from '@/lib/config';
+import { server } from '@/test/msw/server';
+import { act, createTestQueryClient, renderHook, waitFor } from '@/test/render';
+
+import {
+  type FetchResourceState,
+  useResourceState,
+  useSaveResourceState,
+} from './useResourceStatePersistence';
+
+const API_BASE = config.api.url;
+const editorStateUrl = (id: number) => `${API_BASE}/chapter-assignments/${id}/editor-state`;
+
+const makeWrapper = () => {
+  const queryClient = createTestQueryClient();
+  return ({ children }: { children: ReactNode }) =>
+    createElement(QueryClientProvider, { client: queryClient }, children);
+};
+
+// ---------------------------------------------------------------------------
+// Test data factories
+// ---------------------------------------------------------------------------
+
+/** A minimal valid FetchResourceState (all required fields plus defaults for new optional ones). */
+const makeState = (over: Partial<FetchResourceState> = {}): FetchResourceState => ({
+  activeResource: 'ult',
+  languageCode: 'eng',
+  tabStatus: false,
+  ...over,
+});
+
+// ---------------------------------------------------------------------------
+// useResourceState — fetching the new optional fields
+// ---------------------------------------------------------------------------
+
+describe('useResourceState — new field: activeLeftTab', () => {
+  it('returns activeLeftTab "checks" when the server includes it', async () => {
+    const state = makeState({ activeLeftTab: 'checks' });
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.activeLeftTab).toBe('checks');
+  });
+
+  it('returns activeLeftTab "resources" when the server includes it', async () => {
+    const state = makeState({ activeLeftTab: 'resources' });
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.activeLeftTab).toBe('resources');
+  });
+
+  it('returns undefined activeLeftTab when the server omits it (old row, backward-compatible)', async () => {
+    // Old rows do not include activeLeftTab; the key must simply be absent.
+    const state = makeState(); // no activeLeftTab
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.activeLeftTab).toBeUndefined();
+  });
+});
+
+describe('useResourceState — new field: checkOccurrenceRules', () => {
+  it('returns checkOccurrenceRules when the server includes them', async () => {
+    const rules = {
+      'JDG 4:3|the the|0': 'suppress' as const,
+      'JDG 4:5|and and|0': 'surface' as const,
+    };
+    const state = makeState({ checkOccurrenceRules: rules });
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.checkOccurrenceRules).toEqual(rules);
+  });
+
+  it('returns empty checkOccurrenceRules when the server sends an empty map', async () => {
+    const state = makeState({ checkOccurrenceRules: {} });
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.checkOccurrenceRules).toEqual({});
+  });
+
+  it('returns undefined checkOccurrenceRules when the server omits it (old row, backward-compatible)', async () => {
+    const state = makeState(); // no checkOccurrenceRules
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(state)));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.checkOccurrenceRules).toBeUndefined();
+  });
+});
+
+describe('useResourceState — edge cases', () => {
+  it('returns null when the chapter has no saved state (404)', async () => {
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json(null, { status: 404 })));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toBeNull();
+  });
+
+  it('errors when the server returns a non-404 error', async () => {
+    server.use(http.get(editorStateUrl(99), () => HttpResponse.json({}, { status: 500 })));
+
+    const { result } = renderHook(() => useResourceState(99), {
+      wrapper: makeWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+
+  it('does not fire when chapterAssignmentId is 0 (falsy guard)', async () => {
+    const calls = { count: 0 };
+    server.use(
+      http.get(`${API_BASE}/chapter-assignments/0/editor-state`, () => {
+        calls.count += 1;
+        return HttpResponse.json({});
+      })
+    );
+
+    renderHook(() => useResourceState(0), { wrapper: makeWrapper() });
+
+    await new Promise(r => setTimeout(r, 50));
+    expect(calls.count).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// useSaveResourceState — persisting the new optional fields
+// ---------------------------------------------------------------------------
+
+describe('useSaveResourceState — new fields in payload', () => {
+  it('sends activeLeftTab "checks" in the resources blob', async () => {
+    const captured: { body: unknown } = { body: undefined };
+    server.use(
+      http.put(editorStateUrl(10), async ({ request }) => {
+        captured.body = await request.json();
+        return HttpResponse.json({});
+      })
+    );
+
+    const wrapper = makeWrapper();
+    const { result } = renderHook(() => useSaveResourceState(), { wrapper });
+
+    await act(async () => {
+      result.current.mutate({
+        chapterAssignmentId: 10,
+        resourceState: {
+          resources: {
+            bookCode: 'GEN',
+            chapterNumber: 1,
+            verseNumber: 1,
+            activeResource: 'ult',
+            languageCode: 'eng',
+            tabStatus: false,
+            activeLeftTab: 'checks',
+          },
+        },
+      });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(captured.body).toMatchObject({
+      resources: { activeLeftTab: 'checks' },
+    });
+  });
+
+  it('sends checkOccurrenceRules in the resources blob', async () => {
+    const rules = { 'GEN 1:1|the the|0': 'suppress' as const };
+    const captured: { body: unknown } = { body: undefined };
+    server.use(
+      http.put(editorStateUrl(10), async ({ request }) => {
+        captured.body = await request.json();
+        return HttpResponse.json({});
+      })
+    );
+
+    const wrapper = makeWrapper();
+    const { result } = renderHook(() => useSaveResourceState(), { wrapper });
+
+    await act(async () => {
+      result.current.mutate({
+        chapterAssignmentId: 10,
+        resourceState: {
+          resources: {
+            bookCode: 'GEN',
+            chapterNumber: 1,
+            verseNumber: 1,
+            activeResource: 'ult',
+            languageCode: 'eng',
+            tabStatus: false,
+            checkOccurrenceRules: rules,
+          },
+        },
+      });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(captured.body).toMatchObject({
+      resources: { checkOccurrenceRules: rules },
+    });
+  });
+
+  it('sends both activeLeftTab and checkOccurrenceRules together', async () => {
+    const rules = {
+      'JDG 4:3|the the|0': 'suppress' as const,
+      'JDG 4:5|and and|0': 'surface' as const,
+    };
+    const captured: { body: unknown } = { body: undefined };
+    server.use(
+      http.put(editorStateUrl(42), async ({ request }) => {
+        captured.body = await request.json();
+        return HttpResponse.json({});
+      })
+    );
+
+    const wrapper = makeWrapper();
+    const { result } = renderHook(() => useSaveResourceState(), { wrapper });
+
+    await act(async () => {
+      result.current.mutate({
+        chapterAssignmentId: 42,
+        resourceState: {
+          resources: {
+            bookCode: 'JDG',
+            chapterNumber: 4,
+            verseNumber: 3,
+            activeResource: 'ult',
+            languageCode: 'eng',
+            tabStatus: true,
+            activeLeftTab: 'checks',
+            checkOccurrenceRules: rules,
+          },
+        },
+      });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(captured.body).toMatchObject({
+      resources: {
+        activeLeftTab: 'checks',
+        checkOccurrenceRules: rules,
+      },
+    });
+  });
+
+  it('can omit activeLeftTab and checkOccurrenceRules (backward-compatible with old callers)', async () => {
+    const captured: { body: unknown } = { body: undefined };
+    server.use(
+      http.put(editorStateUrl(5), async ({ request }) => {
+        captured.body = await request.json();
+        return HttpResponse.json({});
+      })
+    );
+
+    const wrapper = makeWrapper();
+    const { result } = renderHook(() => useSaveResourceState(), { wrapper });
+
+    await act(async () => {
+      result.current.mutate({
+        chapterAssignmentId: 5,
+        resourceState: {
+          resources: {
+            bookCode: 'GEN',
+            chapterNumber: 1,
+            verseNumber: 1,
+            activeResource: 'ult',
+            languageCode: 'eng',
+            tabStatus: false,
+            // no activeLeftTab, no checkOccurrenceRules
+          },
+        },
+      });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(
+      (captured.body as { resources: FetchResourceState }).resources.activeLeftTab
+    ).toBeUndefined();
+    expect(
+      (captured.body as { resources: FetchResourceState }).resources.checkOccurrenceRules
+    ).toBeUndefined();
+  });
+
+  it('errors and does not mutate cache on server failure', async () => {
+    server.use(http.put(editorStateUrl(10), () => HttpResponse.json({}, { status: 500 })));
+
+    // Silence the expected Logger.logException call by spying without throwing
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const wrapper = makeWrapper();
+    const { result } = renderHook(() => useSaveResourceState(), { wrapper });
+
+    await act(async () => {
+      result.current.mutate({
+        chapterAssignmentId: 10,
+        resourceState: {
+          resources: {
+            bookCode: 'GEN',
+            chapterNumber: 1,
+            verseNumber: 1,
+            activeResource: 'ult',
+            languageCode: 'eng',
+            tabStatus: false,
+          },
+        },
+      });
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+
+  it('updates the react-query cache on success so a subsequent useResourceState read is fresh', async () => {
+    const savedState = makeState({
+      activeLeftTab: 'checks',
+      checkOccurrenceRules: { 'JDG 4:3|the the|0': 'suppress' },
+    });
+
+    server.use(
+      http.put(editorStateUrl(10), () => HttpResponse.json({})),
+      http.get(editorStateUrl(10), () => HttpResponse.json(savedState))
+    );
+
+    // Share a single QueryClient so the mutation cache update is visible to the query.
+    const queryClient = createTestQueryClient();
+    const wrapper = ({ children }: { children: ReactNode }) =>
+      createElement(QueryClientProvider, { client: queryClient }, children);
+
+    const saveHook = renderHook(() => useSaveResourceState(), { wrapper });
+    const stateHook = renderHook(() => useResourceState(10), { wrapper });
+
+    // First, fetch the initial state.
+    await waitFor(() => expect(stateHook.result.current.isSuccess).toBe(true));
+
+    // Perform a save with the new fields.
+    await act(async () => {
+      saveHook.result.current.mutate({
+        chapterAssignmentId: 10,
+        resourceState: {
+          resources: { ...savedState, bookCode: 'JDG', chapterNumber: 4, verseNumber: 3 },
+        },
+      });
+    });
+
+    await waitFor(() => expect(saveHook.result.current.isSuccess).toBe(true));
+
+    // The query cache should now reflect the new fields via onSuccess -> setQueryData.
+    const cached = queryClient.getQueryData<FetchResourceState | null>(['resource-state', 10]);
+    expect(cached?.activeLeftTab).toBe('checks');
+    expect(cached?.checkOccurrenceRules).toEqual({ 'JDG 4:3|the the|0': 'suppress' });
+  });
+});
diff --git a/src/features/bible/hooks/useResourceStatePersistence.ts b/src/features/bible/hooks/useResourceStatePersistence.ts
index 54691a8c..01bc076d 100644
--- a/src/features/bible/hooks/useResourceStatePersistence.ts
+++ b/src/features/bible/hooks/useResourceStatePersistence.ts
@@ -1,12 +1,32 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 
+import { type OccurrenceRules } from '@/features/checks/checks.types';
 import { config } from '@/lib/config';
 import { Logger } from '@/lib/services/logger';
 
+/**
+ * Which tab of the drafting-page left panel is showing (Resources | Checks).
+ * Persisted in the editor-state blob so the panel reopens where the translator
+ * left off (Repeated Word Check, W11/§6.6). Optional + backward-compatible:
+ * old rows simply omit it and the panel defaults to 'resources'.
+ */
+export type LeftTab = 'resources' | 'checks';
+
 export interface FetchResourceState {
   activeResource: string;
   languageCode: string;
   tabStatus: boolean;
+  activeLeftTab?: LeftTab;
+  /**
+   * Occurrence-level suppression rules for the Repeated Word Check, scoped to
+   * this chapter assignment (cascade layer 2, §7.1). Keyed by occurrence
+   * identity `"{snt_id}|{repeated_word}|{ordinal}"`. Optional +
+   * backward-compatible: old rows omit it and `useSuppressions` treats it as
+   * empty. This blob has a **single writer** (`useSaveResourceState`); the
+   * Checks feature reads/updates the map through that one writer rather than
+   * opening a second PUT path that would clobber the other keys.
+   */
+  checkOccurrenceRules?: OccurrenceRules;
 }
 
 interface ResourceState {
@@ -17,6 +37,8 @@ interface ResourceState {
     activeResource: string;
     languageCode: string;
     tabStatus: boolean;
+    activeLeftTab?: LeftTab;
+    checkOccurrenceRules?: OccurrenceRules;
   };
 }
 
diff --git a/src/features/checks/checks.types.ts b/src/features/checks/checks.types.ts
new file mode 100644
index 00000000..cdbb1977
--- /dev/null
+++ b/src/features/checks/checks.types.ts
@@ -0,0 +1,164 @@
+/**
+ * Type definitions for the Checks feature (Repeated Word Check, cards #277/#278).
+ *
+ * This module deliberately mixes two naming conventions:
+ *
+ *  1. **Wire types** (the `*Request` / `*Response` / `*Finding` / envelope shapes)
+ *     mirror the fluent-ai contract **verbatim in snake_case** (`lang_code`,
+ *     `snt_id`, `repeated_word`, `start_position`, …). This is the same
+ *     intentional, contained exception fluent-api made — see fluent-api decision
+ *     **D8** and the proposal §6.1 note. Do **not** "normalize" these to
+ *     camelCase: renaming silently breaks the verbatim pass-through contract with
+ *     fluent-ai (the request body is forwarded unchanged through fluent-api).
+ *     Approved in review:
+ *     https://github.com/eten-tech-foundation/fluent-api/pull/173#discussion_r3343677813
+ *
+ *  2. **UI-derived types** (resolved findings, rules, cascade verdicts) use the
+ *     repo's normal **camelCase** convention. The snake_case exception is scoped
+ *     strictly to the wire types above.
+ */
+
+// ---------------------------------------------------------------------------
+// Wire types — snake_case, verbatim fluent-ai contract (fluent-api D8).
+// Mirror of fluent-api `src/domains/ai-tools/ai-tools.types.ts` and
+// `src/lib/services/fluent-ai/fluent-ai.types.ts`.
+// ---------------------------------------------------------------------------
+
+/** Job lifecycle status from the fluent-ai `ToolJobResponse` envelope. */
+export type JobStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+
+/** One verse sent for checking. `snt_id` is the verse identifier (see W4). */
+export interface VerseInput {
+  snt_id: string;
+  text: string;
+}
+
+/**
+ * Request body for `POST /ai/tools/greek-room/repeated-words`.
+ * Forwarded verbatim by fluent-api to fluent-ai (D8). snake_case is intentional.
+ */
+export interface RepeatedWordsRequest {
+  lang_code: string;
+  lang_name: string;
+  // fluent-ai declares `project_id: str` (Pydantic v2, strict — it does NOT
+  // coerce an int to a str), so this MUST be a string on the wire. The builder
+  // already sends `String(projectItem.projectUnitId)`; typing it `string` (not
+  // `string | number`) matches that reality and keeps a stray numeric id from
+  // ever compiling through. See W1 and phase-04 manual smoke (2026-06-23).
+  project_id: string;
+  project_name: string;
+  verses: VerseInput[];
+}
+
+/** A single consecutive-repeated-word finding from Greek Room. */
+export interface RepeatedWordsFinding {
+  /** Verse identifier, e.g. `"JDG 4:3"` (USFM book code; see W4). */
+  snt_id: string;
+  /** The repeated pair, NFC + lowercased by Greek Room, e.g. `"the the"`. */
+  repeated_word: string;
+  /** The original surface text as it appeared (preserves casing); display only. */
+  surf: string;
+  /** Character offset of the finding within the verse text. */
+  start_position: number;
+  /** Greek Room's verdict: `true` ⇒ intentional/correct (machine "Default Ignore"). */
+  legitimate: boolean;
+  /** Upstream numeric severity (e.g. 0.1 legitimate, 0.5 suspicious). */
+  severity: number;
+}
+
+export interface RepeatedWordsSummary {
+  total_findings: number;
+  legitimate_count: number;
+  verse_count: number;
+}
+
+/** The `result` payload when `status === "completed"`. */
+export interface RepeatedWordsResult {
+  lang_code: string;
+  provider: string;
+  check: string;
+  findings: RepeatedWordsFinding[];
+  summary: RepeatedWordsSummary;
+}
+
+/** fluent-ai's error shape inside the envelope. */
+export interface ToolJobError {
+  code: string;
+  message: string;
+  details?: unknown;
+}
+
+/**
+ * The full `ToolJobResponse` envelope, passed through fluent-api unchanged (D9).
+ * The hook consumes the whole envelope and branches on `status`, so a future
+ * async/polling tool (`status: "queued"`) drops in without reshaping the UI.
+ */
+export interface ToolJobResponse<TResult> {
+  job_id: string;
+  tool: string;
+  status: JobStatus;
+  result: TResult | null;
+  error: ToolJobError | null;
+  created_at: string;
+  completed_at: string | null;
+}
+
+/** Convenience alias for the repeated-words envelope. */
+export type RepeatedWordsResponse = ToolJobResponse<RepeatedWordsResult>;
+
+// ---------------------------------------------------------------------------
+// UI-derived types — camelCase (the repo's normal convention).
+// ---------------------------------------------------------------------------
+
+/**
+ * A tri-state suppression rule (W5/W6). `'suppress'` hides a finding,
+ * `'surface'` forces it active (per-occurrence undo of a global rule or of a
+ * Greek Room `legitimate` verdict). Absence of a key = silent (no opinion).
+ */
+export type RuleVerdict = 'suppress' | 'surface';
+
+/**
+ * Occurrence-level rules (cascade layer 2), scoped to one chapter assignment.
+ * Keyed by occurrence identity `"{snt_id}|{repeated_word}|{ordinal}"`.
+ * Persisted in the editor-state JSONB blob (`checkOccurrenceRules`).
+ */
+export type OccurrenceRules = Record<string, RuleVerdict>;
+
+/**
+ * User-global word-pair rules (cascade layer 1), across all the user's projects.
+ * Keyed by the NFC-normalized `repeated_word` pair (e.g. `"the the"`).
+ * Persisted in `user_settings.checkIgnoredWordPairs`.
+ */
+export type GlobalRules = Record<string, RuleVerdict>;
+
+/** Why a finding is currently inactive (drives the dimmed ignore-type label). */
+export type InactiveReason =
+  | 'occurrence' // user "Ignore Here"
+  | 'global' // user "Ignore Everywhere"
+  | 'legitimate'; // Greek Room "Default Ignore"
+
+/**
+ * A finding after the three-layer cascade has been applied (§6.4).
+ * Carries the original wire finding plus the derived identity and verdict.
+ */
+export interface ResolvedFinding {
+  /** The raw finding from Greek Room (snake_case wire shape preserved). */
+  finding: RepeatedWordsFinding;
+  /**
+   * Index of this finding among same-`repeated_word` findings in the same
+   * verse, ordered by `start_position` (the "x of n" ordinal, W4). Zero-based.
+   */
+  ordinal: number;
+  /** Stable occurrence identity key: `"{snt_id}|{repeated_word}|{ordinal}"`. */
+  occurrenceKey: string;
+  /** Whether the finding is currently active (counts toward the dot). */
+  isActive: boolean;
+  /** Present only when `isActive === false`: which layer suppressed it. */
+  inactiveReason?: InactiveReason;
+}
+
+/** Output of the cascade: findings split into active and inactive buckets. */
+export interface ResolvedFindings {
+  active: ResolvedFinding[];
+  inactive: ResolvedFinding[];
+}
diff --git a/src/features/checks/components/ChecksPanel.test.tsx b/src/features/checks/components/ChecksPanel.test.tsx
new file mode 100644
index 00000000..8e5a4045
--- /dev/null
+++ b/src/features/checks/components/ChecksPanel.test.tsx
@@ -0,0 +1,277 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { renderWithProviders, screen } from '@/test/render';
+
+import { type ResolvedFinding, type ResolvedFindings } from '../checks.types';
+
+import { ChecksPanel } from './ChecksPanel';
+
+const active = (sntId: string, word: string, ordinal = 0): ResolvedFinding => ({
+  finding: {
+    snt_id: sntId,
+    repeated_word: word,
+    surf: `${word} (in ${sntId})`,
+    start_position: 0,
+    legitimate: false,
+    severity: 0.5,
+  },
+  ordinal,
+  occurrenceKey: `${sntId}|${word}|${ordinal}`,
+  isActive: true,
+});
+
+const inactive = (
+  sntId: string,
+  word: string,
+  reason: ResolvedFinding['inactiveReason'],
+  ordinal = 0
+): ResolvedFinding => ({
+  ...active(sntId, word, ordinal),
+  isActive: false,
+  inactiveReason: reason,
+});
+
+const handlers = () => ({
+  onIgnoreHere: vi.fn(),
+  onIgnoreEverywhere: vi.fn(),
+  onUndo: vi.fn(),
+  onStopIgnoringEverywhere: vi.fn(),
+});
+
+const renderPanel = (resolved: ResolvedFindings, over: Partial<{ isError: boolean }> = {}) =>
+  renderWithProviders(
+    <ChecksPanel
+      globalIgnoresAvailable
+      isError={over.isError ?? false}
+      resolved={resolved}
+      {...handlers()}
+    />
+  );
+
+describe('ChecksPanel — grouping & zero state', () => {
+  it('groups active findings by verse with a "Verse N" heading per findings-bearing verse', () => {
+    renderPanel({
+      active: [active('JDG 4:1', 'the the'), active('JDG 4:3', 'and and')],
+      inactive: [],
+    });
+    expect(screen.getByRole('heading', { name: 'Verse 1' })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: 'Verse 3' })).toBeInTheDocument();
+    // Verse 2 had no findings -> no heading.
+    expect(screen.queryByRole('heading', { name: 'Verse 2' })).not.toBeInTheDocument();
+  });
+
+  it('renders a separator between verse groups (one fewer than the group count)', () => {
+    const { container } = renderPanel({
+      active: [active('JDG 4:1', 'the the'), active('JDG 4:3', 'and and')],
+      inactive: [],
+    });
+    expect(container.querySelectorAll('[data-slot="separator"]')).toHaveLength(1);
+  });
+
+  it('shows "No issues found" when there are no active findings', () => {
+    renderPanel({ active: [], inactive: [] });
+    expect(screen.getByText('No issues found')).toBeInTheDocument();
+  });
+
+  it('falls back to the raw snt_id when it does not parse to a verse number', () => {
+    renderPanel({ active: [active('weird-id', 'the the')], inactive: [] });
+    expect(screen.getByRole('heading', { name: 'weird-id' })).toBeInTheDocument();
+  });
+});
+
+describe('ChecksPanel — error line', () => {
+  it('renders the inline error line when isError', () => {
+    renderPanel({ active: [active('JDG 4:1', 'the the')], inactive: [] }, { isError: true });
+    expect(screen.getByRole('alert')).toHaveTextContent('Checks failed to refresh');
+  });
+
+  it('does NOT show the zero state on error (error over empty section instead)', () => {
+    renderPanel({ active: [], inactive: [] }, { isError: true });
+    expect(screen.getByRole('alert')).toHaveTextContent('Checks failed to refresh');
+    expect(screen.queryByText('No issues found')).not.toBeInTheDocument();
+  });
+
+  it('keeps rendering last-known findings below the error line', () => {
+    renderPanel({ active: [active('JDG 4:1', 'the the')], inactive: [] }, { isError: true });
+    expect(screen.getByRole('alert')).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: 'Verse 1' })).toBeInTheDocument();
+  });
+});
+
+describe('ChecksPanel — Show Ignored toggle', () => {
+  it('hides inactive findings by default (toggle off) and reveals them when toggled on', async () => {
+    const resolved: ResolvedFindings = {
+      active: [active('JDG 4:1', 'the the')],
+      inactive: [inactive('JDG 4:1', 'and and', 'occurrence')],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+
+    // Default OFF: the inactive snippet is not shown.
+    expect(screen.queryByText('and and (in JDG 4:1)')).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+    expect(screen.getByText('and and (in JDG 4:1)')).toBeInTheDocument();
+    expect(screen.getByTestId('inactive-label')).toHaveTextContent('Ignore Here');
+  });
+
+  it('does not render the toggle when there are no inactive findings', () => {
+    renderPanel({ active: [active('JDG 4:1', 'the the')], inactive: [] });
+    expect(screen.queryByRole('switch', { name: 'Show Ignored' })).not.toBeInTheDocument();
+  });
+
+  it('renders revealed ignored findings in a dedicated section BELOW the toggle (revised #278 mock)', async () => {
+    const resolved: ResolvedFindings = {
+      active: [active('JDG 4:1', 'the the')],
+      inactive: [inactive('JDG 4:2', 'and and', 'occurrence')],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+
+    const ignoredSection = screen.getByTestId('ignored-section');
+    // The ignored finding lives inside the dedicated below-toggle section...
+    expect(ignoredSection).toHaveTextContent('and and (in JDG 4:2)');
+    expect(ignoredSection).toHaveTextContent('Verse 2');
+    // ...and NOT interleaved into the active group above the toggle.
+    expect(ignoredSection).not.toHaveTextContent('the the (in JDG 4:1)');
+
+    // The toggle (switch) appears in the DOM before the ignored section.
+    const toggle = screen.getByRole('switch', { name: 'Show Ignored' });
+    expect(toggle.compareDocumentPosition(ignoredSection)).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
+  });
+
+  it('resets the toggle (not persisted) across remounts', async () => {
+    const resolved: ResolvedFindings = {
+      active: [],
+      inactive: [inactive('JDG 4:1', 'and and', 'global')],
+    };
+    const { user, unmount } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+    expect(screen.getByText('and and (in JDG 4:1)')).toBeInTheDocument();
+    unmount();
+
+    // Fresh mount = fresh session: toggle is OFF again.
+    renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    expect(screen.queryByText('and and (in JDG 4:1)')).not.toBeInTheDocument();
+  });
+});
+
+describe('ChecksPanel — verseHeading helper (via grouping)', () => {
+  it('handles a snt_id with no colon by rendering the raw id as the heading', () => {
+    renderPanel({ active: [active('NOCOLON', 'the the')], inactive: [] });
+    expect(screen.getByRole('heading', { name: 'NOCOLON' })).toBeInTheDocument();
+  });
+
+  it('handles a snt_id whose verse segment after the colon is not a number', () => {
+    renderPanel({ active: [active('JDG 4:abc', 'the the')], inactive: [] });
+    expect(screen.getByRole('heading', { name: 'JDG 4:abc' })).toBeInTheDocument();
+  });
+
+  it('renders multi-digit verse numbers correctly', () => {
+    renderPanel({ active: [active('REV 22:21', 'the the')], inactive: [] });
+    expect(screen.getByRole('heading', { name: 'Verse 21' })).toBeInTheDocument();
+  });
+});
+
+describe('ChecksPanel — "Show Ignored" toggle visibility', () => {
+  it('does not render the ignored section before the toggle is clicked even with inactive findings', () => {
+    const resolved: ResolvedFindings = {
+      active: [],
+      inactive: [inactive('JDG 4:1', 'the the', 'legitimate')],
+    };
+    renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    expect(screen.queryByTestId('ignored-section')).not.toBeInTheDocument();
+  });
+
+  it('shows the zero state while inactive findings exist but toggle is off', () => {
+    // No active findings + inactive findings present + toggle off = zero state visible
+    // because showingIgnored is false and activeGroups is empty.
+    const resolved: ResolvedFindings = {
+      active: [],
+      inactive: [inactive('JDG 4:1', 'the the', 'occurrence')],
+    };
+    renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    expect(screen.getByText('No issues found')).toBeInTheDocument();
+    expect(screen.queryByTestId('ignored-section')).not.toBeInTheDocument();
+  });
+
+  it('hides the zero state once the toggle is turned on (ignored items now showing)', async () => {
+    const resolved: ResolvedFindings = {
+      active: [],
+      inactive: [inactive('JDG 4:1', 'the the', 'occurrence')],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    // Toggle is OFF: zero state is visible.
+    expect(screen.getByText('No issues found')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+
+    // Toggle is ON: zero state must be hidden; ignored section appears.
+    expect(screen.queryByText('No issues found')).not.toBeInTheDocument();
+    expect(screen.getByTestId('ignored-section')).toBeInTheDocument();
+  });
+
+  it('supports all three inactive reasons (occurrence / global / legitimate) in the ignored section', async () => {
+    const resolved: ResolvedFindings = {
+      active: [],
+      inactive: [
+        inactive('JDG 4:1', 'the the', 'occurrence', 0),
+        inactive('JDG 4:2', 'and and', 'global', 0),
+        inactive('JDG 4:3', 'for for', 'legitimate', 0),
+      ],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...handlers()} />
+    );
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+
+    const section = screen.getByTestId('ignored-section');
+    expect(section).toHaveTextContent('Verse 1');
+    expect(section).toHaveTextContent('Verse 2');
+    expect(section).toHaveTextContent('Verse 3');
+  });
+});
+
+describe('ChecksPanel — callback wiring', () => {
+  it('passes onIgnoreHere through to the active FindingRow', async () => {
+    const h = handlers();
+    const resolved: ResolvedFindings = {
+      active: [active('JDG 4:1', 'the the')],
+      inactive: [],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...h} />
+    );
+    await user.click(screen.getByRole('button', { name: 'Ignore Here' }));
+    expect(h.onIgnoreHere).toHaveBeenCalledWith('JDG 4:1|the the|0');
+  });
+
+  it('passes onUndo through to the inactive FindingRow (after toggle)', async () => {
+    const h = handlers();
+    const inactiveFinding = inactive('JDG 4:1', 'the the', 'occurrence');
+    const resolved: ResolvedFindings = {
+      active: [active('JDG 4:2', 'and and')],
+      inactive: [inactiveFinding],
+    };
+    const { user } = renderWithProviders(
+      <ChecksPanel globalIgnoresAvailable isError={false} resolved={resolved} {...h} />
+    );
+    await user.click(screen.getByRole('switch', { name: 'Show Ignored' }));
+    await user.click(screen.getByRole('button', { name: 'Undo Ignore' }));
+    expect(h.onUndo).toHaveBeenCalledWith(inactiveFinding);
+  });
+});
diff --git a/src/features/checks/components/ChecksPanel.tsx b/src/features/checks/components/ChecksPanel.tsx
new file mode 100644
index 00000000..66affa35
--- /dev/null
+++ b/src/features/checks/components/ChecksPanel.tsx
@@ -0,0 +1,203 @@
+import { useState } from 'react';
+
+import {
+  Accordion,
+  AccordionContent,
+  AccordionItem,
+  AccordionTrigger,
+} from '@/components/ui/accordion';
+import { Label } from '@/components/ui/label';
+import { Separator } from '@/components/ui/separator';
+import { Switch } from '@/components/ui/switch';
+
+import { type ResolvedFinding, type ResolvedFindings } from '../checks.types';
+
+import { FindingRow } from './FindingRow';
+
+export interface ChecksPanelProps {
+  /** Cascade output: `{ active[], inactive[] }` from `useResolvedFindings`. */
+  resolved: ResolvedFindings;
+  /** The check query errored — show the inline red line (W9). */
+  isError: boolean;
+  /** Hide the global "Ignore Everywhere" affordance when unavailable (W8). */
+  globalIgnoresAvailable: boolean;
+  /** Active: suppress this occurrence ("Ignore Here"). */
+  onIgnoreHere: (occurrenceKey: string) => void;
+  /** Active: suppress this word pair globally (called only after confirm, S7). */
+  onIgnoreEverywhere: (repeatedWord: string) => void;
+  /** Inactive `[Undo ▾]` default click. */
+  onUndo: (resolved: ResolvedFinding) => void;
+  /** Inactive `[Undo ▾]` chevron: stop ignoring this pair everywhere. */
+  onStopIgnoringEverywhere: (repeatedWord: string) => void;
+}
+
+/**
+ * Derive the "Verse N" group heading from a `snt_id` (`"{book} {ch}:{verse}"`,
+ * e.g. `"JDG 4:3"` → "Verse 3"). Robust: take the segment after the last `:`;
+ * if it isn't a number (malformed `snt_id`), fall back to the raw `snt_id` so
+ * the heading is never blank.
+ */
+const verseHeading = (sntId: string): string => {
+  const afterColon = sntId.includes(':') ? sntId.slice(sntId.lastIndexOf(':') + 1).trim() : '';
+  return /^\d+$/.test(afterColon) ? `Verse ${afterColon}` : sntId;
+};
+
+interface VerseGroup {
+  sntId: string;
+  heading: string;
+  rows: ResolvedFinding[];
+}
+
+/**
+ * Parse the verse number out of a `snt_id` (segment after the last `:`) for
+ * sort ordering. For a verse range (e.g. `"JDG 4:4-5"`) the leading number
+ * before the dash is used. A malformed `snt_id` (no colon / no leading digits)
+ * yields `Number.POSITIVE_INFINITY` so it sorts to the end — preserving the
+ * never-blank-heading guarantee (`verseHeading` still renders the raw id).
+ */
+const verseNum = (sntId: string): number => {
+  const afterColon = sntId.slice(sntId.lastIndexOf(':') + 1).trim();
+  const leadingDigits = /^\d+/.exec(afterColon)?.[0];
+  return leadingDigits ? Number(leadingDigits) : Number.POSITIVE_INFINITY;
+};
+
+/**
+ * Group one bucket of resolved findings by verse (`snt_id`), sorted by verse
+ * number. Only verses that actually have rows produce a group (§5.1, §6.4).
+ * Active and inactive findings are grouped **separately** now (revised #278
+ * mock): active findings render above the "Show Ignored" toggle, ignored
+ * findings in their own dedicated section below it — so each call groups a
+ * single, already-filtered bucket rather than merging the two.
+ */
+const groupByVerse = (findings: ResolvedFinding[]): VerseGroup[] => {
+  const order: string[] = [];
+  const byVerse = new Map<string, ResolvedFinding[]>();
+
+  for (const f of findings) {
+    const sntId = f.finding.snt_id;
+    let rows = byVerse.get(sntId);
+    if (!rows) {
+      rows = [];
+      byVerse.set(sntId, rows);
+      order.push(sntId);
+    }
+    rows.push(f);
+  }
+
+  return order
+    .map(sntId => ({
+      sntId,
+      heading: verseHeading(sntId),
+      rows: byVerse.get(sntId) ?? [],
+    }))
+    .sort((a, b) => verseNum(a.sntId) - verseNum(b.sntId));
+};
+
+/** Render a list of verse groups with separators between (one fewer than groups). */
+const renderGroups = (
+  groups: VerseGroup[],
+  globalIgnoresAvailable: boolean,
+  handlers: Pick<
+    ChecksPanelProps,
+    'onIgnoreHere' | 'onIgnoreEverywhere' | 'onUndo' | 'onStopIgnoringEverywhere'
+  >
+) =>
+  groups.map((group, index) => (
+    <div key={group.sntId}>
+      {index > 0 && <Separator className='my-2' />}
+      <h4 className='text-sm font-bold'>{group.heading}</h4>
+      {group.rows.map(row => (
+        <FindingRow
+          key={row.occurrenceKey}
+          globalIgnoresAvailable={globalIgnoresAvailable}
+          resolved={row}
+          onIgnoreEverywhere={handlers.onIgnoreEverywhere}
+          onIgnoreHere={handlers.onIgnoreHere}
+          onStopIgnoringEverywhere={handlers.onStopIgnoringEverywhere}
+          onUndo={handlers.onUndo}
+        />
+      ))}
+    </div>
+  ));
+
+/**
+ * The Checks-tab body (§5.1, §6.4–§6.6).
+ *
+ * A per-check accordion (only "Repeated Words" is wired; the structure
+ * anticipates sibling checks) containing the active verse-grouped findings, a
+ * "Show Ignored" toggle, and — when toggled on — a dedicated **ignored** section
+ * *below* the toggle (revised #278 mock layout: ignored occurrences appear below
+ * the active flags, visually distinct/dimmed). Also a zero state and an inline
+ * error line. Purely presentational — it receives the cascade-resolved buckets
+ * and the suppression callbacks; it owns neither the check query nor the
+ * suppression hook (Phase 4 composes them), and only the session-local "Show
+ * Ignored" toggle is local state (deliberately **not** persisted, per #278).
+ */
+export const ChecksPanel: React.FC<ChecksPanelProps> = ({
+  resolved,
+  isError,
+  globalIgnoresAvailable,
+  onIgnoreHere,
+  onIgnoreEverywhere,
+  onUndo,
+  onStopIgnoringEverywhere,
+}) => {
+  const [showIgnored, setShowIgnored] = useState(false);
+
+  const { active, inactive } = resolved;
+  const handlers = { onIgnoreHere, onIgnoreEverywhere, onUndo, onStopIgnoringEverywhere };
+  const activeGroups = groupByVerse(active);
+  const ignoredGroups = groupByVerse(inactive);
+  const hasIgnored = inactive.length > 0;
+  const showingIgnored = showIgnored && hasIgnored;
+  // The zero state must never show on error (§9.2 — an error line over an empty
+  // section instead) and only when there is genuinely nothing to display: no
+  // active findings AND nothing currently revealed by the "Show Ignored" toggle.
+  const showZeroState = !isError && activeGroups.length === 0 && !showingIgnored;
+
+  return (
+    <div className='px-1 py-3'>
+      {isError && (
+        <p className='mb-2 text-sm text-red-500' role='alert'>
+          Checks failed to refresh
+        </p>
+      )}
+
+      <div className='rounded-lg border p-2'>
+        <Accordion collapsible defaultValue='repeated-words' type='single'>
+          <AccordionItem className='border-b-0' value='repeated-words'>
+            <AccordionTrigger className='py-2 text-base'>Repeated Words</AccordionTrigger>
+            <AccordionContent>
+              {showZeroState ? (
+                <p className='py-4 text-center text-sm font-bold'>No issues found</p>
+              ) : (
+                <div>{renderGroups(activeGroups, globalIgnoresAvailable, handlers)}</div>
+              )}
+
+              {hasIgnored && (
+                <div className='mt-3 flex items-center gap-2 border-t pt-3'>
+                  <Switch
+                    checked={showIgnored}
+                    id='checks-show-ignored'
+                    onCheckedChange={setShowIgnored}
+                  />
+                  <Label className='text-sm font-normal' htmlFor='checks-show-ignored'>
+                    Show Ignored
+                  </Label>
+                </div>
+              )}
+
+              {showingIgnored && (
+                <div className='mt-3' data-testid='ignored-section'>
+                  {renderGroups(ignoredGroups, globalIgnoresAvailable, handlers)}
+                </div>
+              )}
+            </AccordionContent>
+          </AccordionItem>
+        </Accordion>
+      </div>
+    </div>
+  );
+};
+
+export default ChecksPanel;
diff --git a/src/features/checks/components/FindingRow.test.tsx b/src/features/checks/components/FindingRow.test.tsx
new file mode 100644
index 00000000..bb7a2222
--- /dev/null
+++ b/src/features/checks/components/FindingRow.test.tsx
@@ -0,0 +1,143 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { renderWithProviders, screen, within } from '@/test/render';
+
+import { type ResolvedFinding } from '../checks.types';
+
+import { FindingRow } from './FindingRow';
+
+const makeResolved = (over: Partial<ResolvedFinding> = {}): ResolvedFinding => ({
+  finding: {
+    snt_id: 'JDG 4:3',
+    repeated_word: 'the the',
+    surf: 'and The the made',
+    start_position: 4,
+    legitimate: false,
+    severity: 0.5,
+  },
+  ordinal: 0,
+  occurrenceKey: 'JDG 4:3|the the|0',
+  isActive: true,
+  ...over,
+});
+
+const handlers = () => ({
+  onIgnoreHere: vi.fn(),
+  onIgnoreEverywhere: vi.fn(),
+  onUndo: vi.fn(),
+  onStopIgnoringEverywhere: vi.fn(),
+});
+
+describe('FindingRow — active', () => {
+  it('renders the surface snippet and both ignore buttons', () => {
+    renderWithProviders(
+      <FindingRow globalIgnoresAvailable resolved={makeResolved()} {...handlers()} />
+    );
+    expect(screen.getByText('and The the made')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Ignore Here' })).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Ignore Everywhere' })).toBeInTheDocument();
+  });
+
+  it('fires onIgnoreHere with the occurrence key', async () => {
+    const h = handlers();
+    const { user } = renderWithProviders(
+      <FindingRow globalIgnoresAvailable resolved={makeResolved()} {...h} />
+    );
+    await user.click(screen.getByRole('button', { name: 'Ignore Here' }));
+    expect(h.onIgnoreHere).toHaveBeenCalledWith('JDG 4:3|the the|0');
+  });
+
+  it('hides Ignore Everywhere when global ignores are unavailable', () => {
+    renderWithProviders(
+      <FindingRow globalIgnoresAvailable={false} resolved={makeResolved()} {...handlers()} />
+    );
+    expect(screen.queryByRole('button', { name: 'Ignore Everywhere' })).not.toBeInTheDocument();
+  });
+
+  it('Ignore Everywhere opens a confirm dialog and only fires on confirm', async () => {
+    const h = handlers();
+    const { user } = renderWithProviders(
+      <FindingRow globalIgnoresAvailable resolved={makeResolved()} {...h} />
+    );
+
+    await user.click(screen.getByRole('button', { name: 'Ignore Everywhere' }));
+    // Dialog is open; the action has NOT fired yet.
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(h.onIgnoreEverywhere).not.toHaveBeenCalled();
+
+    // Confirm via the dialog's own "Ignore Everywhere" button.
+    const dialog = screen.getByRole('dialog');
+    await user.click(within(dialog).getByRole('button', { name: 'Ignore Everywhere' }));
+    expect(h.onIgnoreEverywhere).toHaveBeenCalledWith('the the');
+  });
+
+  it('Cancel in the confirm dialog does not fire onIgnoreEverywhere', async () => {
+    const h = handlers();
+    const { user } = renderWithProviders(
+      <FindingRow globalIgnoresAvailable resolved={makeResolved()} {...h} />
+    );
+    await user.click(screen.getByRole('button', { name: 'Ignore Everywhere' }));
+    await user.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(h.onIgnoreEverywhere).not.toHaveBeenCalled();
+  });
+});
+
+describe('FindingRow — inactive', () => {
+  it('renders the correct ignore-type label for each inactive reason', () => {
+    const cases: Array<[ResolvedFinding['inactiveReason'], string]> = [
+      ['occurrence', 'Ignore Here'],
+      ['global', 'Ignore Always'],
+      ['legitimate', 'Default Ignore'],
+    ];
+    for (const [reason, label] of cases) {
+      const { unmount } = renderWithProviders(
+        <FindingRow
+          globalIgnoresAvailable
+          resolved={makeResolved({ isActive: false, inactiveReason: reason })}
+          {...handlers()}
+        />
+      );
+      expect(screen.getByTestId('inactive-label')).toHaveTextContent(label);
+      // No active ignore buttons on an inactive row.
+      expect(screen.queryByRole('button', { name: 'Ignore Here' })).not.toBeInTheDocument();
+      unmount();
+    }
+  });
+
+  it('Undo Ignore default click fires onUndo with the resolved finding', async () => {
+    const h = handlers();
+    const resolved = makeResolved({ isActive: false, inactiveReason: 'occurrence' });
+    const { user } = renderWithProviders(
+      <FindingRow globalIgnoresAvailable resolved={resolved} {...h} />
+    );
+    await user.click(screen.getByRole('button', { name: 'Undo Ignore' }));
+    expect(h.onUndo).toHaveBeenCalledWith(resolved);
+  });
+
+  it('chevron menu fires onStopIgnoringEverywhere when global ignores are available', async () => {
+    const h = handlers();
+    const { user } = renderWithProviders(
+      <FindingRow
+        globalIgnoresAvailable
+        resolved={makeResolved({ isActive: false, inactiveReason: 'global' })}
+        {...h}
+      />
+    );
+    await user.click(screen.getByRole('button', { name: 'More undo options' }));
+    await user.click(screen.getByRole('menuitem', { name: /Stop ignoring/ }));
+    expect(h.onStopIgnoringEverywhere).toHaveBeenCalledWith('the the');
+  });
+
+  it('omits the chevron (global entry) when global ignores are unavailable', () => {
+    renderWithProviders(
+      <FindingRow
+        globalIgnoresAvailable={false}
+        resolved={makeResolved({ isActive: false, inactiveReason: 'occurrence' })}
+        {...handlers()}
+      />
+    );
+    expect(screen.queryByRole('button', { name: 'More undo options' })).not.toBeInTheDocument();
+    // The plain Undo button is still present.
+    expect(screen.getByRole('button', { name: 'Undo Ignore' })).toBeInTheDocument();
+  });
+});
diff --git a/src/features/checks/components/FindingRow.tsx b/src/features/checks/components/FindingRow.tsx
new file mode 100644
index 00000000..883f6da7
--- /dev/null
+++ b/src/features/checks/components/FindingRow.tsx
@@ -0,0 +1,174 @@
+import { useState } from 'react';
+
+import { ChevronDown } from 'lucide-react';
+
+import { Button } from '@/components/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+import { cn } from '@/lib/utils';
+
+import { type InactiveReason, type ResolvedFinding } from '../checks.types';
+
+/**
+ * Human-readable ignore-type label for an inactive finding (§6.4, revised #278).
+ *
+ * Note the deliberate label mismatch: the **active** button is "Ignore
+ * Everywhere", but a finding inactivated by a global rule shows "Ignore Always"
+ * — that is the term the #278 mock uses for the inactive label. Don't unify the
+ * two (conventions §G / phase-03 gotchas).
+ */
+const INACTIVE_LABEL: Record<InactiveReason, string> = {
+  occurrence: 'Ignore Here',
+  global: 'Ignore Always',
+  legitimate: 'Default Ignore',
+};
+
+export interface FindingRowProps {
+  /** The cascade-resolved finding to render. */
+  resolved: ResolvedFinding;
+  /** Hide the global "Ignore Everywhere" affordance when the backend half is
+   *  absent (feature detection, W8). */
+  globalIgnoresAvailable: boolean;
+  /** Active: suppress just this occurrence ("Ignore Here"). */
+  onIgnoreHere: (occurrenceKey: string) => void;
+  /** Active: suppress this word pair globally — called **only after** the user
+   *  confirms the dialog (S7). */
+  onIgnoreEverywhere: (repeatedWord: string) => void;
+  /** Inactive `[Undo ▾]` default click: reverse at the occurrence layer. */
+  onUndo: (resolved: ResolvedFinding) => void;
+  /** Inactive `[Undo ▾]` chevron: deliberately stop ignoring this pair
+   *  everywhere (only offered when `globalIgnoresAvailable`). */
+  onStopIgnoringEverywhere: (repeatedWord: string) => void;
+}
+
+/**
+ * One repeated-word finding row (§5.1, §6.4–§6.5).
+ *
+ * - **Active** findings show the context snippet plus two solid-blue buttons,
+ *   `[Ignore Here]` and (when available) `[Ignore Everywhere]`. The latter opens
+ *   a confirm dialog (S7) and only fires `onIgnoreEverywhere` on confirm, while
+ *   the resulting inactive row stays reversible via `[Undo ▾]` — the two are
+ *   complementary (confirm guards the click; undo guards the mistake).
+ * - **Inactive** findings render greyed/dimmed with their ignore-type label and
+ *   one `[Undo ▾]` split button: the main button reverses at the occurrence
+ *   layer; the chevron offers the deliberate global "stop ignoring everywhere".
+ *
+ * Presentational only: it owns the confirm-dialog open state (local to the row)
+ * but never the suppression hook or the check query.
+ */
+export const FindingRow: React.FC<FindingRowProps> = ({
+  resolved,
+  globalIgnoresAvailable,
+  onIgnoreHere,
+  onIgnoreEverywhere,
+  onUndo,
+  onStopIgnoringEverywhere,
+}) => {
+  const [confirmOpen, setConfirmOpen] = useState(false);
+  const { finding, isActive, inactiveReason, occurrenceKey } = resolved;
+  // Display the original surface text (preserves casing); never compare on it —
+  // all matching already happened in the cascade (conventions §C).
+  const snippet = finding.surf;
+
+  if (isActive) {
+    return (
+      <div className='py-2' data-testid='finding-row'>
+        <p className='text-sm'>{snippet}</p>
+        <div className='mt-2 flex flex-wrap gap-2'>
+          <Button size='sm' type='button' onClick={() => onIgnoreHere(occurrenceKey)}>
+            Ignore Here
+          </Button>
+          {globalIgnoresAvailable && (
+            <Button size='sm' type='button' onClick={() => setConfirmOpen(true)}>
+              Ignore Everywhere
+            </Button>
+          )}
+        </div>
+
+        <Dialog open={confirmOpen} onOpenChange={setConfirmOpen}>
+          <DialogContent>
+            <DialogHeader>
+              <DialogTitle>Ignore everywhere?</DialogTitle>
+              <DialogDescription>
+                Fluent will not flag this word pair again across all your projects. Are you sure?
+              </DialogDescription>
+            </DialogHeader>
+            <DialogFooter>
+              <Button type='button' variant='outline' onClick={() => setConfirmOpen(false)}>
+                Cancel
+              </Button>
+              <Button
+                type='button'
+                onClick={() => {
+                  setConfirmOpen(false);
+                  onIgnoreEverywhere(finding.repeated_word);
+                }}
+              >
+                Ignore Everywhere
+              </Button>
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+      </div>
+    );
+  }
+
+  // Inactive — greyed, ignore-type label, [Undo ▾] split button.
+  const label = inactiveReason ? INACTIVE_LABEL[inactiveReason] : 'Ignored';
+
+  return (
+    <div className='py-2 opacity-50' data-testid='finding-row'>
+      <p className='text-sm'>{snippet}</p>
+      <div className='mt-2 flex flex-wrap items-center justify-between gap-2'>
+        <span className='text-muted-foreground text-xs font-medium' data-testid='inactive-label'>
+          {label}
+        </span>
+        <div className='flex'>
+          <Button
+            className={cn(globalIgnoresAvailable && 'rounded-r-none')}
+            size='sm'
+            type='button'
+            variant='outline'
+            onClick={() => onUndo(resolved)}
+          >
+            Undo Ignore
+          </Button>
+          {globalIgnoresAvailable && (
+            <DropdownMenu>
+              <DropdownMenuTrigger asChild>
+                <Button
+                  aria-label='More undo options'
+                  className='rounded-l-none border-l-0 px-2'
+                  size='sm'
+                  type='button'
+                  variant='outline'
+                >
+                  <ChevronDown />
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align='end'>
+                <DropdownMenuItem onClick={() => onStopIgnoringEverywhere(finding.repeated_word)}>
+                  Stop ignoring “{finding.repeated_word}” everywhere
+                </DropdownMenuItem>
+              </DropdownMenuContent>
+            </DropdownMenu>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default FindingRow;
diff --git a/src/features/checks/components/LeftPanel.test.tsx b/src/features/checks/components/LeftPanel.test.tsx
new file mode 100644
index 00000000..a54818d0
--- /dev/null
+++ b/src/features/checks/components/LeftPanel.test.tsx
@@ -0,0 +1,117 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { LeftPanel } from './LeftPanel';
+
+const baseProps = {
+  activeTab: 'resources' as const,
+  onTabChange: vi.fn(),
+  activeFindingsCount: 0,
+  resourcesContent: <div>resources-body</div>,
+  checksContent: <div>checks-body</div>,
+};
+
+describe('LeftPanel', () => {
+  it('renders both tabs', () => {
+    render(<LeftPanel {...baseProps} />);
+    expect(screen.getByRole('tab', { name: /Resources/ })).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: /Checks/ })).toBeInTheDocument();
+  });
+
+  it('shows the active tab body and hides the inactive one', () => {
+    const { rerender } = render(<LeftPanel {...baseProps} activeTab='resources' />);
+    expect(screen.getByText('resources-body')).toBeInTheDocument();
+    expect(screen.queryByText('checks-body')).not.toBeInTheDocument();
+
+    rerender(<LeftPanel {...baseProps} activeTab='checks' />);
+    expect(screen.getByText('checks-body')).toBeInTheDocument();
+    expect(screen.queryByText('resources-body')).not.toBeInTheDocument();
+  });
+
+  it('marks the active tab via aria-selected', () => {
+    render(<LeftPanel {...baseProps} activeTab='checks' />);
+    expect(screen.getByRole('tab', { name: /Checks/ })).toHaveAttribute('aria-selected', 'true');
+    expect(screen.getByRole('tab', { name: /Resources/ })).toHaveAttribute(
+      'aria-selected',
+      'false'
+    );
+  });
+
+  it('wires both tabs to the shared tabpanel via aria-controls', () => {
+    render(<LeftPanel {...baseProps} activeTab='resources' />);
+    const panel = screen.getByRole('tabpanel');
+    const panelId = panel.getAttribute('id');
+    expect(panelId).toBeTruthy();
+    expect(screen.getByRole('tab', { name: /Resources/ })).toHaveAttribute(
+      'aria-controls',
+      panelId
+    );
+    expect(screen.getByRole('tab', { name: /Checks/ })).toHaveAttribute('aria-controls', panelId);
+  });
+
+  it('labels the tabpanel by the active tab (aria-labelledby tracks the active tab)', () => {
+    const { rerender } = render(<LeftPanel {...baseProps} activeTab='resources' />);
+    const resourcesTabId = screen.getByRole('tab', { name: /Resources/ }).getAttribute('id');
+    expect(resourcesTabId).toBeTruthy();
+    expect(screen.getByRole('tabpanel')).toHaveAttribute('aria-labelledby', resourcesTabId);
+
+    rerender(<LeftPanel {...baseProps} activeTab='checks' />);
+    const checksTabId = screen.getByRole('tab', { name: /Checks/ }).getAttribute('id');
+    expect(checksTabId).toBeTruthy();
+    expect(screen.getByRole('tabpanel')).toHaveAttribute('aria-labelledby', checksTabId);
+  });
+
+  it('calls onTabChange when a tab is clicked', () => {
+    const onTabChange = vi.fn();
+    render(<LeftPanel {...baseProps} activeTab='resources' onTabChange={onTabChange} />);
+    fireEvent.click(screen.getByRole('tab', { name: /Checks/ }));
+    expect(onTabChange).toHaveBeenCalledWith('checks');
+  });
+
+  it('does not render the notification dot when there are no active findings', () => {
+    render(<LeftPanel {...baseProps} activeFindingsCount={0} />);
+    expect(screen.queryByTestId('checks-notification-dot')).not.toBeInTheDocument();
+  });
+
+  it('renders the dot (visible from the Resources tab) when active findings exist', () => {
+    render(<LeftPanel {...baseProps} activeFindingsCount={3} activeTab='resources' />);
+    expect(screen.getByTestId('checks-notification-dot')).toBeInTheDocument();
+  });
+
+  it('renders the dot on the Checks tab when active findings exist', () => {
+    render(<LeftPanel {...baseProps} activeFindingsCount={1} activeTab='checks' />);
+    expect(screen.getByTestId('checks-notification-dot')).toBeInTheDocument();
+  });
+
+  // --- showChecksTab (feature-flags proposal D6/D7) --------------------------
+  describe('showChecksTab', () => {
+    it('renders the Checks tab by default (prop omitted)', () => {
+      render(<LeftPanel {...baseProps} />);
+      expect(screen.getByRole('tab', { name: /Checks/ })).toBeInTheDocument();
+    });
+
+    it('hides the Checks tab entirely when showChecksTab is false', () => {
+      render(<LeftPanel {...baseProps} showChecksTab={false} />);
+      expect(screen.getByRole('tab', { name: /Resources/ })).toBeInTheDocument();
+      expect(screen.queryByRole('tab', { name: /Checks/ })).not.toBeInTheDocument();
+    });
+
+    it('suppresses the notification dot when the Checks tab is hidden', () => {
+      render(<LeftPanel {...baseProps} activeFindingsCount={5} showChecksTab={false} />);
+      expect(screen.queryByTestId('checks-notification-dot')).not.toBeInTheDocument();
+    });
+
+    it('falls back to the Resources body even if activeTab is checks while hidden', () => {
+      render(<LeftPanel {...baseProps} activeTab='checks' showChecksTab={false} />);
+      expect(screen.getByText('resources-body')).toBeInTheDocument();
+      expect(screen.queryByText('checks-body')).not.toBeInTheDocument();
+    });
+
+    it('labels the tabpanel by the Resources tab when the Checks tab is hidden', () => {
+      render(<LeftPanel {...baseProps} activeTab='checks' showChecksTab={false} />);
+      const resourcesTabId = screen.getByRole('tab', { name: /Resources/ }).getAttribute('id');
+      expect(resourcesTabId).toBeTruthy();
+      expect(screen.getByRole('tabpanel')).toHaveAttribute('aria-labelledby', resourcesTabId);
+    });
+  });
+});
diff --git a/src/features/checks/components/LeftPanel.tsx b/src/features/checks/components/LeftPanel.tsx
new file mode 100644
index 00000000..55e61d57
--- /dev/null
+++ b/src/features/checks/components/LeftPanel.tsx
@@ -0,0 +1,152 @@
+import { type ReactNode } from 'react';
+
+import { type LeftTab } from '@/features/bible/hooks/useResourceStatePersistence';
+import { cn } from '@/lib/utils';
+
+/**
+ * Which tab of the drafting-page left panel is showing (persisted, W11).
+ * Single source of truth lives in `useResourceStatePersistence`, where it is
+ * the editor-state `activeLeftTab` field; re-exported here so consumers of the
+ * panel's type surface can keep importing it from `LeftPanel`.
+ */
+export type { LeftTab };
+
+export interface LeftPanelProps {
+  /** Controlled active tab; lifted to `DraftingPage` so it can be persisted
+   *  in the editor-state blob as `activeLeftTab` (W11, §6.6). */
+  activeTab: LeftTab;
+  /** Called when the translator switches tabs; the parent persists the value. */
+  onTabChange: (tab: LeftTab) => void;
+  /** Cascade-resolved active-finding count (§6.4). The notification dot shows
+   *  iff this is > 0; the dot is visible from either tab. */
+  activeFindingsCount: number;
+  /** Body for the Resources tab (the existing `ResourcePanel`). */
+  resourcesContent: ReactNode;
+  /** Body for the Checks tab (the `ChecksPanel`, composed by the parent). */
+  checksContent: ReactNode;
+  /**
+   * Whether the "Checks" tab is shown at all. When the Repeated Word Check
+   * feature is disabled (feature-flags proposal D6/D7), the tab — and its
+   * notification dot — are hidden entirely so the panel looks as if Checks were
+   * never implemented. The parent (`DraftingUI`) is responsible for also forcing
+   * `activeTab` back to `'resources'` when this is false, so the shared panel
+   * never tries to render an absent tab's body. Defaults to true.
+   */
+  showChecksTab?: boolean;
+}
+
+/**
+ * Stable element ids wiring the tabs to the shared panel (W11, §6.6). The two
+ * tabs share a single body container; `aria-labelledby` on the panel points at
+ * whichever tab is currently active, so screen readers announce the panel's
+ * controlling tab. (CR-5: complete the ARIA tab/tabpanel relationship.)
+ */
+const TAB_IDS: Record<LeftTab, string> = {
+  resources: 'left-panel-tab-resources',
+  checks: 'left-panel-tab-checks',
+};
+const PANEL_ID = 'left-panel-tabpanel';
+
+interface TabButtonProps {
+  id: string;
+  label: string;
+  isActive: boolean;
+  onClick: () => void;
+  showDot?: boolean;
+}
+
+const TabButton: React.FC<TabButtonProps> = ({ id, label, isActive, onClick, showDot = false }) => (
+  <button
+    aria-controls={PANEL_ID}
+    aria-selected={isActive}
+    className={cn(
+      'flex items-center gap-1.5 border-b-2 px-1 pb-2 text-base font-semibold transition-colors',
+      isActive
+        ? 'border-blue-600 text-blue-600'
+        : 'text-muted-foreground hover:text-foreground border-transparent'
+    )}
+    id={id}
+    role='tab'
+    type='button'
+    onClick={onClick}
+  >
+    {label}
+    {showDot && (
+      <span
+        aria-label='Active checks present'
+        className='inline-block h-2 w-2 shrink-0 rounded-full bg-blue-600'
+        data-testid='checks-notification-dot'
+      />
+    )}
+  </button>
+);
+
+/**
+ * Tabbed left-panel container for the drafting page (W11, §6.6).
+ *
+ * Owns the text-tab header row ("Resources | Checks", blue underline on the
+ * active tab, a blue notification dot right of "Checks" when there are active
+ * findings) and renders the active tab's body below it. The dot's state comes
+ * from the cascade-resolved active count computed at `DraftingPage` level and
+ * threaded in via {@link LeftPanelProps.activeFindingsCount}, so it stays live
+ * while the Resources tab is showing.
+ *
+ * `ResourcePanel` lost its own "Resources" heading; this tab row is now the
+ * panel's header. The component is deliberately content-agnostic (slots for
+ * each tab body) so it can be unit-tested in isolation and so the real
+ * `ChecksPanel`/`ResourcePanel` are composed by the parent.
+ */
+export const LeftPanel: React.FC<LeftPanelProps> = ({
+  activeTab,
+  onTabChange,
+  activeFindingsCount,
+  resourcesContent,
+  checksContent,
+  showChecksTab = true,
+}) => {
+  const hasActiveFindings = activeFindingsCount > 0;
+  // When the Checks tab is hidden, the shared panel must never try to render the
+  // (absent) checks body. The parent forces `activeTab` back to 'resources', but
+  // we also guard here so this component is correct in isolation.
+  const effectiveTab: LeftTab = showChecksTab ? activeTab : 'resources';
+
+  return (
+    <div className='flex h-full flex-col'>
+      <div aria-label='Left panel' className='flex items-center gap-6 px-1 pt-4' role='tablist'>
+        <TabButton
+          id={TAB_IDS.resources}
+          isActive={effectiveTab === 'resources'}
+          label='Resources'
+          onClick={() => onTabChange('resources')}
+        />
+        {/* The notification dot sits to the right of the "Checks" label only,
+            and is visible whatever tab is active (mock shows it while the
+            Resources tab is active too) — §5.1, W11. The whole tab (and thus the
+            dot) is hidden when the Checks feature is disabled (feature-flags
+            proposal D6/D7), so it looks as if Checks were never implemented. */}
+        {showChecksTab && (
+          <TabButton
+            id={TAB_IDS.checks}
+            isActive={effectiveTab === 'checks'}
+            label='Checks'
+            showDot={hasActiveFindings}
+            onClick={() => onTabChange('checks')}
+          />
+        )}
+      </div>
+
+      {/* Single shared panel: `aria-labelledby` tracks the active tab so the
+          tab/tabpanel relationship is complete for assistive tech (CR-5). */}
+      <div
+        aria-labelledby={TAB_IDS[effectiveTab]}
+        className='min-h-0 flex-1'
+        id={PANEL_ID}
+        role='tabpanel'
+      >
+        {effectiveTab === 'resources' ? resourcesContent : checksContent}
+      </div>
+    </div>
+  );
+};
+
+export default LeftPanel;
diff --git a/src/features/checks/hooks/useRepeatedWordsCheck.test.ts b/src/features/checks/hooks/useRepeatedWordsCheck.test.ts
new file mode 100644
index 00000000..0aecc818
--- /dev/null
+++ b/src/features/checks/hooks/useRepeatedWordsCheck.test.ts
@@ -0,0 +1,343 @@
+import { createElement, type ReactNode } from 'react';
+
+import { QueryClientProvider } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { config } from '@/lib/config';
+import { type ProjectItem } from '@/lib/types';
+import { server } from '@/test/msw/server';
+import { createTestQueryClient, renderHook, waitFor } from '@/test/render';
+
+import { type RepeatedWordsResponse } from '../checks.types';
+
+import {
+  buildRepeatedWordsRequest,
+  buildSntId,
+  type CheckVerseInput,
+  useRepeatedWordsCheck,
+} from './useRepeatedWordsCheck';
+
+const CHECK_URL = `${config.api.url}/ai/tools/greek-room/repeated-words`;
+
+/**
+ * A QueryClientProvider wrapper pinned to one client for the test's lifetime,
+ * so a `rerender(...)` doesn't swap in a fresh client and reset the cache.
+ * (`@/test/render`'s `renderHook` is the raw Testing Library one — no providers.)
+ * This file is `.test.ts` (no JSX), so the element is built with `createElement`.
+ */
+const makeWrapper = () => {
+  const queryClient = createTestQueryClient();
+  return ({ children }: { children: ReactNode }) =>
+    createElement(QueryClientProvider, { client: queryClient }, children);
+};
+
+/** A ProjectItem with the fields the check reads; the rest are filler. */
+const makeProjectItem = (over: Partial<ProjectItem> = {}): ProjectItem => ({
+  chapterAssignmentId: 42,
+  projectId: 100,
+  projectName: 'Test Project',
+  projectUnitId: 7,
+  bibleId: 1,
+  bibleName: 'Test Bible',
+  // `targetLanguage` is the human display NAME; the check must send it as
+  // `lang_name`, NOT as `lang_code` (greek-room keys its legitimate-duplicate
+  // whitelist on the ISO code). See phase-04 manual smoke (BUG #2, 2026-06-23).
+  targetLanguage: 'Spanish',
+  // `targetLangCode` is the ISO 639-3 code the check must send as `lang_code`.
+  targetLangCode: 'spa',
+  bookId: 7,
+  // `book` is the human display name; the check must NOT use it for snt_id.
+  book: 'Judges',
+  chapterStatus: 'draft',
+  chapterNumber: 4,
+  totalVerses: 24,
+  completedVerses: 0,
+  submittedTime: null,
+  // `bookCode` is the USFM code the check builds snt_id from (W4).
+  bookCode: 'JDG',
+  sourceLangCode: 'eng',
+  ...over,
+});
+
+/** A completed-envelope response with the given findings count. */
+const makeResponse = (findingsCount = 0): RepeatedWordsResponse => ({
+  job_id: 'job-1',
+  tool: 'greek-room/repeated-words',
+  status: 'completed',
+  result: {
+    lang_code: 'spa',
+    provider: 'greek-room',
+    check: 'repeated-words',
+    findings: Array.from({ length: findingsCount }, (_, i) => ({
+      snt_id: 'JDG 4:3',
+      repeated_word: 'the the',
+      surf: 'the the',
+      start_position: i,
+      legitimate: false,
+      severity: 0.5,
+    })),
+    summary: { total_findings: findingsCount, legitimate_count: 0, verse_count: 1 },
+  },
+  error: null,
+  created_at: '2026-06-21T00:00:00Z',
+  completed_at: '2026-06-21T00:00:01Z',
+});
+
+/** Register a POST handler that captures the request body and returns a body. */
+const mockPost = (response: RepeatedWordsResponse = makeResponse(0), status = 200) => {
+  const calls: { count: number; lastBody: unknown } = { count: 0, lastBody: undefined };
+  server.use(
+    http.post(CHECK_URL, async ({ request }) => {
+      calls.count += 1;
+      calls.lastBody = await request.json();
+      return HttpResponse.json(response, { status });
+    })
+  );
+  return calls;
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Pure builders
+// ---------------------------------------------------------------------------
+
+describe('buildSntId', () => {
+  it('formats "{bookCode} {chapter}:{verse}" with the USFM book code', () => {
+    expect(buildSntId('JDG', 4, 3)).toBe('JDG 4:3');
+  });
+});
+
+describe('buildRepeatedWordsRequest', () => {
+  it('uses projectItem.bookCode (USFM) not projectItem.book for snt_id', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem(), [
+      { verseNumber: 3, content: 'the the cat' },
+    ]);
+    expect(request.verses[0].snt_id).toBe('JDG 4:3');
+  });
+
+  it('drops empty/whitespace-only verses', () => {
+    const verses: CheckVerseInput[] = [
+      { verseNumber: 1, content: '   ' },
+      { verseNumber: 2, content: '' },
+      { verseNumber: 3, content: 'real content' },
+    ];
+    const request = buildRepeatedWordsRequest(makeProjectItem(), verses);
+    expect(request.verses).toHaveLength(1);
+    expect(request.verses[0]).toEqual({ snt_id: 'JDG 4:3', text: 'real content' });
+  });
+
+  it('carries the snake_case project context (D8 wire shape)', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem(), [
+      { verseNumber: 3, content: 'x' },
+    ]);
+    expect(request).toMatchObject({
+      // lang_code is the ISO 639-3 CODE; lang_name is the human display NAME.
+      lang_code: 'spa',
+      lang_name: 'Spanish',
+      // project_id is sent as a STRING: fluent-ai declares it `str` (strict), so
+      // a numeric value is rejected 422 → 502. See the phase-04 manual smoke.
+      project_id: '7',
+      project_name: 'Test Project',
+    });
+  });
+
+  it('sends the ISO code as lang_code and the display name as lang_name (BUG #2 regression)', () => {
+    // Greek-room keys its legitimate-duplicate whitelist on the ISO 639-3 code
+    // (e.g. "eng" recognises "truly truly"); sending the display name ("English")
+    // silently disables legitimate-duplicate suppression. lang_code MUST be the
+    // code, lang_name the name. See phase-04 manual smoke (BUG #2, 2026-06-23).
+    const request = buildRepeatedWordsRequest(
+      makeProjectItem({ targetLanguage: 'English', targetLangCode: 'eng' }),
+      [{ verseNumber: 3, content: 'truly truly' }]
+    );
+    expect(request.lang_code).toBe('eng');
+    expect(request.lang_name).toBe('English');
+    // Guard against a regression that sends the name as the code.
+    expect(request.lang_code).not.toBe('English');
+  });
+
+  it('falls back to "<unknown>" when targetLangCode is empty (no crash)', () => {
+    // `targetLangCode` is a required `string` (BUG #3 made it non-optional so
+    // the compiler catches any ProjectItem constructor that omits it). The runtime
+    // fallback still degrades gracefully: an empty/whitespace code becomes
+    // "<unknown>" on the wire rather than producing undefined/empty.
+    const request = buildRepeatedWordsRequest(
+      makeProjectItem({ targetLanguage: 'English', targetLangCode: '' }),
+      [{ verseNumber: 3, content: 'truly truly' }]
+    );
+    // greek-room just won't match any legitimate whitelist for an unknown code.
+    expect(request.lang_code).toBe('<unknown>');
+    expect(request.lang_name).toBe('English');
+  });
+
+  it('sends project_id as a string (fluent-ai requires str, not int)', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem({ projectUnitId: 123 }), [
+      { verseNumber: 3, content: 'x' },
+    ]);
+    expect(typeof request.project_id).toBe('string');
+    expect(request.project_id).toBe('123');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+describe('useRepeatedWordsCheck — enabled gating', () => {
+  it('does not fire when disabled', async () => {
+    const calls = mockPost();
+    const { result } = renderHook(
+      () =>
+        useRepeatedWordsCheck({
+          projectItem: makeProjectItem(),
+          verses: [{ verseNumber: 3, content: 'the the' }],
+          saveCounter: 0,
+          enabled: false,
+        }),
+      { wrapper: makeWrapper() }
+    );
+    // A disabled query is `fetchStatus: 'idle'` — assert it stays there instead
+    // of sleeping on a fixed timer to "prove a negative" (W7). If the query
+    // ever fired, `fetchStatus` would flip to 'fetching' and this would fail.
+    await waitFor(() => expect(result.current.fetchStatus).toBe('idle'));
+    expect(result.current.isFetching).toBe(false);
+    expect(calls.count).toBe(0);
+  });
+
+  it('does not fire when no verse has content (even if enabled)', async () => {
+    const calls = mockPost();
+    const { result } = renderHook(
+      () =>
+        useRepeatedWordsCheck({
+          projectItem: makeProjectItem(),
+          verses: [{ verseNumber: 3, content: '   ' }],
+          saveCounter: 0,
+          enabled: true,
+        }),
+      { wrapper: makeWrapper() }
+    );
+    // With no verse content the query is disabled (`enabled && hasContent`), so
+    // it stays `fetchStatus: 'idle'` — assert that rather than a fixed sleep (W7).
+    await waitFor(() => expect(result.current.fetchStatus).toBe('idle'));
+    expect(result.current.isFetching).toBe(false);
+    expect(calls.count).toBe(0);
+  });
+
+  it('fires and returns the completed envelope when enabled with content', async () => {
+    const calls = mockPost(makeResponse(2));
+    const { result } = renderHook(
+      () =>
+        useRepeatedWordsCheck({
+          projectItem: makeProjectItem(),
+          verses: [{ verseNumber: 3, content: 'the the' }],
+          saveCounter: 0,
+          enabled: true,
+        }),
+      { wrapper: makeWrapper() }
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.status).toBe('completed');
+    expect(result.current.data?.result?.findings).toHaveLength(2);
+
+    // Assert the request body that actually went on the wire (W6): the hook
+    // must POST the snake_case D8 shape assembled by buildRepeatedWordsRequest
+    // — the ISO code as lang_code, the display name as lang_name, and the
+    // project id as a STRING (fluent-ai's strict `str`).
+    expect(calls.count).toBe(1);
+    expect(calls.lastBody).toMatchObject({
+      lang_code: 'spa',
+      lang_name: 'Spanish',
+      project_id: '7',
+      project_name: 'Test Project',
+      verses: [{ snt_id: 'JDG 4:3', text: 'the the' }],
+    });
+  });
+});
+
+describe('useRepeatedWordsCheck — saveCounter re-fires', () => {
+  it('re-runs the check when saveCounter changes', async () => {
+    const calls = mockPost(makeResponse(1));
+    const { result, rerender } = renderHook(
+      (saveCounter: number) =>
+        useRepeatedWordsCheck({
+          projectItem: makeProjectItem(),
+          verses: [{ verseNumber: 3, content: 'the the' }],
+          saveCounter,
+          enabled: true,
+        }),
+      { initialProps: 0, wrapper: makeWrapper() }
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(calls.count).toBe(1);
+
+    rerender(1);
+    await waitFor(() => expect(calls.count).toBe(2));
+  });
+});
+
+describe('useRepeatedWordsCheck — error handling', () => {
+  it('surfaces a non-2xx as query.isError (no retry)', async () => {
+    mockPost(makeResponse(0), 502);
+    const { result } = renderHook(
+      () =>
+        useRepeatedWordsCheck({
+          projectItem: makeProjectItem(),
+          verses: [{ verseNumber: 3, content: 'the the' }],
+          saveCounter: 0,
+          enabled: true,
+        }),
+      { wrapper: makeWrapper() }
+    );
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe('buildRepeatedWordsRequest — additional edge cases', () => {
+  it('sends only verses with non-empty content (mixed empty and non-empty)', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem(), [
+      { verseNumber: 1, content: 'real text' },
+      { verseNumber: 2, content: '' },
+      { verseNumber: 3, content: '   ' },
+      { verseNumber: 4, content: 'more text' },
+    ]);
+    expect(request.verses).toHaveLength(2);
+    expect(request.verses.map(v => v.snt_id)).toEqual(['JDG 4:1', 'JDG 4:4']);
+  });
+
+  it('sends an empty verses array when all content is blank', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem(), [
+      { verseNumber: 1, content: '' },
+      { verseNumber: 2, content: '   ' },
+    ]);
+    expect(request.verses).toHaveLength(0);
+  });
+
+  it('builds snt_id from chapterNumber on projectItem (not a hardcoded chapter)', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem({ chapterNumber: 12 }), [
+      { verseNumber: 5, content: 'text' },
+    ]);
+    expect(request.verses[0].snt_id).toBe('JDG 12:5');
+  });
+
+  it('uses whitespace-trimmed targetLangCode — empty after trim falls back to <unknown>', () => {
+    const request = buildRepeatedWordsRequest(makeProjectItem({ targetLangCode: '   ' }), [
+      { verseNumber: 1, content: 'text' },
+    ]);
+    expect(request.lang_code).toBe('<unknown>');
+  });
+
+  it('sends the TRIMMED code, not the padded value (a padded " spa " becomes "spa")', () => {
+    // greek-room keys its legitimate-duplicate whitelist on the EXACT code, so a
+    // padded code (" spa ") would match nothing and silently disable suppression
+    // (the BUG #2 failure mode). The guard must forward the trimmed value, not
+    // just use the trim to test truthiness. See phase-04 manual smoke (BUG #2).
+    const request = buildRepeatedWordsRequest(makeProjectItem({ targetLangCode: ' spa ' }), [
+      { verseNumber: 1, content: 'text' },
+    ]);
+    expect(request.lang_code).toBe('spa');
+  });
+});
diff --git a/src/features/checks/hooks/useRepeatedWordsCheck.ts b/src/features/checks/hooks/useRepeatedWordsCheck.ts
new file mode 100644
index 00000000..9c96881a
--- /dev/null
+++ b/src/features/checks/hooks/useRepeatedWordsCheck.ts
@@ -0,0 +1,177 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { config } from '@/lib/config';
+import { Logger } from '@/lib/services/logger';
+import { type ProjectItem } from '@/lib/types';
+
+import {
+  type RepeatedWordsRequest,
+  type RepeatedWordsResponse,
+  type VerseInput,
+} from '../checks.types';
+
+/**
+ * A drafted verse to feed into the check. `verseNumber` is the canonical verse
+ * number; `content` is what the translator currently sees (drafting state, not
+ * a refetch — what they see is what gets checked, per §6.2).
+ */
+export interface CheckVerseInput {
+  verseNumber: number;
+  content: string;
+}
+
+/**
+ * Build the verse identifier per **W4**: `"{bookCode} {chapter}:{verse}"` using
+ * the **USFM book code** (e.g. `"JDG 4:3"`).
+ *
+ * Implementation note (W4 resolved): `ProjectItem.bookCode` carries the USFM
+ * code, whereas `ProjectItem.book` is the human display name. The drafting
+ * page's editor-state persistence happens to store the display name under a key
+ * it (confusingly) also calls `bookCode`; we deliberately use the real USFM
+ * `projectItem.bookCode` here so `snt_id` matches the smoke-test convention.
+ */
+export const buildSntId = (bookCode: string, chapterNumber: number, verseNumber: number): string =>
+  `${bookCode} ${chapterNumber}:${verseNumber}`;
+
+/**
+ * Assemble the snake_case `RepeatedWordsRequest` (D8 shape) from the project
+ * context and the currently drafted verses. Only verses with non-empty content
+ * are sent.
+ */
+export const buildRepeatedWordsRequest = (
+  projectItem: ProjectItem,
+  verses: CheckVerseInput[]
+): RepeatedWordsRequest => {
+  const verseInputs: VerseInput[] = verses
+    .filter(v => v.content.trim() !== '')
+    .map(v => ({
+      snt_id: buildSntId(projectItem.bookCode, projectItem.chapterNumber, v.verseNumber),
+      text: v.content,
+    }));
+
+  // `lang_code` MUST be the ISO 639-3 code (e.g. "eng"): greek-room keys its
+  // legitimate-duplicate whitelist on the code, so sending the display name
+  // ("English") silently disables legitimate-duplicate suppression. `lang_name`
+  // carries the human name. See phase-04 manual smoke (BUG #2, 2026-06-23).
+  //
+  // Defensive fallback: if the API omits the code (undefined) OR sends it empty
+  // (fluent-api defaults a null ISO column to ""), send "<unknown>" rather than
+  // an empty/undefined value. greek-room simply won't match any legitimate
+  // whitelist for an unknown code (duplicates are still flagged) — a safe
+  // degradation that keeps the check running instead of crashing.
+  // The `?.` here is intentionally defensive against a RUNTIME value the TYPE
+  // says can't happen: `targetLangCode` is typed non-optional, but the API
+  // can still omit it. We keep the type non-optional (so genuinely missing
+  // usages elsewhere stay caught) and guard only at this trust boundary, hence
+  // the targeted disable of the "unnecessary optional chain" rule.
+  // Trim ONCE and forward the trimmed value: greek-room keys its
+  // legitimate-duplicate whitelist on the exact code, so a padded code
+  // (" spa ") must be normalized to "spa" before it goes on the wire — testing
+  // truthiness on a trimmed copy while forwarding the untrimmed original would
+  // silently disable suppression (the BUG #2 failure mode).
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive guard against an undefined runtime value the type does not model
+  const trimmedCode = projectItem.targetLangCode?.trim();
+  const langCode = trimmedCode ? trimmedCode : null;
+
+  return {
+    lang_code: langCode ?? '<unknown>',
+    lang_name: projectItem.targetLanguage,
+    // fluent-ai declares `project_id: str` (Pydantic v2, strict — it does NOT
+    // coerce an int to a str), so a numeric `projectUnitId` is rejected with a
+    // 422 that fluent-api surfaces as a 502. fluent-api's own schema is the
+    // tolerant side (accepts string | number); we are the compliant side and
+    // send the contract-correct string. See phase-04 manual smoke (2026-06-23).
+    project_id: String(projectItem.projectUnitId),
+    project_name: projectItem.projectName,
+    verses: verseInputs,
+  };
+};
+
+/** POST the request to the fluent-api proxy and return the full envelope (D9). */
+export const postRepeatedWordsCheck = async (
+  request: RepeatedWordsRequest
+): Promise<RepeatedWordsResponse> => {
+  const res = await fetch(`${config.api.url}/ai/tools/greek-room/repeated-words`, {
+    method: 'POST',
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(request),
+  });
+
+  if (!res.ok) {
+    // Include the HTTP status so a failed check is actionable in logs/telemetry
+    // (e.g. fluent-api maps a fluent-ai failure/unreachable to 502) rather than
+    // an opaque generic message (W5).
+    throw new Error(`Failed to run repeated-words check (HTTP ${res.status})`);
+  }
+
+  return (await res.json()) as RepeatedWordsResponse;
+};
+
+export interface UseRepeatedWordsCheckParams {
+  projectItem: ProjectItem;
+  /** All currently drafted verses of the chapter (content from drafting state). */
+  verses: CheckVerseInput[];
+  /**
+   * Increments on every successful verse auto-save; part of the query key so
+   * the check re-fires exactly on the auto-save event (W3, card #172).
+   */
+  saveCounter: number;
+  /**
+   * When false the query is disabled — read-only `/view` route, no verse has
+   * content, or any other gating the caller wants to apply (W10).
+   */
+  enabled?: boolean;
+}
+
+/**
+ * Chapter-wide Repeated Word Check query (W3/W4/W10).
+ *
+ * Keyed on `(chapterAssignmentId, saveCounter)` so it re-runs on each
+ * successful auto-save. Consumes the full `ToolJobResponse` envelope and
+ * branches on `status`:
+ *  - `completed` ⇒ the synchronous case today; findings are in `result`.
+ *  - `queued` / `running` ⇒ a future async tool; the shape is identical, so a
+ *    `refetchInterval` can be added later without reshaping callers (D3/D9).
+ *  - `failed` / `cancelled` ⇒ fluent-api surfaces these as HTTP 502 errors, so
+ *    they arrive here as `query.isError` (handled by the panel's inline error,
+ *    W9).
+ *
+ * Note on stale data: TanStack only retains the previous `data` on a refetch of
+ * the *same* query key. Because the key includes `saveCounter`, each auto-save
+ * is effectively a NEW key — so a failed re-check after a save leaves `data`
+ * `undefined`, not the prior findings. The panel handles this purely via
+ * `isError` (it does not rely on stale `data` surviving the error).
+ *
+ * Follows the fetch pattern in `features/bible/hooks/useBibleTarget.ts`.
+ */
+export const useRepeatedWordsCheck = ({
+  projectItem,
+  verses,
+  saveCounter,
+  enabled = true,
+}: UseRepeatedWordsCheckParams) => {
+  const hasContent = verses.some(v => v.content.trim() !== '');
+
+  return useQuery<RepeatedWordsResponse>({
+    queryKey: ['repeated-words', projectItem.chapterAssignmentId, saveCounter],
+    queryFn: async () => {
+      const request = buildRepeatedWordsRequest(projectItem, verses);
+      try {
+        return await postRepeatedWordsCheck(request);
+      } catch (error) {
+        Logger.logException(error, { context: 'Repeated-words check failed' });
+        throw error;
+      }
+    },
+    enabled: enabled && hasContent,
+    // No automatic retry: a failed check surfaces immediately as `isError` so
+    // the panel can render its inline error line (W9). (We do NOT rely on
+    // TanStack keeping stale `data` here — the `saveCounter` query key changes
+    // on each save, so the prior findings are not retained across a failed
+    // re-check; see the stale-data note in the docblock above.)
+    retry: false,
+  });
+};
diff --git a/src/features/checks/hooks/useResolvedFindings.test.ts b/src/features/checks/hooks/useResolvedFindings.test.ts
new file mode 100644
index 00000000..c6a31a04
--- /dev/null
+++ b/src/features/checks/hooks/useResolvedFindings.test.ts
@@ -0,0 +1,313 @@
+import { describe, expect, it } from 'vitest';
+
+import { type GlobalRules, type OccurrenceRules, type RepeatedWordsFinding } from '../checks.types';
+
+import { buildOccurrenceKey, normalizePair, resolveFindings } from './useResolvedFindings';
+
+/**
+ * Factory for a Greek Room finding with sensible defaults. `surf` defaults to a
+ * Title-cased echo of `repeated_word` to prove it is never used for comparison.
+ */
+const makeFinding = (over: Partial<RepeatedWordsFinding> = {}): RepeatedWordsFinding => ({
+  snt_id: 'JDG 4:3',
+  repeated_word: 'the the',
+  surf: 'The the',
+  start_position: 0,
+  legitimate: false,
+  severity: 0.5,
+  ...over,
+});
+
+const NO_OCCURRENCE: OccurrenceRules = {};
+const NO_GLOBAL: GlobalRules = {};
+
+describe('normalizePair', () => {
+  it('NFC-normalizes without case folding', () => {
+    // Decomposed "é" (e + combining acute) vs. composed "é".
+    const decomposed = 'cafe\u0301 cafe\u0301';
+    const composed = 'caf\u00e9 caf\u00e9';
+    expect(normalizePair(decomposed)).toBe(normalizePair(composed));
+    // Case is preserved (no folding).
+    expect(normalizePair('The The')).toBe('The The');
+    expect(normalizePair('The The')).not.toBe(normalizePair('the the'));
+  });
+});
+
+describe('buildOccurrenceKey', () => {
+  it('formats as "{snt_id}|{repeated_word}|{ordinal}" with NFC-normalized pair', () => {
+    expect(buildOccurrenceKey('JDG 4:3', 'the the', 0)).toBe('JDG 4:3|the the|0');
+  });
+
+  it('produces equal keys for composed/decomposed accent variants', () => {
+    const decomposed = buildOccurrenceKey('GEN 1:1', 'cafe\u0301 cafe\u0301', 1);
+    const composed = buildOccurrenceKey('GEN 1:1', 'caf\u00e9 caf\u00e9', 1);
+    expect(decomposed).toBe(composed);
+  });
+});
+
+describe('resolveFindings — Greek Room layer (layer 0)', () => {
+  it('suspicious findings are active', () => {
+    const result = resolveFindings([makeFinding({ legitimate: false })], NO_OCCURRENCE, NO_GLOBAL);
+    expect(result.active).toHaveLength(1);
+    expect(result.inactive).toHaveLength(0);
+  });
+
+  it('legitimate findings are inactive with reason "legitimate"', () => {
+    const result = resolveFindings([makeFinding({ legitimate: true })], NO_OCCURRENCE, NO_GLOBAL);
+    expect(result.active).toHaveLength(0);
+    expect(result.inactive).toHaveLength(1);
+    expect(result.inactive[0].inactiveReason).toBe('legitimate');
+  });
+});
+
+describe('resolveFindings — global layer (layer 1)', () => {
+  it('global suppress hides an otherwise-suspicious finding (reason "global")', () => {
+    const global: GlobalRules = { 'the the': 'suppress' };
+    const result = resolveFindings([makeFinding()], NO_OCCURRENCE, global);
+    expect(result.active).toHaveLength(0);
+    expect(result.inactive[0].inactiveReason).toBe('global');
+  });
+
+  it('global surface re-activates a Greek-Room-legitimate finding', () => {
+    const global: GlobalRules = { 'the the': 'surface' };
+    const result = resolveFindings([makeFinding({ legitimate: true })], NO_OCCURRENCE, global);
+    expect(result.active).toHaveLength(1);
+    expect(result.inactive).toHaveLength(0);
+  });
+
+  it('global rule matches via NFC normalization', () => {
+    // Stored rule composed; finding decomposed.
+    const global: GlobalRules = { [normalizePair('caf\u00e9 caf\u00e9')]: 'suppress' };
+    const finding = makeFinding({ repeated_word: 'cafe\u0301 cafe\u0301' });
+    const result = resolveFindings([finding], NO_OCCURRENCE, global);
+    expect(result.inactive).toHaveLength(1);
+    expect(result.inactive[0].inactiveReason).toBe('global');
+  });
+});
+
+describe('resolveFindings — occurrence layer (layer 2) precedence', () => {
+  it('occurrence suppress beats a silent global (reason "occurrence")', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'suppress' };
+    const result = resolveFindings([makeFinding()], occ, NO_GLOBAL);
+    expect(result.inactive[0].inactiveReason).toBe('occurrence');
+  });
+
+  it('occurrence surface overrides a global suppress (most specific wins)', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'surface' };
+    const global: GlobalRules = { 'the the': 'suppress' };
+    const result = resolveFindings([makeFinding()], occ, global);
+    expect(result.active).toHaveLength(1);
+    expect(result.inactive).toHaveLength(0);
+  });
+
+  it('occurrence suppress overrides a global surface (most specific wins)', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'suppress' };
+    const global: GlobalRules = { 'the the': 'surface' };
+    const result = resolveFindings([makeFinding({ legitimate: true })], occ, global);
+    expect(result.inactive[0].inactiveReason).toBe('occurrence');
+  });
+
+  it('occurrence surface overrides a Greek-Room-legitimate verdict', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'surface' };
+    const result = resolveFindings([makeFinding({ legitimate: true })], occ, NO_GLOBAL);
+    expect(result.active).toHaveLength(1);
+  });
+});
+
+describe('resolveFindings — full precedence matrix', () => {
+  // most-specific non-silent verdict wins; layer 0 is the Greek Room verdict.
+  interface Case {
+    occ?: 'suppress' | 'surface';
+    global?: 'suppress' | 'surface';
+    legitimate: boolean;
+    expectActive: boolean;
+    reason?: 'occurrence' | 'global' | 'legitimate';
+  }
+
+  const cases: Case[] = [
+    // occurrence dominates regardless of lower layers
+    {
+      occ: 'suppress',
+      global: 'surface',
+      legitimate: false,
+      expectActive: false,
+      reason: 'occurrence',
+    },
+    { occ: 'surface', global: 'suppress', legitimate: true, expectActive: true },
+    // global decides when occurrence is silent
+    { global: 'suppress', legitimate: false, expectActive: false, reason: 'global' },
+    { global: 'surface', legitimate: true, expectActive: true },
+    // greek room decides when both upper layers silent
+    { legitimate: true, expectActive: false, reason: 'legitimate' },
+    { legitimate: false, expectActive: true },
+  ];
+
+  it.each(cases)(
+    'occ=$occ global=$global legitimate=$legitimate -> active=$expectActive',
+    ({ occ, global, legitimate, expectActive, reason }: Case) => {
+      const occRules: OccurrenceRules = occ ? { 'JDG 4:3|the the|0': occ } : {};
+      const globalRules: GlobalRules = global ? { 'the the': global } : {};
+      const result = resolveFindings([makeFinding({ legitimate })], occRules, globalRules);
+
+      if (expectActive) {
+        expect(result.active).toHaveLength(1);
+        expect(result.inactive).toHaveLength(0);
+      } else {
+        expect(result.inactive).toHaveLength(1);
+        expect(result.inactive[0].inactiveReason).toBe(reason);
+      }
+    }
+  );
+});
+
+describe('resolveFindings — ordinal assignment', () => {
+  it('numbers same-pair findings in a verse by start_position (zero-based)', () => {
+    // Provided out of order; ordinals must follow start_position, not input order.
+    const findings = [
+      makeFinding({ start_position: 40 }),
+      makeFinding({ start_position: 10 }),
+      makeFinding({ start_position: 25 }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    const byStart = new Map([...result.active].map(r => [r.finding.start_position, r.ordinal]));
+    expect(byStart.get(10)).toBe(0);
+    expect(byStart.get(25)).toBe(1);
+    expect(byStart.get(40)).toBe(2);
+  });
+
+  it('keeps ordinals independent per repeated_word and per verse', () => {
+    const findings = [
+      makeFinding({ snt_id: 'JDG 4:3', repeated_word: 'the the', start_position: 5 }),
+      makeFinding({ snt_id: 'JDG 4:3', repeated_word: 'and and', start_position: 20 }),
+      makeFinding({ snt_id: 'JDG 4:4', repeated_word: 'the the', start_position: 0 }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    // Each is the first (ordinal 0) of its own (verse, pair) group.
+    expect(result.active.every(r => r.ordinal === 0)).toBe(true);
+    expect(result.active.map(r => r.occurrenceKey).sort()).toEqual(
+      ['JDG 4:3|and and|0', 'JDG 4:3|the the|0', 'JDG 4:4|the the|0'].sort()
+    );
+  });
+
+  it('handles the "the the the" overlap: two findings, ordinals 0 and 1', () => {
+    // A triple repetition yields two overlapping consecutive-pair findings.
+    const findings = [
+      makeFinding({ start_position: 0, surf: 'the the' }),
+      makeFinding({ start_position: 4, surf: 'the the' }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    const ordinals = result.active.map(r => r.ordinal).sort();
+    expect(ordinals).toEqual([0, 1]);
+    expect(result.active.map(r => r.occurrenceKey).sort()).toEqual(
+      ['JDG 4:3|the the|0', 'JDG 4:3|the the|1'].sort()
+    );
+  });
+
+  it('allows independently suppressing one occurrence of an overlap', () => {
+    const findings = [makeFinding({ start_position: 0 }), makeFinding({ start_position: 4 })];
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|1': 'suppress' };
+    const result = resolveFindings(findings, occ, NO_GLOBAL);
+    expect(result.active).toHaveLength(1);
+    expect(result.active[0].ordinal).toBe(0);
+    expect(result.inactive).toHaveLength(1);
+    expect(result.inactive[0].ordinal).toBe(1);
+    expect(result.inactive[0].inactiveReason).toBe('occurrence');
+  });
+});
+
+describe('resolveFindings — output shape', () => {
+  it('preserves the original finding reference and omits inactiveReason when active', () => {
+    const finding = makeFinding();
+    const result = resolveFindings([finding], NO_OCCURRENCE, NO_GLOBAL);
+    expect(result.active[0].finding).toBe(finding);
+    expect(result.active[0]).not.toHaveProperty('inactiveReason');
+    expect(result.active[0].occurrenceKey).toBe('JDG 4:3|the the|0');
+  });
+
+  it('returns empty buckets for no findings', () => {
+    const result = resolveFindings([], NO_OCCURRENCE, NO_GLOBAL);
+    expect(result.active).toEqual([]);
+    expect(result.inactive).toEqual([]);
+  });
+
+  it('puts inactiveReason on inactive findings', () => {
+    const result = resolveFindings([makeFinding({ legitimate: true })], NO_OCCURRENCE, NO_GLOBAL);
+    expect(result.inactive[0]).toHaveProperty('inactiveReason', 'legitimate');
+  });
+
+  it('includes occurrenceKey on inactive findings', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'suppress' };
+    const result = resolveFindings([makeFinding()], occ, NO_GLOBAL);
+    expect(result.inactive[0].occurrenceKey).toBe('JDG 4:3|the the|0');
+  });
+});
+
+describe('resolveFindings — multi-verse, multi-pair scenarios', () => {
+  it('handles findings from multiple verses independently', () => {
+    const occ: OccurrenceRules = { 'JDG 4:3|the the|0': 'suppress' };
+    const findings = [
+      makeFinding({ snt_id: 'JDG 4:3', repeated_word: 'the the' }),
+      makeFinding({ snt_id: 'JDG 4:4', repeated_word: 'the the' }),
+    ];
+    const result = resolveFindings(findings, occ, NO_GLOBAL);
+    // The JDG 4:3 occurrence is suppressed; JDG 4:4 one is not (it's a different verse).
+    expect(result.active).toHaveLength(1);
+    expect(result.active[0].finding.snt_id).toBe('JDG 4:4');
+    expect(result.inactive).toHaveLength(1);
+    expect(result.inactive[0].finding.snt_id).toBe('JDG 4:3');
+  });
+
+  it('handles multiple different pairs in the same verse', () => {
+    const global: GlobalRules = { 'and and': 'suppress' };
+    const findings = [
+      makeFinding({ repeated_word: 'the the' }),
+      makeFinding({ repeated_word: 'and and', start_position: 10 }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, global);
+    expect(result.active).toHaveLength(1);
+    expect(result.active[0].finding.repeated_word).toBe('the the');
+    expect(result.inactive).toHaveLength(1);
+    expect(result.inactive[0].finding.repeated_word).toBe('and and');
+    expect(result.inactive[0].inactiveReason).toBe('global');
+  });
+
+  it('preserves input order of findings in the output buckets', () => {
+    // Two findings, same pair and verse, out of order by start_position.
+    // Ordinals are assigned by start_position, but the output ordering
+    // reflects the *input* order (the caller's order is preserved).
+    const findings = [
+      makeFinding({ start_position: 40, surf: 'B the the' }),
+      makeFinding({ start_position: 10, surf: 'A the the' }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    // Both active; input order preserved (start_position:40 first, then 10).
+    expect(result.active[0].finding.surf).toBe('B the the');
+    expect(result.active[1].finding.surf).toBe('A the the');
+    // But ordinals follow start_position: start_position:10 is ordinal 0, 40 is ordinal 1.
+    expect(result.active[0].ordinal).toBe(1); // was start_position:40
+    expect(result.active[1].ordinal).toBe(0); // was start_position:10
+  });
+});
+
+describe('resolveFindings — occurrence key uniqueness', () => {
+  it('builds unique occurrence keys for same pair across different verses', () => {
+    const findings = [makeFinding({ snt_id: 'JDG 4:3' }), makeFinding({ snt_id: 'JDG 4:4' })];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    const keys = result.active.map(r => r.occurrenceKey);
+    expect(new Set(keys).size).toBe(2); // all unique
+    expect(keys).toContain('JDG 4:3|the the|0');
+    expect(keys).toContain('JDG 4:4|the the|0');
+  });
+
+  it('builds unique occurrence keys for different pairs in the same verse', () => {
+    const findings = [
+      makeFinding({ repeated_word: 'the the', start_position: 0 }),
+      makeFinding({ repeated_word: 'and and', start_position: 10 }),
+    ];
+    const result = resolveFindings(findings, NO_OCCURRENCE, NO_GLOBAL);
+    const keys = result.active.map(r => r.occurrenceKey);
+    expect(new Set(keys).size).toBe(2);
+    expect(keys).toContain('JDG 4:3|the the|0');
+    expect(keys).toContain('JDG 4:3|and and|0');
+  });
+});
diff --git a/src/features/checks/hooks/useResolvedFindings.ts b/src/features/checks/hooks/useResolvedFindings.ts
new file mode 100644
index 00000000..7108d5d3
--- /dev/null
+++ b/src/features/checks/hooks/useResolvedFindings.ts
@@ -0,0 +1,204 @@
+import { useMemo } from 'react';
+
+import {
+  type GlobalRules,
+  type InactiveReason,
+  type OccurrenceRules,
+  type RepeatedWordsFinding,
+  type ResolvedFinding,
+  type ResolvedFindings,
+  type RuleVerdict,
+} from '../checks.types';
+
+/**
+ * Pure three-layer suppression cascade (W5/W6, §6.4).
+ *
+ * Every finding resolves to active/inactive through three layers; the
+ * **most-specific non-silent verdict wins** (specificity, not temporal order,
+ * so the result is deterministic and reproducible from stored state):
+ *
+ *   | Layer | Scope                              | Verdicts                          |
+ *   | ----- | ---------------------------------- | --------------------------------- |
+ *   | 2     | occurrence (this chapter)          | silent / 'suppress' / 'surface'   |
+ *   | 1     | word pair (all the user's projects)| silent / 'suppress' / 'surface'   |
+ *   | 0     | Greek Room verdict (`legitimate`)  | active / inactive (always present)|
+ *
+ * Layer 2 (occurrence) is more specific than layer 1 (global), which is more
+ * specific than layer 0 (Greek Room). A `'surface'` rule at any layer forces
+ * the finding active (per-occurrence undo of a global rule or of a Greek Room
+ * `legitimate` verdict); a `'suppress'` rule forces it inactive; absence of a
+ * rule (silent) defers to the next-less-specific layer.
+ *
+ * This module is intentionally a pure function (wrapped in a memo hook) with no
+ * I/O — it is exhaustively unit-tested in `useResolvedFindings.test.ts`.
+ */
+
+/**
+ * NFC-normalize a string for comparison/keying. We normalize but deliberately
+ * do **not** case-fold: Unicode case folding is locale-sensitive (the Turkish
+ * dotless-ı problem) and Fluent targets minority languages. Greek Room already
+ * delivers `repeated_word` lowercased, so case equivalence is wholly its policy,
+ * inherited here rather than re-implemented (W4, §6.3).
+ */
+export const normalizePair = (repeatedWord: string): string => repeatedWord.normalize('NFC');
+
+/**
+ * Build the stable occurrence-identity key `"{snt_id}|{repeated_word}|{ordinal}"`.
+ * The `repeated_word` segment is NFC-normalized so a stored rule matches a fresh
+ * finding regardless of composed/decomposed accent representation (§7.1).
+ *
+ * The `|` separator is chosen because the two *outer* fields are provably
+ * pipe-free — `snt_id` is `"{bookCode} {chapter}:{verse}"` and `ordinal` is a
+ * number — so the key always splits into exactly three logical parts even if the
+ * verse-derived `repeated_word` itself were to contain a `|`. Consumers that need
+ * to recover the pair therefore slice the *middle* field (between the first and
+ * last `|`) rather than `split('|')[1]`; see `purgeLocalForPair` in
+ * `useSuppressions.ts`.
+ */
+export const buildOccurrenceKey = (sntId: string, repeatedWord: string, ordinal: number): string =>
+  `${sntId}|${normalizePair(repeatedWord)}|${ordinal}`;
+
+/**
+ * Assign each finding its ordinal: the index among findings in the **same
+ * verse** with the **same (NFC-normalized) `repeated_word`**, ordered by
+ * `start_position` ("x of n", zero-based). Computed from Greek Room's findings
+ * only — we never tokenize verse text ourselves (W4, §6.3).
+ *
+ * Caveat (§6.3): a triple repetition ("the the the") yields two overlapping
+ * findings, which receive ordinals 0 and 1. Mechanically fine; accepted for v1.
+ */
+const assignOrdinals = (
+  findings: RepeatedWordsFinding[]
+): Array<{ finding: RepeatedWordsFinding; ordinal: number }> => {
+  // Counter per (snt_id, normalized repeated_word). We must process each group
+  // in start_position order so ordinals are stable against unrelated edits.
+  const groups = new Map<string, RepeatedWordsFinding[]>();
+  for (const finding of findings) {
+    const groupKey = `${finding.snt_id}|${normalizePair(finding.repeated_word)}`;
+    const bucket = groups.get(groupKey);
+    if (bucket) {
+      bucket.push(finding);
+    } else {
+      groups.set(groupKey, [finding]);
+    }
+  }
+
+  // Map each finding (by reference identity) to its assigned ordinal.
+  const ordinalOf = new Map<RepeatedWordsFinding, number>();
+  for (const bucket of groups.values()) {
+    const ordered = [...bucket].sort((a, b) => a.start_position - b.start_position);
+    ordered.forEach((finding, index) => ordinalOf.set(finding, index));
+  }
+
+  // Preserve the caller's original finding order in the output.
+  return findings.map(finding => ({
+    finding,
+    ordinal: ordinalOf.get(finding) ?? 0,
+  }));
+};
+
+/**
+ * Resolve one finding through the cascade. Returns whether it is active and, if
+ * not, which layer suppressed it.
+ */
+/**
+ * Look up a verdict in a tri-state rule map. The map's value type is
+ * `RuleVerdict`, but a missing key yields `undefined` at runtime; this helper
+ * makes that `| undefined` explicit (the tsconfig has no `noUncheckedIndexed
+ * AccessProperty`, so a bare index access would over-narrow).
+ */
+const lookupVerdict = (
+  rules: OccurrenceRules | GlobalRules,
+  key: string
+): RuleVerdict | undefined => (key in rules ? rules[key] : undefined);
+
+const resolveOne = (
+  finding: RepeatedWordsFinding,
+  occurrenceKey: string,
+  occurrenceRules: OccurrenceRules,
+  globalRules: GlobalRules
+): { isActive: boolean; inactiveReason?: InactiveReason } => {
+  // Layer 2 — occurrence rule (most specific). A present verdict wins outright:
+  // 'suppress' => inactive (reason 'occurrence'); 'surface' => active.
+  const occurrenceVerdict = lookupVerdict(occurrenceRules, occurrenceKey);
+  if (occurrenceVerdict !== undefined) {
+    return occurrenceVerdict === 'suppress'
+      ? { isActive: false, inactiveReason: 'occurrence' }
+      : { isActive: true };
+  }
+
+  // Layer 1 — user-global word-pair rule.
+  const globalVerdict = lookupVerdict(globalRules, normalizePair(finding.repeated_word));
+  if (globalVerdict !== undefined) {
+    return globalVerdict === 'suppress'
+      ? { isActive: false, inactiveReason: 'global' }
+      : { isActive: true };
+  }
+
+  // Layer 0 — Greek Room verdict.
+  if (finding.legitimate) {
+    return { isActive: false, inactiveReason: 'legitimate' };
+  }
+  return { isActive: true };
+};
+
+/**
+ * Resolve a list of raw findings into `{ active[], inactive[] }` given the
+ * occurrence- and global-rule maps. Pure; safe to call outside React.
+ */
+export const resolveFindings = (
+  findings: RepeatedWordsFinding[],
+  occurrenceRules: OccurrenceRules,
+  globalRules: GlobalRules
+): ResolvedFindings => {
+  const withOrdinals = assignOrdinals(findings);
+
+  const active: ResolvedFinding[] = [];
+  const inactive: ResolvedFinding[] = [];
+
+  for (const { finding, ordinal } of withOrdinals) {
+    const occurrenceKey = buildOccurrenceKey(finding.snt_id, finding.repeated_word, ordinal);
+    const { isActive, inactiveReason } = resolveOne(
+      finding,
+      occurrenceKey,
+      occurrenceRules,
+      globalRules
+    );
+
+    const resolved: ResolvedFinding = {
+      finding,
+      ordinal,
+      occurrenceKey,
+      isActive,
+      ...(isActive ? {} : { inactiveReason }),
+    };
+
+    if (isActive) {
+      active.push(resolved);
+    } else {
+      inactive.push(resolved);
+    }
+  }
+
+  return { active, inactive };
+};
+
+export interface UseResolvedFindingsParams {
+  findings: RepeatedWordsFinding[];
+  occurrenceRules: OccurrenceRules;
+  globalRules: GlobalRules;
+}
+
+/**
+ * React hook wrapper around {@link resolveFindings}, memoized on its inputs.
+ * The notification dot counts `active.length`.
+ */
+export const useResolvedFindings = ({
+  findings,
+  occurrenceRules,
+  globalRules,
+}: UseResolvedFindingsParams): ResolvedFindings =>
+  useMemo(
+    () => resolveFindings(findings, occurrenceRules, globalRules),
+    [findings, occurrenceRules, globalRules]
+  );
diff --git a/src/features/checks/hooks/useSuppressions.test.ts b/src/features/checks/hooks/useSuppressions.test.ts
new file mode 100644
index 00000000..d15bf546
--- /dev/null
+++ b/src/features/checks/hooks/useSuppressions.test.ts
@@ -0,0 +1,629 @@
+import { http, HttpResponse } from 'msw';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { config } from '@/lib/config';
+import { server } from '@/test/msw/server';
+import { act, renderHook, waitFor } from '@/test/render';
+
+import { type OccurrenceRules, type ResolvedFinding } from '../checks.types';
+
+import {
+  deleteRule,
+  purgeLocalForPair,
+  setRule,
+  useSuppressions,
+  type UseSuppressionsParams,
+} from './useSuppressions';
+
+const SETTINGS_URL = `${config.api.url}/self/settings`;
+
+/** Register a GET /self/settings handler returning the given body + status. */
+const mockGet = (body: Record<string, unknown>, status = 200) => {
+  server.use(http.get(SETTINGS_URL, () => HttpResponse.json(body, { status })));
+};
+
+/** Register a PUT /self/settings handler; resolves the captured body. */
+const mockPut = (status = 200) => {
+  const captured: { body: unknown } = { body: undefined };
+  server.use(
+    http.put(SETTINGS_URL, async ({ request }) => {
+      captured.body = await request.json();
+      return HttpResponse.json({ settings: {}, updatedAt: null }, { status });
+    })
+  );
+  return captured;
+};
+
+/** Render the hook with an injected occurrence store we can assert against. */
+const setup = (
+  occurrenceRules: OccurrenceRules = {},
+  saveOccurrenceRules: UseSuppressionsParams['saveOccurrenceRules'] = vi.fn()
+) => {
+  const result = renderHook((props: UseSuppressionsParams) => useSuppressions(props), {
+    initialProps: { occurrenceRules, saveOccurrenceRules },
+  });
+  return { ...result, saveOccurrenceRules };
+};
+
+const makeResolved = (over: Partial<ResolvedFinding> = {}): ResolvedFinding => ({
+  finding: {
+    snt_id: 'JDG 4:3',
+    repeated_word: 'the the',
+    surf: 'the the',
+    start_position: 0,
+    legitimate: false,
+    severity: 0.5,
+  },
+  ordinal: 0,
+  occurrenceKey: 'JDG 4:3|the the|0',
+  isActive: false,
+  inactiveReason: 'occurrence',
+  ...over,
+});
+
+beforeEach(() => {
+  // Default: route present, empty settings, so probe resolves "available".
+  mockGet({ settings: null, updatedAt: null });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+describe('setRule / deleteRule', () => {
+  it('setRule returns a new map with the key set, leaving the original untouched', () => {
+    const original: OccurrenceRules = { a: 'suppress' };
+    const next = setRule(original, 'b', 'surface');
+    expect(next).toEqual({ a: 'suppress', b: 'surface' });
+    expect(original).toEqual({ a: 'suppress' });
+  });
+
+  it('deleteRule removes the key in a copy; no-op when absent', () => {
+    expect(deleteRule({ a: 'suppress', b: 'surface' }, 'a')).toEqual({ b: 'surface' });
+    expect(deleteRule({ a: 'suppress' }, 'missing')).toEqual({ a: 'suppress' });
+  });
+});
+
+describe('purgeLocalForPair', () => {
+  it('drops every occurrence rule whose pair segment matches (NFC), keeps others', () => {
+    const rules: OccurrenceRules = {
+      'JDG 4:3|the the|0': 'suppress',
+      'JDG 4:5|the the|0': 'surface',
+      'JDG 4:3|and and|0': 'suppress',
+    };
+    const { rules: next, changed } = purgeLocalForPair(rules, 'the the');
+    expect(changed).toBe(true);
+    expect(next).toEqual({ 'JDG 4:3|and and|0': 'suppress' });
+  });
+
+  it('matches composed vs decomposed accents', () => {
+    const rules: OccurrenceRules = { ['GEN 1:1|cafe\u0301 cafe\u0301|0']: 'suppress' };
+    const { rules: next, changed } = purgeLocalForPair(rules, 'caf\u00e9 caf\u00e9');
+    expect(changed).toBe(true);
+    expect(next).toEqual({});
+  });
+
+  it('returns the same instance + changed=false when nothing matches', () => {
+    const rules: OccurrenceRules = { 'JDG 4:3|and and|0': 'suppress' };
+    const out = purgeLocalForPair(rules, 'the the');
+    expect(out.changed).toBe(false);
+    expect(out.rules).toBe(rules);
+  });
+
+  it('CR-1 regression: purges a pair that itself contains the "|" delimiter', () => {
+    // The pair is the *middle* field; the outer fields (snt_id, ordinal) are
+    // pipe-free, so a "|" inside the repeated_word must not break matching.
+    // A naive split('|')[1] would read "a " and fail to purge this rule.
+    const rules: OccurrenceRules = {
+      'JDG 4:3|a | a|0': 'suppress',
+      'JDG 4:3|and and|0': 'suppress',
+    };
+    const { rules: next, changed } = purgeLocalForPair(rules, 'a | a');
+    expect(changed).toBe(true);
+    expect(next).toEqual({ 'JDG 4:3|and and|0': 'suppress' });
+  });
+
+  it('CR-1 regression: handles pairs with other awkward characters (quote, backslash)', () => {
+    const rules: OccurrenceRules = {
+      'GEN 1:1|a" a"|0': 'suppress',
+      'GEN 1:2|b\\ b\\|0': 'surface',
+    };
+    expect(purgeLocalForPair(rules, 'a" a"').rules).toEqual({ 'GEN 1:2|b\\ b\\|0': 'surface' });
+    expect(purgeLocalForPair(rules, 'b\\ b\\').rules).toEqual({ 'GEN 1:1|a" a"|0': 'suppress' });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Feature-detect probe (§9.1, W8)
+// ---------------------------------------------------------------------------
+
+describe('useSuppressions — feature-detect probe', () => {
+  it('200 with settings:null ⇒ available, empty global rules, probe resolved', async () => {
+    mockGet({ settings: null, updatedAt: null });
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(true);
+    expect(result.current.globalRules).toEqual({});
+  });
+
+  it('200 with rules ⇒ available and parses checkIgnoredWordPairs', async () => {
+    mockGet({
+      settings: { checkIgnoredWordPairs: { 'the the': 'suppress' } },
+      updatedAt: '2026-06-18T00:00:00Z',
+    });
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(true);
+    expect(result.current.globalRules).toEqual({ 'the the': 'suppress' });
+  });
+
+  it('404 ⇒ unavailable (route not deployed), probe still resolves', async () => {
+    mockGet({ message: 'Not Found' }, 404);
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(false);
+    expect(result.current.globalRules).toEqual({});
+  });
+
+  it('network failure ⇒ conservatively unavailable, probe resolves', async () => {
+    server.use(http.get(SETTINGS_URL, () => HttpResponse.error()));
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Occurrence actions (write through the single editor-state writer, §7.1)
+// ---------------------------------------------------------------------------
+
+describe('useSuppressions — occurrence actions', () => {
+  it('ignoreHere writes a "suppress" verdict for the key, preserving siblings', async () => {
+    const save = vi.fn();
+    const { result } = setup({ 'JDG 4:3|and and|0': 'suppress' }, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreHere('JDG 4:3|the the|0'));
+    expect(save).toHaveBeenCalledWith({
+      'JDG 4:3|and and|0': 'suppress',
+      'JDG 4:3|the the|0': 'suppress',
+    });
+  });
+
+  it('BUG #3 regression: ignoreHere DELETES a "surface" override instead of stacking "suppress"', async () => {
+    // Scenario: a legitimate finding was surfaced (undo), then the user clicks
+    // Ignore Here again. The 'surface' override should be removed so the finding
+    // falls back to the lower-layer verdict (legitimate), not overwritten with
+    // 'suppress' which would change the inactiveReason and require two undos.
+    const save = vi.fn();
+    const { result } = setup({ 'JDG 4:3|the the|0': 'surface' }, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreHere('JDG 4:3|the the|0'));
+    // Should delete the 'surface' key, not write 'suppress' over it.
+    expect(save).toHaveBeenCalledWith({});
+  });
+
+  it('undoOccurrence DELETES the rule when the finding is hidden by its own occurrence rule', async () => {
+    const save = vi.fn();
+    const { result } = setup({ 'JDG 4:3|the the|0': 'suppress' }, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.undoOccurrence(makeResolved({ inactiveReason: 'occurrence' })));
+    expect(save).toHaveBeenCalledWith({});
+  });
+
+  it('undoOccurrence writes "surface" when the finding is hidden by a GLOBAL rule', async () => {
+    const save = vi.fn();
+    const { result } = setup({}, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.undoOccurrence(makeResolved({ inactiveReason: 'global' })));
+    expect(save).toHaveBeenCalledWith({ 'JDG 4:3|the the|0': 'surface' });
+  });
+
+  it('undoOccurrence writes "surface" when the finding is hidden by Greek Room (legitimate)', async () => {
+    const save = vi.fn();
+    const { result } = setup({}, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.undoOccurrence(makeResolved({ inactiveReason: 'legitimate' })));
+    expect(save).toHaveBeenCalledWith({ 'JDG 4:3|the the|0': 'surface' });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Global actions (optimistic + rollback; purge current-chapter local, §6.5/§9.3)
+// ---------------------------------------------------------------------------
+
+describe('useSuppressions — global actions', () => {
+  it('ignoreEverywhere optimistically suppresses, PUTs the full blob, and purges current-chapter occurrence rules for the pair', async () => {
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    const put = mockPut();
+    const save = vi.fn();
+    const { result } = setup(
+      { 'JDG 4:3|the the|0': 'suppress', 'JDG 4:3|and and|0': 'suppress' },
+      save
+    );
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreEverywhere('the the'));
+
+    // Optimistic: the global map updates immediately.
+    expect(result.current.globalRules).toEqual({ 'the the': 'suppress' });
+    // Purge-local: the current-chapter occurrence rule for "the the" is dropped,
+    // the unrelated "and and" rule stands.
+    expect(save).toHaveBeenCalledWith({ 'JDG 4:3|and and|0': 'suppress' });
+    // Full-replace PUT carries the whole blob under settings.checkIgnoredWordPairs.
+    await waitFor(() =>
+      expect(put.body).toEqual({ settings: { checkIgnoredWordPairs: { 'the the': 'suppress' } } })
+    );
+  });
+
+  it('ignoreEverywhere rolls back the optimistic update on PUT failure', async () => {
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    mockPut(500);
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreEverywhere('the the'));
+    // Briefly optimistic, then reverts to the prior (empty) state.
+    await waitFor(() => expect(result.current.globalRules).toEqual({}));
+  });
+
+  it('CR-7 regression: a failed global PUT restores the optimistically-purged occurrence rules', async () => {
+    // The optimistic global write purges the current-chapter occurrence rules for
+    // the pair (a *persisted* write through saveOccurrenceRules). If the PUT then
+    // fails, the global flag rolls back — and so must the occurrence map, or the
+    // user's per-occurrence ignores for that pair would be permanently lost.
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    mockPut(500);
+    const save = vi.fn();
+    const original: OccurrenceRules = {
+      'JDG 4:3|the the|0': 'suppress',
+      'JDG 4:3|and and|0': 'suppress',
+    };
+    const { result } = setup(original, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreEverywhere('the the'));
+
+    // First call is the optimistic purge (the "the the" occurrence rule dropped).
+    expect(save).toHaveBeenNthCalledWith(1, { 'JDG 4:3|and and|0': 'suppress' });
+    // After the PUT 500, the catch restores the full pre-purge occurrence map.
+    await waitFor(() => expect(save).toHaveBeenCalledTimes(2));
+    expect(save).toHaveBeenNthCalledWith(2, original);
+    // Global map also rolled back to its prior (empty) state.
+    expect(result.current.globalRules).toEqual({});
+  });
+
+  it('NEW-C: rollback merges back only the purged keys, preserving a later unrelated occurrence edit', async () => {
+    // Regression for CR thread 3488525698. The old rollback restored the WHOLE
+    // call-time occurrence snapshot, which would wipe any occurrence edit the user
+    // made while the global PUT was in flight. We now merge back only the keys the
+    // optimistic purge removed, into the *current* map — so an unrelated edit that
+    // landed in the meantime survives the rollback.
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    mockPut(500);
+    const save = vi.fn();
+    const original: OccurrenceRules = { 'JDG 4:3|the the|0': 'suppress' };
+    const { result, rerender } = setup(original, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    // Global "Ignore Everywhere" for "the the": optimistically purges that key.
+    act(() => result.current.ignoreEverywhere('the the'));
+    expect(save).toHaveBeenNthCalledWith(1, {});
+
+    // While the PUT is in flight, an unrelated occurrence edit lands (e.g. the
+    // user clicks "Ignore Here" on a different finding). Simulate the new map
+    // flowing back in through the prop (the single editor-state writer).
+    const afterEdit: OccurrenceRules = { 'JDG 4:5|and and|0': 'suppress' };
+    rerender({ occurrenceRules: afterEdit, saveOccurrenceRules: save });
+
+    // PUT 500 → rollback merges ONLY the purged "the the" key back into the
+    // current map, keeping the unrelated "and and" edit intact (not overwritten
+    // by the stale pre-purge snapshot).
+    await waitFor(() => expect(save).toHaveBeenCalledTimes(2));
+    expect(save).toHaveBeenNthCalledWith(2, {
+      'JDG 4:5|and and|0': 'suppress',
+      'JDG 4:3|the the|0': 'suppress',
+    });
+    expect(result.current.globalRules).toEqual({});
+  });
+
+  it('single-key full-replace: the PUT body carries only checkIgnoredWordPairs (no client-side sibling echo)', async () => {
+    // The blob is single-key today; the client sends only the key it owns and the
+    // server full-replaces (the API write schema strips unknown keys, so a second
+    // setting cannot exist without a server-schema change that must add server-side
+    // merge — see the API implementation note). Even if GET happens to return an
+    // unknown sibling, the client must NOT echo it back: it sends only
+    // checkIgnoredWordPairs.
+    mockGet({
+      settings: { checkIgnoredWordPairs: {}, someOtherFeatureSetting: { enabled: true } },
+      updatedAt: null,
+    });
+    const put = mockPut();
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreEverywhere('the the'));
+
+    await waitFor(() =>
+      expect(put.body).toEqual({
+        settings: { checkIgnoredWordPairs: { 'the the': 'suppress' } },
+      })
+    );
+  });
+
+  it('stopIgnoringEverywhere deletes the global entry and PUTs the reduced blob', async () => {
+    mockGet({
+      settings: { checkIgnoredWordPairs: { 'the the': 'suppress', 'and and': 'suppress' } },
+      updatedAt: null,
+    });
+    const put = mockPut();
+    const { result } = setup({}, vi.fn());
+    await waitFor(() =>
+      expect(result.current.globalRules).toEqual({ 'the the': 'suppress', 'and and': 'suppress' })
+    );
+
+    act(() => result.current.stopIgnoringEverywhere('the the'));
+    expect(result.current.globalRules).toEqual({ 'and and': 'suppress' });
+    await waitFor(() =>
+      expect(put.body).toEqual({
+        settings: { checkIgnoredWordPairs: { 'and and': 'suppress' } },
+      })
+    );
+  });
+
+  it('BUG #4 regression: stopIgnoringEverywhere writes "surface" when no global suppress exists (e.g. legitimate-only finding)', async () => {
+    // Scenario: a finding is only suppressed by Greek Room legitimate (no global
+    // rule). The chevron "Stop ignoring everywhere" should write a global 'surface'
+    // to override the legitimate verdict for this pair across all projects.
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    const put = mockPut();
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.stopIgnoringEverywhere('truly truly'));
+    expect(result.current.globalRules).toEqual({ 'truly truly': 'surface' });
+    await waitFor(() =>
+      expect(put.body).toEqual({
+        settings: { checkIgnoredWordPairs: { 'truly truly': 'surface' } },
+      })
+    );
+  });
+
+  it('ignoreEverywhere DELETES a "surface" global override instead of stacking "suppress" (toggle principle)', async () => {
+    // Scenario: a pair was previously globally surfaced (e.g. to override
+    // legitimate). Clicking "Ignore Everywhere" should just remove the 'surface'
+    // override, letting the lower layer (legitimate) re-suppress naturally.
+    mockGet({
+      settings: { checkIgnoredWordPairs: { 'truly truly': 'surface' } },
+      updatedAt: null,
+    });
+    const put = mockPut();
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.globalRules).toEqual({ 'truly truly': 'surface' }));
+
+    act(() => result.current.ignoreEverywhere('truly truly'));
+    expect(result.current.globalRules).toEqual({});
+    await waitFor(() =>
+      expect(put.body).toEqual({
+        settings: { checkIgnoredWordPairs: {} },
+      })
+    );
+  });
+
+  it('stopIgnoringEverywhere rolls back on PUT failure', async () => {
+    mockGet({
+      settings: { checkIgnoredWordPairs: { 'the the': 'suppress' } },
+      updatedAt: null,
+    });
+    mockPut(500);
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.globalRules).toEqual({ 'the the': 'suppress' }));
+
+    act(() => result.current.stopIgnoringEverywhere('the the'));
+    // Optimistically removed, then rolls back on 500.
+    await waitFor(() => expect(result.current.globalRules).toEqual({ 'the the': 'suppress' }));
+  });
+
+  it('CR-1 regression: ignoreEverywhere purges a current-chapter rule whose pair contains "|"', async () => {
+    // End-to-end through the real purge path (purgeCurrentChapter → purgeLocalForPair).
+    // The occurrence key for a pipe-containing pair must still be purged on a
+    // global "Ignore Everywhere"; otherwise the just-clicked panel keeps a stale
+    // occurrence rule (occurrence beats global) for that pair.
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    mockPut();
+    const save = vi.fn();
+    const { result } = setup(
+      { 'JDG 4:3|a | a|0': 'suppress', 'JDG 4:3|and and|0': 'suppress' },
+      save
+    );
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    act(() => result.current.ignoreEverywhere('a | a'));
+    // Only the pipe-containing rule is purged; the unrelated one stands.
+    expect(save).toHaveBeenCalledWith({ 'JDG 4:3|and and|0': 'suppress' });
+  });
+
+  it('CR-15 follow-up: serializes overlapping global writes so PUTs reach the server in UI-action order', async () => {
+    // Two quick global toggles must not race on the server. Each full-replace PUT
+    // is chained after the previous one settles, so the second PUT does not even
+    // start until the first has finished — guaranteeing the persisted blob ends in
+    // the same order as the user actions (an older PUT can't land after a newer
+    // one). We prove this by making the FIRST PUT hang until we release it: while
+    // it is in flight the second PUT must NOT have started; after release, both
+    // arrive in order.
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+
+    const order: Array<Record<string, unknown>> = [];
+    let releaseFirst!: () => void;
+    const firstReleased = new Promise<void>(resolve => {
+      releaseFirst = resolve;
+    });
+    let putCount = 0;
+    server.use(
+      http.put(SETTINGS_URL, async ({ request }) => {
+        const body = (await request.json()) as Record<string, unknown>;
+        putCount += 1;
+        if (putCount === 1) {
+          // Hold the first write open until the test releases it.
+          await firstReleased;
+        }
+        order.push(body);
+        return HttpResponse.json({ settings: {}, updatedAt: null }, { status: 200 });
+      })
+    );
+
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    // First global toggle — its PUT starts and hangs (held open above).
+    act(() => result.current.ignoreEverywhere('aaa'));
+    await waitFor(() => expect(putCount).toBe(1));
+
+    // Second global toggle while the first PUT is still in flight. Its PUT is
+    // chained behind the first and must NOT have started yet (serialized — not
+    // fired concurrently). The optimistic state already reflects both.
+    act(() => result.current.ignoreEverywhere('bbb'));
+    expect(result.current.globalRules).toEqual({ aaa: 'suppress', bbb: 'suppress' });
+    // Still only one PUT in flight; the second is queued behind it.
+    expect(putCount).toBe(1);
+    expect(order).toHaveLength(0); // first hasn't completed, second hasn't started
+
+    // Release the first; now the second proceeds. Both complete in order A→B.
+    releaseFirst();
+    await waitFor(() => expect(order).toHaveLength(2));
+    expect(order[0]).toEqual({ settings: { checkIgnoredWordPairs: { aaa: 'suppress' } } });
+    // Second carries BOTH toggles (state accumulated), proving B persisted last.
+    expect(order[1]).toEqual({
+      settings: { checkIgnoredWordPairs: { aaa: 'suppress', bbb: 'suppress' } },
+    });
+  });
+
+  it('NEW-C: a queued write rolls back to the last COMMITTED baseline, not a call-time snapshot holding an earlier unconfirmed write', async () => {
+    // Regression for CR thread 3488525698 (the half our serialization surfaced).
+    // Writes are serialized: A then B. B is issued while A is still optimistic but
+    // unconfirmed, so B's call-time `previous` already contains A's change. If A
+    // FAILS and B also FAILS, the seq-guard lets B (the latest) roll back. Rolling
+    // back to B's call-time snapshot would resurrect A's never-persisted state;
+    // we instead roll back to the last *server-confirmed* baseline (here: empty).
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+
+    let releaseFirst!: () => void;
+    const firstReleased = new Promise<void>(resolve => {
+      releaseFirst = resolve;
+    });
+    let putCount = 0;
+    server.use(
+      http.put(SETTINGS_URL, async () => {
+        putCount += 1;
+        if (putCount === 1) {
+          await firstReleased;
+        }
+        // Both writes fail — neither ever commits, so the confirmed baseline stays empty.
+        return HttpResponse.json({ message: 'boom' }, { status: 500 });
+      })
+    );
+
+    const { result } = setup({}, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    // Write A: optimistic {aaa}; its PUT starts and hangs (held open).
+    act(() => result.current.ignoreEverywhere('aaa'));
+    await waitFor(() => expect(putCount).toBe(1));
+
+    // Write B while A is unconfirmed: B's call-time `previous` is {aaa} (A's
+    // optimistic state). Optimistic now shows both.
+    act(() => result.current.ignoreEverywhere('bbb'));
+    expect(result.current.globalRules).toEqual({ aaa: 'suppress', bbb: 'suppress' });
+
+    // Release A (fails), then B runs (also fails). Only B rolls back (latest seq).
+    releaseFirst();
+    await waitFor(() => expect(putCount).toBe(2));
+
+    // B rolls back to the last COMMITTED baseline (empty), NOT to {aaa} — A's
+    // change was never persisted, so it must not survive as a phantom.
+    await waitFor(() => expect(result.current.globalRules).toEqual({}));
+  });
+
+  it('purge-local runs for NFC-composed vs decomposed pair in occurrence key', async () => {
+    // The occurrence key stores the NFC-normalized pair; global write purges by
+    // normalizing the repeated_word. Composed "caf\u00e9" must purge a key that
+    // stores the decomposed form "cafe\u0301" (or vice versa).
+    mockGet({ settings: { checkIgnoredWordPairs: {} }, updatedAt: null });
+    mockPut();
+    const save = vi.fn();
+    const decomposedKey = 'GEN 1:1|cafe\u0301 cafe\u0301|0';
+    const { result } = setup({ [decomposedKey]: 'suppress' }, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    // ignoreEverywhere with the composed form — should purge the decomposed occurrence rule.
+    act(() => result.current.ignoreEverywhere('caf\u00e9 caf\u00e9'));
+    // The save callback should have been called with an empty map (decomposed key purged).
+    expect(save).toHaveBeenCalledWith({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Occurrence rules propagation
+// ---------------------------------------------------------------------------
+
+describe('useSuppressions — occurrence rules propagation', () => {
+  it('passes through the injected occurrenceRules unchanged in the returned value', async () => {
+    const rules: OccurrenceRules = {
+      'JDG 4:3|the the|0': 'suppress',
+      'JDG 4:5|and and|0': 'surface',
+    };
+    const { result } = setup(rules, vi.fn());
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.occurrenceRules).toEqual(rules);
+  });
+
+  it('updates the occurrenceRules reference when the prop changes (via rerender)', async () => {
+    const save = vi.fn();
+    const { result, rerender } = setup({}, save);
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+
+    const newRules: OccurrenceRules = { 'JDG 4:1|the the|0': 'suppress' };
+    rerender({ occurrenceRules: newRules, saveOccurrenceRules: save });
+    expect(result.current.occurrenceRules).toEqual(newRules);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// settingsProbeResolved timing
+// ---------------------------------------------------------------------------
+
+describe('useSuppressions — settingsProbeResolved gates the check query', () => {
+  it('starts false before the probe returns', () => {
+    // The beforeEach sets up a default GET handler; the probe resolves
+    // asynchronously, so at the very start it must be false.
+    const { result } = setup();
+    expect(result.current.settingsProbeResolved).toBe(false);
+  });
+
+  it('becomes true after a 200 response', async () => {
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+  });
+
+  it('becomes true even after a 404 (unavailable but resolved)', async () => {
+    mockGet({ message: 'Not Found' }, 404);
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(false);
+  });
+
+  it('becomes true even after a non-404 server error (conservatively unavailable)', async () => {
+    mockGet({}, 503);
+    const { result } = setup();
+    await waitFor(() => expect(result.current.settingsProbeResolved).toBe(true));
+    expect(result.current.globalIgnoresAvailable).toBe(false);
+  });
+});
diff --git a/src/features/checks/hooks/useSuppressions.ts b/src/features/checks/hooks/useSuppressions.ts
new file mode 100644
index 00000000..37594cd1
--- /dev/null
+++ b/src/features/checks/hooks/useSuppressions.ts
@@ -0,0 +1,533 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { config } from '@/lib/config';
+import { Logger } from '@/lib/services/logger';
+
+import {
+  type GlobalRules,
+  type OccurrenceRules,
+  type ResolvedFinding,
+  type RuleVerdict,
+} from '../checks.types';
+
+import { normalizePair } from './useResolvedFindings';
+
+/**
+ * `useSuppressions` — owns the read/write of the two suppression stores that
+ * feed the cascade in `useResolvedFindings` (Repeated Word Check, phase 2;
+ * proposal §6.5, §7, §9.1, §9.3, W6/W8).
+ *
+ * Two stores, two scopes:
+ *
+ *  - **Occurrence rules** (cascade layer 2) live in the editor-state JSONB blob
+ *    (`checkOccurrenceRules`), scoped to one `(user, chapterAssignment)`. There
+ *    is **one writer** for that blob — `useResourceStatePersistence`'s save
+ *    mutation — so this hook does not open a second PUT path. The page injects
+ *    the current map plus a single `saveOccurrenceRules` callback; this hook
+ *    does the read-modify-write and hands the merged map back through it (§7.1,
+ *    "one writer for the editor-state blob").
+ *
+ *  - **Global word-pair rules** (cascade layer 1) live in
+ *    `user_settings.checkIgnoredWordPairs` behind `GET/PUT /self/settings`. This
+ *    hook owns that half end to end: the once-per-session feature-detect probe
+ *    (§9.1), optimistic writes with rollback (§9.3), and the full-replace PUT
+ *    (§8.1).
+ *
+ * The action callbacks (`ignoreHere`, `ignoreEverywhere`, `undoOccurrence`,
+ * `stopIgnoringEverywhere`) are what `FindingRow` (phase 3) calls. The confirm
+ * dialog for "Ignore Everywhere" lives in the UI (phase 3); it calls
+ * `ignoreEverywhere` only on confirm.
+ */
+
+// ---------------------------------------------------------------------------
+// /self/settings wire shape (Fluent-domain → camelCase, conventions §B).
+// ---------------------------------------------------------------------------
+
+/**
+ * The user-settings blob behind `/self/settings`. Tolerant of absent keys.
+ *
+ * Single-key today: `checkIgnoredWordPairs` is the only setting in the blob, so
+ * the PUT is a full-replace of the whole JSONB blob (§8.1; the API `upsert`
+ * replaces `settings` wholesale with no server-side merge) and the client simply
+ * sends the one key it owns. The API write schema strips unknown keys, so a
+ * second setting cannot be introduced without editing the server schema — at
+ * which point the server is responsible for read-merging keys (the API carries an
+ * implementation note gating that). We therefore deliberately do NOT cache/echo a
+ * client-side snapshot of sibling keys here. This stays on the camelCase
+ * `/self/settings` boundary, NOT the snake_case greek-room pass-through (see
+ * checks.types.ts:1-19).
+ */
+interface SelfSettings {
+  /** Global word-pair rules, keyed by NFC-normalized `repeated_word`. */
+  checkIgnoredWordPairs?: GlobalRules;
+}
+
+/**
+ * GET response shape. The API returns `{ settings, updatedAt }` (see
+ * fluent-api `self-settings.service.ts` `toResponse`), where `settings` is
+ * `null` when the user has no row yet (W8). The client only reads `settings`
+ * — `updatedAt` is modeled here for contract fidelity (the doc §8.1 lists it)
+ * but is deliberately ignored: there is no optimistic-concurrency / ETag path
+ * in v1 (§8.3), so the timestamp has no consumer. Kept optional so an older
+ * deployment that omits it still parses.
+ */
+interface SelfSettingsResponse {
+  settings: SelfSettings | null;
+  /** Server-side last-write timestamp (ISO string) or `null`. Unused by the
+   * client today; present only to match the wire contract. */
+  updatedAt?: string | null;
+}
+
+const SELF_SETTINGS_URL = `${config.api.url}/self/settings`;
+
+/**
+ * Result of the once-per-session probe. `available` distinguishes "the route
+ * exists" (any 2xx, including `settings: null`) from "not deployed / network
+ * down" (404 or failure) so phase 3 can hide the global-ignore controls
+ * without ever rendering a dead button (W8).
+ */
+interface ProbeResult {
+  available: boolean;
+  rules: GlobalRules;
+}
+
+/** Pull the global rules out of a settings blob, tolerating any odd shape. */
+const extractGlobalRules = (settings: SelfSettings | null): GlobalRules => {
+  const pairs = settings?.checkIgnoredWordPairs;
+  if (pairs && typeof pairs === 'object') {
+    return pairs as GlobalRules;
+  }
+  return {};
+};
+
+/**
+ * Probe `GET /self/settings` once. Any 2xx ⇒ available (parse rules, tolerate
+ * `null`); 404 ⇒ route not deployed yet ⇒ unavailable; network/parse failure ⇒
+ * conservatively unavailable for the session. Never throws.
+ */
+const probeSelfSettings = async (): Promise<ProbeResult> => {
+  try {
+    const res = await fetch(SELF_SETTINGS_URL, {
+      method: 'GET',
+      credentials: 'include',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (res.status === 404) {
+      return { available: false, rules: {} };
+    }
+    if (!res.ok) {
+      // Other non-2xx (401/500/…): treat as unavailable for the session.
+      return { available: false, rules: {} };
+    }
+    const body = (await res.json()) as SelfSettingsResponse | null;
+    const settings = body?.settings ?? null;
+    return {
+      available: true,
+      rules: extractGlobalRules(settings),
+    };
+  } catch (error) {
+    Logger.logException(error, { context: 'Repeated-words self/settings probe failed' });
+    return { available: false, rules: {} };
+  }
+};
+
+/**
+ * PUT the settings blob (full-replace, §8.1). The blob is single-key today
+ * (`checkIgnoredWordPairs`), so the caller supplies the complete map it wants
+ * persisted and we send the whole blob. A second setting cannot exist without a
+ * server-schema change, at which point the server merges keys (it carries an
+ * implementation note gating that) — so we deliberately send only the key we own
+ * and do NOT echo a client-cached snapshot.
+ */
+const putSelfSettings = async (rules: GlobalRules): Promise<void> => {
+  const res = await fetch(SELF_SETTINGS_URL, {
+    method: 'PUT',
+    credentials: 'include',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ settings: { checkIgnoredWordPairs: rules } }),
+  });
+  if (!res.ok) {
+    throw new Error('Failed to save global ignore rules');
+  }
+};
+
+// ---------------------------------------------------------------------------
+// Pure map helpers (exported for unit tests).
+// ---------------------------------------------------------------------------
+
+/** Set `key → verdict` in a copy of `rules`. */
+export const setRule = <T extends Record<string, RuleVerdict>>(
+  rules: T,
+  key: string,
+  verdict: RuleVerdict
+): T => ({ ...rules, [key]: verdict });
+
+/** Delete `key` from a copy of `rules` (no-op if absent). */
+export const deleteRule = <T extends Record<string, RuleVerdict>>(rules: T, key: string): T => {
+  if (!(key in rules)) {
+    return { ...rules };
+  }
+  const next = { ...rules };
+  delete next[key];
+  return next;
+};
+
+/**
+ * Extract the `repeated_word` segment from an occurrence key
+ * (`"{snt_id}|{repeated_word}|{ordinal}"`).
+ *
+ * We deliberately do **not** `split('|')`: the `repeated_word` is the *middle*
+ * field, and while `snt_id` (`"{bookCode} {chapter}:{verse}"`) and `ordinal` (a
+ * number) provably contain no `|`, the pair itself is verse-derived text and is
+ * not guaranteed to be pipe-free. A naive `split('|')[1]` would mis-slice such a
+ * pair (e.g. a key `"JDG 4:3|a | a|0"` would yield `"a "` instead of `"a | a"`)
+ * and silently fail to purge that rule. Because the two *outer* fields are
+ * pipe-free, the pair is exactly the substring between the first and last `|`,
+ * which we recover unambiguously regardless of any `|` inside it. Returns
+ * `undefined` for a malformed key (fewer than two delimiters).
+ */
+const extractPairFromKey = (key: string): string | undefined => {
+  const first = key.indexOf('|');
+  const last = key.lastIndexOf('|');
+  if (first === -1 || last === first) {
+    return undefined;
+  }
+  return key.slice(first + 1, last);
+};
+
+/**
+ * Remove every occurrence rule that targets `repeatedWord` (NFC-normalized) in
+ * the current chapter's occurrence map — used by "purge-local on global write"
+ * (§6.5). The occurrence key is `"{snt_id}|{repeated_word}|{ordinal}"`, so we
+ * match the normalized middle segment (see {@link extractPairFromKey} for why we
+ * slice between the outer delimiters rather than `split('|')`). Returns a new map
+ * (or the same instance if nothing matched, to avoid needless writes).
+ */
+export const purgeLocalForPair = (
+  occurrenceRules: OccurrenceRules,
+  repeatedWord: string
+): { rules: OccurrenceRules; changed: boolean } => {
+  const target = normalizePair(repeatedWord);
+  let changed = false;
+  const next: OccurrenceRules = {};
+  for (const [key, verdict] of Object.entries(occurrenceRules)) {
+    const pair = extractPairFromKey(key);
+    if (pair !== undefined && normalizePair(pair) === target) {
+      changed = true;
+      continue; // drop it
+    }
+    next[key] = verdict;
+  }
+  return changed ? { rules: next, changed } : { rules: occurrenceRules, changed };
+};
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+export interface UseSuppressionsParams {
+  /**
+   * Current occurrence-rule map from the editor-state blob (read through the
+   * single editor-state writer; defaults to empty for old rows). The page owns
+   * this state; this hook never fetches it.
+   */
+  occurrenceRules: OccurrenceRules;
+  /**
+   * The **single writer** for the occurrence map. Given the next full map, it
+   * persists it via the existing debounced editor-state save
+   * (`useResourceStatePersistence`). This hook does the read-modify-write and
+   * never opens its own editor-state PUT (the "one writer" rule, §7.1).
+   */
+  saveOccurrenceRules: (next: OccurrenceRules) => void;
+  /**
+   * Whether the Repeated Word Check feature is enabled in this environment
+   * (the `repeatedWordCheck` flag; feature-flags proposal D5/D7). Defaults to
+   * `true` so existing callers/tests are unaffected. When `false`, the
+   * once-per-session `GET /self/settings` probe is **skipped entirely** — the
+   * whole Checks UI is hidden behind the flag, so there is no reason to fetch
+   * user settings for a feature that can't be seen (W2). The global stores stay
+   * at their fail-closed defaults (empty rules, `globalIgnoresAvailable=false`)
+   * and `settingsProbeResolved` stays `false`, which is consistent with the
+   * check query being suppressed by the same flag upstream.
+   */
+  enabled?: boolean;
+}
+
+export interface UseSuppressionsResult {
+  /** Layer-2 map → `useResolvedFindings`. */
+  occurrenceRules: OccurrenceRules;
+  /** Layer-1 map → `useResolvedFindings`. */
+  globalRules: GlobalRules;
+  /** False until the probe resolves, and on 404/failure (W8). Phase 3 hides
+   * `[Ignore Everywhere]` and omits global undo when this is false. */
+  globalIgnoresAvailable: boolean;
+  /** Flips true on any terminal probe response. Phase 4 gates the check
+   * query's `enabled` on this so findings never render ahead of global rules
+   * (W10/§9.1). */
+  settingsProbeResolved: boolean;
+
+  // Actions called by FindingRow (phase 3) -----------------------------------
+
+  /** "Ignore Here" — suppress this single occurrence (layer 2). */
+  ignoreHere: (occurrenceKey: string) => void;
+  /** "Ignore Everywhere" — suppress this word pair across the user's projects
+   * (layer 1) and purge any current-chapter occurrence rules for the pair.
+   * Optimistic; rolls back on PUT failure. Caller (phase 3) shows the confirm
+   * dialog first. */
+  ignoreEverywhere: (repeatedWord: string) => void;
+  /** Default `[Undo ▾]` click (§6.5): undo whatever layer is currently hiding
+   * this finding — delete the occurrence rule if it's the user's own, else
+   * write an occurrence-level `'surface'` override so the global rule / Greek
+   * Room verdict survives but this one occurrence re-surfaces. */
+  undoOccurrence: (resolved: ResolvedFinding) => void;
+  /** Chevron action: stop ignoring this pair everywhere. If a global
+   * `'suppress'` exists, deletes it; otherwise writes a global `'surface'`
+   * override (e.g. to override Greek Room `legitimate` for the pair globally).
+   * Purges current-chapter occurrence rules for the pair. Optimistic; rolls
+   * back on PUT failure. */
+  stopIgnoringEverywhere: (repeatedWord: string) => void;
+}
+
+/**
+ * @see the module doc above. The occurrence half is injected (single writer);
+ * the global half is owned here (probe + optimistic PUT/rollback).
+ */
+export const useSuppressions = ({
+  occurrenceRules,
+  saveOccurrenceRules,
+  enabled = true,
+}: UseSuppressionsParams): UseSuppressionsResult => {
+  // --- Global half: probe once per session, then hold the map locally so we
+  // can apply optimistic updates and roll them back without a query refetch. ---
+  const [globalRules, setGlobalRules] = useState<GlobalRules>({});
+  const [globalIgnoresAvailable, setGlobalIgnoresAvailable] = useState(false);
+  const [settingsProbeResolved, setSettingsProbeResolved] = useState(false);
+
+  // Guard against double-invocation (StrictMode) and state updates after
+  // unmount; the probe runs exactly once per mounted session.
+  const probeStarted = useRef(false);
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+
+  // Last global-rules map the server has *confirmed* (probe result, then each
+  // successful PUT). Rollback restores from THIS, never from a call-time
+  // snapshot: with writes serialized (see `putChainRef`), a later write B can be
+  // issued while an earlier write A is still optimistic-but-unconfirmed, so B's
+  // call-time `previous` may contain A's never-persisted change. Reverting to the
+  // last *committed* baseline can't resurrect that phantom state (CR `3488525698`).
+  // Only ever written in the success path; only ever read in the catch.
+  const committedGlobalRef = useRef<GlobalRules>({});
+
+  useEffect(() => {
+    // Skip the probe entirely while the feature is off (W2): the Checks UI is
+    // hidden behind the flag, so fetching `/self/settings` for it would be a
+    // wasted request in every environment where fluent-ai isn't wired. The
+    // probe fires once if/when `enabled` becomes true (e.g. the flag resolves
+    // after mount), guarded by `probeStarted` so it still runs at most once.
+    if (!enabled || probeStarted.current) {
+      return;
+    }
+    probeStarted.current = true;
+    void probeSelfSettings().then(({ available, rules }) => {
+      if (!mounted.current) {
+        return;
+      }
+      setGlobalIgnoresAvailable(available);
+      setGlobalRules(available ? rules : {});
+      committedGlobalRef.current = available ? rules : {};
+      setSettingsProbeResolved(true);
+    });
+  }, [enabled]);
+
+  // Latest occurrence map for read-modify-write inside callbacks without
+  // making the callbacks change identity on every keystroke.
+  const occurrenceRef = useRef(occurrenceRules);
+  occurrenceRef.current = occurrenceRules;
+
+  // Monotonic counter identifying the most-recently-issued global write. Each
+  // `writeGlobal` captures its own `mySeq`; a failed PUT only rolls back when its
+  // `mySeq` is still the latest issued write, so an old failing PUT can't clobber
+  // a newer in-flight edit's optimistic state (CR-15; successor to CR-7).
+  const writeSeqRef = useRef(0);
+
+  // Tail of the global-write chain. Each PUT is appended after the previous one
+  // settles, so the full-replace PUTs reach the server strictly in UI-action
+  // order — an older successful write can no longer commit after a newer one.
+  // (The `/self/settings` blob is last-writer-wins with no server merge, §8.1, so
+  // out-of-order delivery of two overlapping PUTs would otherwise persist the
+  // stale blob even though the UI shows the newer edit.) The seq-guard above
+  // protects the client rollback; this chain protects the server write order.
+  // CR-15 follow-up.
+  const putChainRef = useRef<Promise<unknown>>(Promise.resolve());
+
+  // --- Occurrence actions (write through the single editor-state writer) ---
+
+  const ignoreHere = useCallback(
+    (occurrenceKey: string) => {
+      const currentVerdict = occurrenceRef.current[occurrenceKey] as RuleVerdict | undefined;
+      if (currentVerdict === 'surface') {
+        // The finding is only active because of a 'surface' override (e.g. the
+        // user previously undid a legitimate or global suppression). To re-ignore,
+        // just remove the override — the lower layer will re-suppress naturally.
+        // This avoids stacking 'suppress' over 'surface' (BUG #3).
+        saveOccurrenceRules(deleteRule(occurrenceRef.current, occurrenceKey));
+      } else {
+        saveOccurrenceRules(setRule(occurrenceRef.current, occurrenceKey, 'suppress'));
+      }
+    },
+    [saveOccurrenceRules]
+  );
+
+  const undoOccurrence = useCallback(
+    (resolved: ResolvedFinding) => {
+      const { occurrenceKey, inactiveReason } = resolved;
+      if (inactiveReason === 'occurrence') {
+        // The user's own occurrence rule is what's hiding it → remove it.
+        saveOccurrenceRules(deleteRule(occurrenceRef.current, occurrenceKey));
+      } else {
+        // A global rule or Greek Room `legitimate` is hiding it → re-surface
+        // just this occurrence; the broader verdict stands.
+        saveOccurrenceRules(setRule(occurrenceRef.current, occurrenceKey, 'surface'));
+      }
+    },
+    [saveOccurrenceRules]
+  );
+
+  // --- Global actions (optimistic + rollback; purge current-chapter local) ---
+
+  /**
+   * Apply a current-chapter purge for `pair` through the single writer. Returns
+   * the occurrence entries it removed (key → verdict) so a failed global write
+   * can restore *just those* keys — see the rollback in `writeGlobal`. Empty
+   * when nothing matched (no write issued).
+   */
+  const purgeCurrentChapter = useCallback(
+    (repeatedWord: string): OccurrenceRules => {
+      const before = occurrenceRef.current;
+      const { rules, changed } = purgeLocalForPair(before, repeatedWord);
+      if (!changed) {
+        return {};
+      }
+      const purged: OccurrenceRules = {};
+      for (const [key, verdict] of Object.entries(before)) {
+        if (!(key in rules)) {
+          purged[key] = verdict;
+        }
+      }
+      saveOccurrenceRules(rules);
+      return purged;
+    },
+    [saveOccurrenceRules]
+  );
+
+  const writeGlobal = useCallback(
+    (repeatedWord: string, mutate: (rules: GlobalRules) => GlobalRules) => {
+      const pair = normalizePair(repeatedWord);
+      const previous = globalRules;
+      // Mark this as the latest issued write. On failure we only roll back if no
+      // newer write was issued in the meantime (CR-15 sequence guard).
+      const mySeq = ++writeSeqRef.current;
+      const next = mutate(previous);
+      // Optimistic: the finding greys/un-greys immediately.
+      setGlobalRules(next);
+      // Purge current-chapter occurrence rules for the pair so the just-clicked
+      // panel doesn't appear to ignore the action (occurrence beats global). Keep
+      // exactly which entries were removed so a failed PUT restores only those.
+      const purgedOccurrence = purgeCurrentChapter(pair);
+      // Send the full blob (single-key full-replace, §8.1), chained after the
+      // previous global write so the PUTs commit on the server in UI-action
+      // order. The leading `.catch(() => {})` swallows the *previous* link's
+      // rejection so one failed write doesn't break the chain for later ones;
+      // each write still reports its own failure in the trailing `.catch`.
+      putChainRef.current = putChainRef.current
+        .catch(() => {})
+        .then(async () => {
+          await putSelfSettings(next);
+          // Persisted: this map is now the confirmed baseline future rollbacks
+          // restore from. (Only the success path writes this ref.)
+          committedGlobalRef.current = next;
+        })
+        .catch(error => {
+          Logger.logException(error, {
+            context: 'Repeated-words global ignore write failed; rolling back',
+          });
+          // Only the latest issued write may revert its own optimistic changes.
+          // If a newer edit was issued while this PUT was in flight, rolling back
+          // would clobber that newer edit (CR-15), so we skip and let the newer
+          // write own the state.
+          if (mounted.current && mySeq === writeSeqRef.current) {
+            // Roll the global flag back to the last *server-confirmed* state —
+            // NOT the call-time `previous`, which (with serialized writes) could
+            // still hold an earlier write's never-persisted optimistic change
+            // (CR `3488525698`). Re-click allowed; the visible flip is the only
+            // failure notice (no queued retry for v1).
+            setGlobalRules(committedGlobalRef.current);
+            // Restore only the occurrence entries this write's purge removed,
+            // merging them back into the *current* map so unrelated occurrence
+            // edits made meanwhile survive (CR `3488525698`). Skip the write
+            // entirely when nothing was purged.
+            const purgedKeys = Object.keys(purgedOccurrence);
+            if (purgedKeys.length > 0) {
+              saveOccurrenceRules({ ...occurrenceRef.current, ...purgedOccurrence });
+            }
+          }
+        });
+    },
+    [globalRules, purgeCurrentChapter, saveOccurrenceRules]
+  );
+
+  const ignoreEverywhere = useCallback(
+    (repeatedWord: string) => {
+      const pair = normalizePair(repeatedWord);
+      writeGlobal(repeatedWord, rules => {
+        const current = rules[pair] as RuleVerdict | undefined;
+        // Toggle principle: if there's a 'surface' override, just remove it
+        // (the lower layer or default will re-suppress). Otherwise write 'suppress'.
+        return current === 'surface' ? deleteRule(rules, pair) : setRule(rules, pair, 'suppress');
+      });
+    },
+    [writeGlobal]
+  );
+
+  const stopIgnoringEverywhere = useCallback(
+    (repeatedWord: string) => {
+      const pair = normalizePair(repeatedWord);
+      writeGlobal(repeatedWord, rules => {
+        const current = rules[pair] as RuleVerdict | undefined;
+        // Toggle principle: if there's a 'suppress' rule, just remove it.
+        // Otherwise write 'surface' to override a lower-layer verdict (e.g.
+        // Greek Room `legitimate`) globally for this pair (BUG #4).
+        return current === 'suppress' ? deleteRule(rules, pair) : setRule(rules, pair, 'surface');
+      });
+    },
+    [writeGlobal]
+  );
+
+  return useMemo(
+    () => ({
+      occurrenceRules,
+      globalRules,
+      globalIgnoresAvailable,
+      settingsProbeResolved,
+      ignoreHere,
+      ignoreEverywhere,
+      undoOccurrence,
+      stopIgnoringEverywhere,
+    }),
+    [
+      occurrenceRules,
+      globalRules,
+      globalIgnoresAvailable,
+      settingsProbeResolved,
+      ignoreHere,
+      ignoreEverywhere,
+      undoOccurrence,
+      stopIgnoringEverywhere,
+    ]
+  );
+};
diff --git a/src/features/dashboard/user/UserHomePage.test.tsx b/src/features/dashboard/user/UserHomePage.test.tsx
index 2345a37f..4a473ded 100644
--- a/src/features/dashboard/user/UserHomePage.test.tsx
+++ b/src/features/dashboard/user/UserHomePage.test.tsx
@@ -37,6 +37,7 @@ const assignment = (overrides: Partial<UserChapterAssignment>): UserChapterAssig
   bibleName: 'Test Bible',
   chapterStatus: 'draft',
   targetLanguage: 'Spanish',
+  targetLangCode: 'spa',
   sourceLangCode: 'eng',
   bookCode: 'GEN',
   bookId: 1,
diff --git a/src/features/flags/FeatureFlagsDiagnostics.test.tsx b/src/features/flags/FeatureFlagsDiagnostics.test.tsx
new file mode 100644
index 00000000..a12058e8
--- /dev/null
+++ b/src/features/flags/FeatureFlagsDiagnostics.test.tsx
@@ -0,0 +1,91 @@
+import { type ReactNode } from 'react';
+
+import { QueryClientProvider } from '@tanstack/react-query';
+import userEvent from '@testing-library/user-event';
+import { http, HttpResponse } from 'msw';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { config } from '@/lib/config';
+import { server } from '@/test/msw/server';
+import { createTestQueryClient, render, screen, waitFor } from '@/test/render';
+
+import { FeatureFlagsDiagnostics } from './FeatureFlagsDiagnostics';
+
+const FEATURES_URL = `${config.api.url}/config/features`;
+
+const makeWrapper = () => {
+  const queryClient = createTestQueryClient();
+  const Wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+  return Wrapper;
+};
+
+const mockFeatures = (features: Record<string, boolean>, status = 200) =>
+  server.use(http.get(FEATURES_URL, () => HttpResponse.json({ features }, { status })));
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('FeatureFlagsDiagnostics', () => {
+  it('renders each flag with its published On/Off state once loaded', async () => {
+    mockFeatures({ repeatedWordCheck: true });
+    render(<FeatureFlagsDiagnostics />, { wrapper: makeWrapper() });
+
+    await waitFor(() =>
+      expect(screen.getByTestId('flag-state-repeatedWordCheck')).toHaveTextContent('On')
+    );
+    expect(screen.getByTestId('flag-row-repeatedWordCheck')).toBeInTheDocument();
+    expect(screen.queryByTestId('flags-error')).not.toBeInTheDocument();
+  });
+
+  it('shows the flag as Off when the API reports it off', async () => {
+    mockFeatures({ repeatedWordCheck: false });
+    render(<FeatureFlagsDiagnostics />, { wrapper: makeWrapper() });
+
+    await waitFor(() =>
+      expect(screen.getByTestId('flag-state-repeatedWordCheck')).toHaveTextContent('Off')
+    );
+  });
+
+  it('surfaces an error banner and fail-closed (Off) values when the endpoint errors', async () => {
+    mockFeatures({ repeatedWordCheck: true }, 500);
+    render(<FeatureFlagsDiagnostics />, { wrapper: makeWrapper() });
+
+    await waitFor(() => expect(screen.getByTestId('flags-error')).toBeInTheDocument());
+    // Even though the (failing) server would have said `true`, the page shows Off.
+    expect(screen.getByTestId('flag-state-repeatedWordCheck')).toHaveTextContent('Off');
+  });
+
+  it('reflects the flag map even for an unknown/new flag key (enumerates the map)', async () => {
+    // The API is the source of truth; a flag added there before the FeatureName
+    // union is updated should still render, proving the page is data-driven.
+    mockFeatures({ repeatedWordCheck: false, someNewFlag: true });
+    render(<FeatureFlagsDiagnostics />, { wrapper: makeWrapper() });
+
+    await waitFor(() =>
+      expect(screen.getByTestId('flag-state-someNewFlag')).toHaveTextContent('On')
+    );
+  });
+
+  it('refetches when Refresh is clicked', async () => {
+    let calls = 0;
+    server.use(
+      http.get(FEATURES_URL, () => {
+        calls += 1;
+        return HttpResponse.json({ features: { repeatedWordCheck: false } });
+      })
+    );
+    const user = userEvent.setup();
+    render(<FeatureFlagsDiagnostics />, { wrapper: makeWrapper() });
+
+    await waitFor(() =>
+      expect(screen.getByTestId('flag-state-repeatedWordCheck')).toHaveTextContent('Off')
+    );
+    const callsAfterLoad = calls;
+
+    await user.click(screen.getByRole('button', { name: 'Refresh' }));
+    await waitFor(() => expect(calls).toBeGreaterThan(callsAfterLoad));
+  });
+});
diff --git a/src/features/flags/FeatureFlagsDiagnostics.tsx b/src/features/flags/FeatureFlagsDiagnostics.tsx
new file mode 100644
index 00000000..9a344d6c
--- /dev/null
+++ b/src/features/flags/FeatureFlagsDiagnostics.tsx
@@ -0,0 +1,109 @@
+import React from 'react';
+
+import { config } from '@/lib/config';
+
+import { useFeatureFlags } from './useFeatureFlags';
+
+/**
+ * Read-only diagnostics page for the published feature flags (proposal D8).
+ *
+ * Purpose: a human (or a support engineer) can hit one URL and see exactly what
+ * `GET /config/features` reports for the environment they're in — the single
+ * source of truth for "is the Repeated Word Check meant to be visible here?".
+ * This is deliberately unlinked (no nav entry): you reach it only if you know
+ * the path. It is login-gated by the `_authenticated` layout but has no role
+ * gate, so any signed-in user can self-serve this diagnostic.
+ *
+ * It is strictly read-only: it renders whatever the API returned and never
+ * writes or overrides a flag. The flags themselves are owned by fluent-api
+ * (env-sourced), so there is nothing to toggle here — mirroring the proposal's
+ * "the API owns the truth" stance (D3/D4).
+ *
+ * Note: because {@link useFeatureFlags} fails closed, a network error shows every
+ * flag as "Off" *and* surfaces the error banner — that combination is itself the
+ * signal that the values shown are the safe defaults, not confirmed state.
+ */
+export const FeatureFlagsDiagnostics: React.FC = () => {
+  const { features, isLoading, isError, query } = useFeatureFlags();
+
+  // Enumerate whatever the effective map contains rather than a hard-coded list,
+  // so a flag added later (API + `FeatureName`) appears here automatically with
+  // no change to this page. `features` is `Record<FeatureName, boolean>`, so
+  // `Object.entries` is already `[string, boolean][]` — no cast needed (W4).
+  const entries = Object.entries(features);
+
+  return (
+    <div className='mx-auto max-w-2xl px-8 py-10'>
+      <header className='mb-6'>
+        <h1 className='text-2xl font-bold'>Feature flags</h1>
+        <p className='text-muted-foreground mt-1 text-sm'>
+          Read-only view of what <code className='font-mono'>GET /config/features</code> reports for
+          this environment. Values are owned by the API and cannot be changed here.
+        </p>
+        <p className='text-muted-foreground mt-1 text-xs'>
+          Source: <span className='font-mono'>{config.api.url}/config/features</span> · Environment:{' '}
+          <span className='font-mono'>{config.environment.current}</span>
+        </p>
+      </header>
+
+      {isLoading && (
+        <p className='text-muted-foreground text-sm' data-testid='flags-loading'>
+          Loading flags…
+        </p>
+      )}
+
+      {isError && (
+        <div
+          className='mb-4 rounded-md border border-red-300 bg-red-50 px-4 py-3 text-sm text-red-700'
+          data-testid='flags-error'
+          role='alert'
+        >
+          Could not reach the feature-flags endpoint. Showing fail-closed defaults (every flag
+          treated as <strong>Off</strong>) — these are safe defaults, not confirmed values.
+        </div>
+      )}
+
+      <table className='w-full border-collapse text-sm' data-testid='flags-table'>
+        <thead>
+          <tr className='border-b text-left'>
+            <th className='py-2 pr-4 font-semibold'>Flag</th>
+            <th className='py-2 font-semibold'>State</th>
+          </tr>
+        </thead>
+        <tbody>
+          {entries.map(([name, enabled]) => (
+            <tr key={name} className='border-b last:border-b-0' data-testid={`flag-row-${name}`}>
+              <td className='py-2 pr-4 font-mono'>{name}</td>
+              <td className='py-2'>
+                <span
+                  className={
+                    enabled
+                      ? 'inline-flex items-center rounded-full bg-green-100 px-2.5 py-0.5 text-xs font-semibold text-green-800'
+                      : 'inline-flex items-center rounded-full bg-gray-100 px-2.5 py-0.5 text-xs font-semibold text-gray-600'
+                  }
+                  data-testid={`flag-state-${name}`}
+                >
+                  {enabled ? 'On' : 'Off'}
+                </span>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+
+      {entries.length === 0 && !isLoading && (
+        <p className='text-muted-foreground mt-4 text-sm'>No feature flags are defined.</p>
+      )}
+
+      <button
+        className='text-primary mt-6 cursor-pointer text-sm font-semibold underline-offset-2 hover:underline'
+        type='button'
+        onClick={() => void query.refetch()}
+      >
+        Refresh
+      </button>
+    </div>
+  );
+};
+
+export default FeatureFlagsDiagnostics;
diff --git a/src/features/flags/FeatureGate.tsx b/src/features/flags/FeatureGate.tsx
new file mode 100644
index 00000000..6ae7f827
--- /dev/null
+++ b/src/features/flags/FeatureGate.tsx
@@ -0,0 +1,34 @@
+import { type ReactNode } from 'react';
+
+import { type FeatureName } from './flags.types';
+import { useFeatureFlag } from './useFeatureFlags';
+
+export interface FeatureGateProps {
+  /** The flag that must be on for the children to render. */
+  feature: FeatureName;
+  /** Rendered only when the named flag is on. */
+  children: ReactNode;
+  /**
+   * Optional fallback rendered when the flag is off (including while loading or
+   * on error — the gate is fail-closed, D7). Defaults to nothing, i.e. the
+   * gated UI simply disappears as though it were not implemented.
+   */
+  fallback?: ReactNode;
+}
+
+/**
+ * Render children only when a feature flag is on (proposal D6/D7).
+ *
+ * **Fails closed:** while the flag map is loading, or if the endpoint errors,
+ * the flag reads `false` (see {@link useFeatureFlag}), so the children are
+ * hidden and the optional `fallback` (default: nothing) is shown instead. This
+ * is a pure render-wrapper — it does not gate side effects such as network
+ * queries; a caller that also needs to suppress a query should read the flag
+ * directly and fold it into that query's `enabled`.
+ */
+export const FeatureGate: React.FC<FeatureGateProps> = ({ feature, children, fallback = null }) => {
+  const enabled = useFeatureFlag(feature);
+  return <>{enabled ? children : fallback}</>;
+};
+
+export default FeatureGate;
diff --git a/src/features/flags/flags.types.ts b/src/features/flags/flags.types.ts
new file mode 100644
index 00000000..dba0d105
--- /dev/null
+++ b/src/features/flags/flags.types.ts
@@ -0,0 +1,40 @@
+/**
+ * Feature-flag types — the fluent-web mirror of the fluent-api contract.
+ *
+ * The API owns the truth (env-sourced) and publishes a read-only projection at
+ * `GET /config/features` (proposal D3/D4). fluent-web never decides policy — it
+ * only reflects what the API reports. See
+ * `fluent-api/src/lib/features.ts` for the source of these keys.
+ *
+ * The wire shape is a **named map** so new flags are purely additive: adding a
+ * feature later is a new key here + a new `<FeatureGate>`/`useFeatureFlag`
+ * usage, with no change to the hook or the gate primitive (D6).
+ */
+
+/**
+ * Known feature-flag wire keys (camelCase), mirroring the API's `FLAGS`
+ * registry. Kept as a string-literal union (not an open `string`) so a typo in
+ * `useFeatureFlag('...')` / `<FeatureGate feature="...">` is a compile error and
+ * so the diagnostics page can enumerate the known flags.
+ */
+export type FeatureName = 'repeatedWordCheck';
+
+/** The published feature map: every known flag, always present as a boolean. */
+export type Features = Record<FeatureName, boolean>;
+
+/** The `GET /config/features` response envelope. */
+export interface FeaturesResponse {
+  features: Features;
+}
+
+/**
+ * The safe, fail-closed default map (D7): every known flag is **off**. Used
+ * while flags are loading or when the endpoint errors/is unreachable, so gated
+ * AI UI is never surfaced before the API has confirmed the feature is on.
+ *
+ * Declared as a function (not a shared const) so callers always get a fresh
+ * object and can't accidentally mutate a shared default.
+ */
+export const failClosedFeatures = (): Features => ({
+  repeatedWordCheck: false,
+});
diff --git a/src/features/flags/index.ts b/src/features/flags/index.ts
new file mode 100644
index 00000000..7234b618
--- /dev/null
+++ b/src/features/flags/index.ts
@@ -0,0 +1,26 @@
+/**
+ * Feature flags — the fluent-web consumer of fluent-api's published feature map
+ * (`GET /config/features`). See the proposal at
+ * `fluent-api/docs/proposals/feature-flags/feature-flags-suggestion.md`.
+ *
+ * Public surface:
+ *   - `useFeatureFlags()` — the full, fail-closed feature map + query status.
+ *   - `useFeatureFlag(name)` — a single boolean (fail-closed).
+ *   - `<FeatureGate feature=...>` — render children only when a flag is on.
+ *   - types: `FeatureName`, `Features`, `FeaturesResponse`.
+ */
+export { FeatureGate, type FeatureGateProps } from './FeatureGate';
+export { FeatureFlagsDiagnostics } from './FeatureFlagsDiagnostics';
+export {
+  useFeatureFlags,
+  useFeatureFlag,
+  fetchFeatureFlags,
+  FEATURE_FLAGS_QUERY_KEY,
+  type UseFeatureFlagsResult,
+} from './useFeatureFlags';
+export {
+  type FeatureName,
+  type Features,
+  type FeaturesResponse,
+  failClosedFeatures,
+} from './flags.types';
diff --git a/src/features/flags/useFeatureFlags.test.tsx b/src/features/flags/useFeatureFlags.test.tsx
new file mode 100644
index 00000000..2ee56e0e
--- /dev/null
+++ b/src/features/flags/useFeatureFlags.test.tsx
@@ -0,0 +1,139 @@
+import { type ReactNode } from 'react';
+
+import { QueryClientProvider } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { config } from '@/lib/config';
+import { server } from '@/test/msw/server';
+import { createTestQueryClient, render, renderHook, screen, waitFor } from '@/test/render';
+
+import { FeatureGate } from './FeatureGate';
+import { failClosedFeatures } from './flags.types';
+import { useFeatureFlag, useFeatureFlags } from './useFeatureFlags';
+
+const FEATURES_URL = `${config.api.url}/config/features`;
+
+/**
+ * A QueryClientProvider wrapper pinned to a single test client (retries off, no
+ * cache) so a `rerender` doesn't reset the cache. Mirrors the pattern in
+ * `useRepeatedWordsCheck.test.ts`. (The hook itself also sets `retry: false`, so
+ * the error case resolves immediately.)
+ */
+const makeWrapper = () => {
+  const queryClient = createTestQueryClient();
+  const Wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+  return Wrapper;
+};
+
+/** Register a GET handler for /config/features returning the given map. */
+const mockFeatures = (features: Record<string, boolean>, status = 200) => {
+  const calls = { count: 0 };
+  server.use(
+    http.get(FEATURES_URL, () => {
+      calls.count += 1;
+      return HttpResponse.json({ features }, { status });
+    })
+  );
+  return calls;
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('failClosedFeatures', () => {
+  it('returns every known flag off, and a fresh object each call', () => {
+    const a = failClosedFeatures();
+    const b = failClosedFeatures();
+    expect(a).toEqual({ repeatedWordCheck: false });
+    expect(a).not.toBe(b); // not a shared mutable singleton
+  });
+});
+
+describe('useFeatureFlags — fail-closed semantics', () => {
+  it('reports every flag off while loading (before the response lands)', () => {
+    mockFeatures({ repeatedWordCheck: true });
+    const { result } = renderHook(() => useFeatureFlags(), { wrapper: makeWrapper() });
+    // First synchronous render: data hasn't arrived → fail-closed.
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.features.repeatedWordCheck).toBe(false);
+  });
+
+  it('reflects the published map once loaded', async () => {
+    mockFeatures({ repeatedWordCheck: true });
+    const { result } = renderHook(() => useFeatureFlags(), { wrapper: makeWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.features.repeatedWordCheck).toBe(true);
+    expect(result.current.isError).toBe(false);
+  });
+
+  it('publishes a flag as off when the API says off', async () => {
+    mockFeatures({ repeatedWordCheck: false });
+    const { result } = renderHook(() => useFeatureFlags(), { wrapper: makeWrapper() });
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.features.repeatedWordCheck).toBe(false);
+  });
+
+  it('fails closed (all flags off) when the endpoint errors', async () => {
+    mockFeatures({ repeatedWordCheck: true }, 500);
+    const { result } = renderHook(() => useFeatureFlags(), { wrapper: makeWrapper() });
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    // Even though the (unreachable) server would have said `true`, we hide.
+    expect(result.current.features.repeatedWordCheck).toBe(false);
+  });
+});
+
+describe('useFeatureFlag — single-flag selector', () => {
+  it('returns the boolean for a named flag once loaded', async () => {
+    mockFeatures({ repeatedWordCheck: true });
+    const { result } = renderHook(() => useFeatureFlag('repeatedWordCheck'), {
+      wrapper: makeWrapper(),
+    });
+    expect(result.current).toBe(false); // fail-closed during load
+    await waitFor(() => expect(result.current).toBe(true));
+  });
+});
+
+describe('FeatureGate', () => {
+  it('renders children only after the flag resolves on (hidden while loading)', async () => {
+    mockFeatures({ repeatedWordCheck: true });
+    render(
+      <FeatureGate feature='repeatedWordCheck'>
+        <div>gated-content</div>
+      </FeatureGate>,
+      { wrapper: makeWrapper() }
+    );
+    // Fail-closed: not present on first render.
+    expect(screen.queryByText('gated-content')).not.toBeInTheDocument();
+    await waitFor(() => expect(screen.getByText('gated-content')).toBeInTheDocument());
+  });
+
+  it('renders the fallback (and never the children) when the flag is off', async () => {
+    mockFeatures({ repeatedWordCheck: false });
+    render(
+      <FeatureGate fallback={<div>fallback-content</div>} feature='repeatedWordCheck'>
+        <div>gated-content</div>
+      </FeatureGate>,
+      { wrapper: makeWrapper() }
+    );
+    await waitFor(() => expect(screen.getByText('fallback-content')).toBeInTheDocument());
+    expect(screen.queryByText('gated-content')).not.toBeInTheDocument();
+  });
+
+  it('stays hidden (children never appear) when the endpoint errors', async () => {
+    const calls = mockFeatures({ repeatedWordCheck: true }, 500);
+    render(
+      <FeatureGate feature='repeatedWordCheck'>
+        <div>gated-content</div>
+      </FeatureGate>,
+      { wrapper: makeWrapper() }
+    );
+    await waitFor(() => expect(calls.count).toBeGreaterThan(0));
+    // Give React Query a tick to settle into the error state.
+    await new Promise(r => setTimeout(r, 20));
+    expect(screen.queryByText('gated-content')).not.toBeInTheDocument();
+  });
+});
diff --git a/src/features/flags/useFeatureFlags.ts b/src/features/flags/useFeatureFlags.ts
new file mode 100644
index 00000000..abc34144
--- /dev/null
+++ b/src/features/flags/useFeatureFlags.ts
@@ -0,0 +1,122 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+import { config } from '@/lib/config';
+import { Logger } from '@/lib/services/logger';
+
+import {
+  type FeatureName,
+  type Features,
+  type FeaturesResponse,
+  failClosedFeatures,
+} from './flags.types';
+
+/**
+ * Query key for the published feature map. Exported so tests and the
+ * diagnostics page can reference/invalidate it without restating the string.
+ */
+export const FEATURE_FLAGS_QUERY_KEY = ['feature-flags'] as const;
+
+/**
+ * How long the flag map is considered fresh. Flags change only on deploy/config
+ * (never at runtime — proposal D1/D8), so there is no value in refetching them
+ * often; a long staleTime avoids a request storm without hiding a real change
+ * for longer than a page reload.
+ */
+const FLAGS_STALE_TIME_MS = 5 * 60 * 1000; // 5 minutes
+
+/** GET the published feature map from fluent-api. Follows the fetch pattern in
+ *  `features/bible/hooks/useBibleTarget.ts` (plain fetch + credentials). The
+ *  endpoint is unauthenticated (proposal Q1), but we still send credentials for
+ *  consistency and so it keeps working if the reviewer decides to gate it. */
+export const fetchFeatureFlags = async (): Promise<Features> => {
+  const res = await fetch(`${config.api.url}/config/features`, {
+    method: 'GET',
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!res.ok) {
+    throw new Error(`Failed to fetch feature flags (HTTP ${res.status})`);
+  }
+
+  // The body is cast, not schema-validated, so a 200 with a malformed/partial
+  // `features` object (missing a known key, or `features` absent entirely) must
+  // NOT be trusted verbatim — that would let an unknown flag read `undefined`
+  // (falsy, but off-contract) and bypass the fail-closed guarantee. Spread the
+  // known-off defaults FIRST, then overlay whatever the API sent: every known
+  // flag is present as a boolean, and only keys the API explicitly reports as
+  // `true` turn on (W3, D7).
+  const body = (await res.json()) as FeaturesResponse;
+  return { ...failClosedFeatures(), ...body.features };
+};
+
+export interface UseFeatureFlagsResult {
+  /**
+   * The effective feature map. **Never undefined** — while loading or on error
+   * this is the fail-closed map (every flag `false`), so callers can read
+   * `features.repeatedWordCheck` directly without null-checks and get the safe
+   * (hidden) answer by default (D7).
+   */
+  features: Features;
+  /** True while the flags are being fetched for the first time. */
+  isLoading: boolean;
+  /** True if the fetch errored/was unreachable (flags are fail-closed). */
+  isError: boolean;
+  /** Raw query handle, for a diagnostics page that wants status/refetch. */
+  query: UseQueryResult<Features>;
+}
+
+/**
+ * Fetch and expose the published feature flags (proposal D6/D7).
+ *
+ * **Fails closed.** The returned `features` map is the fail-closed default
+ * (everything off) until the API confirms a flag is on — so gated AI UI stays
+ * hidden while the request is in flight or if it fails, which is the whole point
+ * (don't surface features whose backend isn't there). The map is always the
+ * full `Features` shape, so consumers never branch on undefined.
+ */
+export const useFeatureFlags = (): UseFeatureFlagsResult => {
+  const query = useQuery<Features>({
+    queryKey: FEATURE_FLAGS_QUERY_KEY,
+    queryFn: async () => {
+      try {
+        return await fetchFeatureFlags();
+      } catch (error) {
+        Logger.logException(error instanceof Error ? error : new Error(String(error)), {
+          context: 'Feature-flags fetch failed',
+        });
+        throw error;
+      }
+    },
+    staleTime: FLAGS_STALE_TIME_MS,
+    // No retry. The query already fails *closed* — a blip just keeps gated UI
+    // hidden (the safe state) and self-corrects on the next natural refetch, so
+    // retrying would only delay when `isError` (and the diagnostics banner) can
+    // be observed without changing the user-visible outcome. Keeping it off also
+    // means the fail-closed answer is available immediately.
+    retry: false,
+  });
+
+  return {
+    // Fail-closed: use live data only once it has actually arrived; otherwise
+    // (loading OR error) every flag reads false.
+    features: query.data ?? failClosedFeatures(),
+    isLoading: query.isLoading,
+    isError: query.isError,
+    query,
+  };
+};
+
+/**
+ * Thin selector for a single flag (D6). Returns a plain boolean, fail-closed by
+ * construction (it reads the fail-closed map from {@link useFeatureFlags}).
+ *
+ * @example
+ *   const checksEnabled = useFeatureFlag('repeatedWordCheck');
+ */
+export const useFeatureFlag = (name: FeatureName): boolean => {
+  const { features } = useFeatureFlags();
+  return features[name];
+};
diff --git a/src/features/projects/components/ProjectDetailPage.tsx b/src/features/projects/components/ProjectDetailPage.tsx
index 41e477ee..8ecc3052 100644
--- a/src/features/projects/components/ProjectDetailPage.tsx
+++ b/src/features/projects/components/ProjectDetailPage.tsx
@@ -328,6 +328,10 @@ export const ProjectDetailPage: React.FC<ProjectDetailPageProps> = ({
         bibleId: assignment.bibleId,
         bibleName: projectSource,
         targetLanguage: projectTargetLanguageName,
+        // ISO 639-3 code for the repeated-words check's `lang_code` (BUG #3):
+        // the progress endpoint now surfaces this so the PM path no longer
+        // sends "<unknown>".
+        targetLangCode: assignment.targetLangCode,
         bookId: assignment.bookId,
         book: assignment.bookNameEng,
         chapterStatus: assignment.status,
diff --git a/src/features/resources/components/ResourcePanel.tsx b/src/features/resources/components/ResourcePanel.tsx
index 929a1aa5..8868fe9b 100644
--- a/src/features/resources/components/ResourcePanel.tsx
+++ b/src/features/resources/components/ResourcePanel.tsx
@@ -410,10 +410,9 @@ export const ResourcePanel: React.FC<ResourcePanelProps> = ({
 
   return (
     <aside className='bg-background flex h-full flex-col'>
+      {/* The "Resources" heading was removed: the shared LeftPanel tab row
+          ("Resources | Checks") now serves as this panel's header (W11, §6.6). */}
       <div className='bg-background top-0 py-4'>
-        <div className='flex items-center gap-2'>
-          <h3 className='text-foreground text-xl font-semibold'>Resources</h3>
-        </div>
         <ResourceChipRow
           resourceNames={resourceNames}
           selectedResource={selectedResource}
diff --git a/src/lib/types.ts b/src/lib/types.ts
index 9a2dbccc..fc21397a 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -86,6 +86,13 @@ export interface ChapterAssignmentProgress {
   bookId: number;
   bookCode: string;
   sourceLangCode: string;
+  /**
+   * ISO 639-3 target language CODE, e.g. "eng" (sent as the repeated-words
+   * check's `lang_code`). Required so the PM "open chapter" path can populate
+   * `ProjectItem.targetLangCode`; if it were optional the field could be
+   * silently dropped and the check would send "<unknown>" (BUG #3).
+   */
+  targetLangCode: string;
   bookNameEng: string;
   chapterNumber: number;
   assignedUser: AssignmentUser | null;
@@ -114,7 +121,18 @@ export interface ProjectItem {
   projectUnitId: number;
   bibleId: number;
   bibleName: string;
+  /** Human-readable target language display NAME, e.g. "English". */
   targetLanguage: string;
+  /**
+   * ISO 639-3 target language CODE, e.g. "eng". Sent as the check's `lang_code`
+   * — greek-room keys its legitimate-duplicate whitelist on this code, so the
+   * display name must NOT be used here. See phase-04 manual smoke (BUG #2).
+   * Required so the compiler forces every `ProjectItem` builder to supply it
+   * (the PM "open chapter" path silently omitted it — BUG #3). The check still
+   * degrades to "<unknown>" at runtime if the value is somehow empty, rather
+   * than crashing.
+   */
+  targetLangCode: string;
   bookId: number;
   book: string;
   chapterStatus: string;
@@ -247,7 +265,10 @@ export interface UserChapterAssignment {
   bibleId: number;
   bibleName: string;
   chapterStatus: string;
+  /** Human-readable target language display NAME, e.g. "English". */
   targetLanguage: string;
+  /** ISO 639-3 target language CODE, e.g. "eng" (sent as the check's lang_code). */
+  targetLangCode: string;
   sourceLangCode: string;
   bookCode: string;
   bookId: number;
diff --git a/src/routeTree.gen.ts b/src/routeTree.gen.ts
index 02b0706e..c1f42595 100644
--- a/src/routeTree.gen.ts
+++ b/src/routeTree.gen.ts
@@ -17,6 +17,7 @@ import { Route as AuthenticatedRouteImport } from './routes/_authenticated'
 import { Route as AuthenticatedIndexRouteImport } from './routes/_authenticated/index'
 import { Route as LegalTermsRouteImport } from './routes/legal/terms'
 import { Route as LegalPrivacyRouteImport } from './routes/legal/privacy'
+import { Route as AuthenticatedDebugRouteImport } from './routes/_authenticated/debug'
 import { Route as AuthenticatedUsersIndexRouteImport } from './routes/_authenticated/users/index'
 import { Route as AuthenticatedProjectsIndexRouteImport } from './routes/_authenticated/projects/index'
 import { Route as AuthenticatedProjectsProjectIdIndexRouteImport } from './routes/_authenticated/projects/$projectId/index'
@@ -62,6 +63,11 @@ const LegalPrivacyRoute = LegalPrivacyRouteImport.update({
   path: '/privacy',
   getParentRoute: () => LegalRoute,
 } as any)
+const AuthenticatedDebugRoute = AuthenticatedDebugRouteImport.update({
+  id: '/debug',
+  path: '/debug',
+  getParentRoute: () => AuthenticatedRoute,
+} as any)
 const AuthenticatedUsersIndexRoute = AuthenticatedUsersIndexRouteImport.update({
   id: '/users/',
   path: '/users/',
@@ -98,6 +104,7 @@ export interface FileRoutesByFullPath {
   '/legal': typeof LegalRouteWithChildren
   '/login': typeof LoginRoute
   '/reset-password': typeof ResetPasswordRoute
+  '/debug': typeof AuthenticatedDebugRoute
   '/legal/privacy': typeof LegalPrivacyRoute
   '/legal/terms': typeof LegalTermsRoute
   '/projects/': typeof AuthenticatedProjectsIndexRoute
@@ -111,6 +118,7 @@ export interface FileRoutesByTo {
   '/legal': typeof LegalRouteWithChildren
   '/login': typeof LoginRoute
   '/reset-password': typeof ResetPasswordRoute
+  '/debug': typeof AuthenticatedDebugRoute
   '/legal/privacy': typeof LegalPrivacyRoute
   '/legal/terms': typeof LegalTermsRoute
   '/': typeof AuthenticatedIndexRoute
@@ -127,6 +135,7 @@ export interface FileRoutesById {
   '/legal': typeof LegalRouteWithChildren
   '/login': typeof LoginRoute
   '/reset-password': typeof ResetPasswordRoute
+  '/_authenticated/debug': typeof AuthenticatedDebugRoute
   '/legal/privacy': typeof LegalPrivacyRoute
   '/legal/terms': typeof LegalTermsRoute
   '/_authenticated/': typeof AuthenticatedIndexRoute
@@ -144,6 +153,7 @@ export interface FileRouteTypes {
     | '/legal'
     | '/login'
     | '/reset-password'
+    | '/debug'
     | '/legal/privacy'
     | '/legal/terms'
     | '/projects/'
@@ -157,6 +167,7 @@ export interface FileRouteTypes {
     | '/legal'
     | '/login'
     | '/reset-password'
+    | '/debug'
     | '/legal/privacy'
     | '/legal/terms'
     | '/'
@@ -172,6 +183,7 @@ export interface FileRouteTypes {
     | '/legal'
     | '/login'
     | '/reset-password'
+    | '/_authenticated/debug'
     | '/legal/privacy'
     | '/legal/terms'
     | '/_authenticated/'
@@ -248,6 +260,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof LegalPrivacyRouteImport
       parentRoute: typeof LegalRoute
     }
+    '/_authenticated/debug': {
+      id: '/_authenticated/debug'
+      path: '/debug'
+      fullPath: '/debug'
+      preLoaderRoute: typeof AuthenticatedDebugRouteImport
+      parentRoute: typeof AuthenticatedRoute
+    }
     '/_authenticated/users/': {
       id: '/_authenticated/users/'
       path: '/users'
@@ -287,6 +306,7 @@ declare module '@tanstack/react-router' {
 }
 
 interface AuthenticatedRouteChildren {
+  AuthenticatedDebugRoute: typeof AuthenticatedDebugRoute
   AuthenticatedIndexRoute: typeof AuthenticatedIndexRoute
   AuthenticatedProjectsIndexRoute: typeof AuthenticatedProjectsIndexRoute
   AuthenticatedUsersIndexRoute: typeof AuthenticatedUsersIndexRoute
@@ -296,6 +316,7 @@ interface AuthenticatedRouteChildren {
 }
 
 const AuthenticatedRouteChildren: AuthenticatedRouteChildren = {
+  AuthenticatedDebugRoute: AuthenticatedDebugRoute,
   AuthenticatedIndexRoute: AuthenticatedIndexRoute,
   AuthenticatedProjectsIndexRoute: AuthenticatedProjectsIndexRoute,
   AuthenticatedUsersIndexRoute: AuthenticatedUsersIndexRoute,
diff --git a/src/routes/_authenticated/debug.tsx b/src/routes/_authenticated/debug.tsx
new file mode 100644
index 00000000..eea7180d
--- /dev/null
+++ b/src/routes/_authenticated/debug.tsx
@@ -0,0 +1,15 @@
+import { createFileRoute } from '@tanstack/react-router';
+
+import { FeatureFlagsDiagnostics } from '@/features/flags';
+
+/**
+ * Unlinked, read-only feature-flags diagnostics page (feature-flags proposal
+ * D8). Login-gated by the `_authenticated` layout but intentionally has no role
+ * gate and no nav entry — you reach it only by knowing the path (`/debug`) — so
+ * any signed-in user can self-serve "what does `GET /config/features` report
+ * here?" without exposing a control surface (there is nothing to toggle; the API
+ * owns the values).
+ */
+export const Route = createFileRoute('/_authenticated/debug')({
+  component: FeatureFlagsDiagnostics,
+});