diff --git a/ledger/checks/mutation_harness.py b/ledger/checks/mutation_harness.py
index 7cc08ac..1f3c33d 100644
--- a/ledger/checks/mutation_harness.py
+++ b/ledger/checks/mutation_harness.py
@@ -421,12 +421,22 @@ def _mo002_alias_becomes_a_bespoke_hue(w: World) -> None:
     w.replace(WEBTHEME, "--amber:var(--alarm);", "--amber:#D9A253;")
 
 
-def _mo003_retired_palette_removed(w: World) -> None:
-    """FIXED: the specimen a calm pixel sweep would catch is tokenised."""
+def _mo003b_the_retired_palette_returns(w: World) -> None:
+    """The retired pre-blend-3 ground comes back to webpwa.py's offline body.
+
+    DIRECTION NOTE, stated rather than hidden: OSV1-003's declared direction is
+    VIOLATION-MOVEMENT (it is still VIOLATION -- a calm L1 still paints
+    `--blocked`, which `_mo003_the_calm_page_stops_painting_blocked` is the
+    counterfactual for). This mutation pushes the OTHER way, and it is here on
+    purpose: the row's two palette specimens
+    CLOSED on 2026-09-05 (OSV1-005), so its probe stopped pinning them as
+    present and started guarding that they stay gone. A guard nobody has
+    watched fail is a guard that might assert nothing.
+    """
     w.replace(
         WEBPWA,
-        "background:#0D0D0C;color:#F2EEE6;",
-        "background:var(--color-ground);color:var(--ink-primary);",
+        '\'<meta name="color-scheme" content="dark light">\' +',
+        "'<body style=\"background:#0D0D0C;color:#F2EEE6\">' +",
     )
 
 
@@ -438,39 +448,31 @@ def _mo004_a_status_loses_its_word(w: World) -> None:
     w.replace(WEBBROWSE, '"open": "READY",', '"open": "",')
 
 
-def _mo005_the_worst_literal_site_is_migrated(w: World) -> None:
-    """FIXED (partially): the retired-palette inline body is tokenised, so the
-    census drops from 66 to 65 and the named specimen leaves the bucket.
+_LITERAL_INLINE_SITE = "\n_LEDGER_MUTATION = '<i style=\"color:#D9A253\"></i>'\n"
+#: A page-local stylesheet, exactly the shape webtrust.py used to ship: its own
+#: `:root` re-declaring role tokens as literal hexes.
+_PAGE_LOCAL_SHEET = (
+    '\n_LEDGER_MUTATION_CSS = "<style>:root{--ground:#0D0D0C;--amber:#D9A253}</style>"\n'
+)
 
-    BOTH halves of that one site must go: it carries a literal COLOUR pair AND
-    a literal `font:16px`/`padding:32px`. Replacing only the palette left the
-    site in the LITERAL bucket and the count unchanged at 66 -- the harness
-    caught that as a non-discriminating mutation, which is what it is for.
-    """
-    w.replace(
-        WEBPWA,
-        "background:#0D0D0C;color:#F2EEE6;",
-        "background:var(--color-ground);color:var(--ink-primary);",
-    )
-    w.replace(WEBPWA, "font:16px -apple-system,sans-serif;padding:32px;", "")
 
+def _mo005_a_literal_inline_site_returns(w: World) -> None:
+    """REGRESSION: one inline `style=` attribute carries a literal colour again.
 
-def _mo005b_the_page_local_palette_goes(w: World) -> None:
-    """FIXED (the OTHER half): webtrust.py's page-local `<style>` block stops
-    declaring its own retired palette -- the eight literal colour declarations
-    at webtrust.py:258-259 go, as they would if the module imported the token
-    CSS instead of copying it.
+    Core 4 tolerates ZERO, so a single site is the whole defect -- which is why
+    this mutation is one line rather than a re-creation of the 66 the row
+    closed.
+    """
+    w.append(WIDGETS, _LITERAL_INLINE_SITE)
 
-    This is the half Core 4's frozen text could not reach until the 2026-09-04
-    DRAFT true-up widened it, so it gets its OWN mutation: `_mo005_...` proves
-    the INLINE bucket discriminates and says nothing about a `<style>` block.
+
+def _mo005b_a_page_local_stylesheet_returns(w: World) -> None:
+    """REGRESSION: a module outside the token module ships its own stylesheet
+    again, re-declaring role tokens as literal hexes -- the second-source-of-
+    visual-truth defect the 2026-09-04 true-up widened Core 4 to reach, and the
+    one webtrust.py held for three palette generations without anyone noticing.
     """
-    w.replace(
-        WEBTRUST,
-        "  --ground:#0D0D0C; --raise:#151513; --ink:#F2EEE6; --mid:#A6A199;\n"
-        "  --quiet:#9C978F; --amber:#D9A253; --rule:#1F1F1D; --rule-hi:#333330;\n",
-        "",
-    )
+    w.append(WEBTRUST, _PAGE_LOCAL_SHEET)
 
 
 _UNREGISTERED_SITE = "\n_LEDGER_MUTATION = f'<div style=\"height:{0}px\"></div>'\n"
@@ -870,13 +872,27 @@ def _mo024_the_hero_good_half_is_deferred_again(w: World) -> None:
     )
 
 
-def _mo025_the_literal_style_row_goes_green(w: World) -> None:
-    """FIXED: OSV1-005 closes, so Conformance 6's deferred good half should now
-    pass -- and this row must be re-derived from the PASSING pair."""
+def _mo024_the_hero_row_goes_red_again(w: World) -> None:
+    """REGRESSION: OSV1-001 reopens, so Conformance 5 is no longer demonstrated
+    end-to-end. The two move together by construction, and this proves
+    OSV1-024's probe still notices when its partner row does not agree."""
     w.replace(
         ROWS_PATH,
-        "  disposition: VIOLATION\n  work: work_item_pipeline-np3",
-        "  disposition: CONFORMS\n  work: work_item_pipeline-np3",
+        "  disposition: CONFORMS\n  work: work_item_pipeline-ujy",
+        "  disposition: VIOLATION\n  work: work_item_pipeline-ujy",
+    )
+
+
+def _mo025_the_literal_style_row_goes_red_again(w: World) -> None:
+    """REGRESSION: OSV1-005 reopens, so Conformance 6 is no longer demonstrated
+    end-to-end. Anchored on the row's own probe ref, because `work_item_
+    pipeline-np3` now names TWO green rows (OSV1-005 and OSV1-032)."""
+    w.replace(
+        ROWS_PATH,
+        "  disposition: CONFORMS\n  work: work_item_pipeline-np3\n"
+        "  assertion:\n    kind: probe\n    ref: test_row_osv1_005",
+        "  disposition: VIOLATION\n  work: work_item_pipeline-np3\n"
+        "  assertion:\n    kind: probe\n    ref: test_row_osv1_005",
     )
 
 
@@ -891,11 +907,16 @@ def _mo026_the_empty_slot_row_goes_green(w: World) -> None:
 
 
 def _mo032_the_register_grows(w: World) -> None:
-    """Freeze 6's enumerated half moves. NOTE, honestly: the OTHER half (zero
-    literal sites remaining) is not simulable in memory -- it would mean
-    rewriting 66 real sites -- so this mutation proves the enumerated half
-    only. OSV1-005's own mutation is what proves the LITERAL bucket
-    discriminates.
+    """Freeze 6's enumerated half moves: an inline computed-geometry site that
+    is not on the register appears.
+
+    THE HONEST NOTE THIS CARRIED AT SEED IS NOW OBSOLETE, and saying so is part
+    of the record: while the row was GAP, its other half ("no literal site
+    remaining") could not be simulated in memory, because simulating the FIXED
+    world meant rewriting 66 real sites. Now that the row is CONFORMS the
+    direction reversed -- reinstating ONE literal site is the whole defect --
+    so both halves get their own mutation below and this row's evidence is no
+    longer partial.
     """
     w.append(WIDGETS, _UNREGISTERED_SITE)
 
@@ -1026,8 +1047,10 @@ def _mo034_the_changelog_records_a_look(w: World) -> None:
     ),
     Mutation(
         "OSV1-003",
-        "the retired palette a calm sweep would catch is tokenised away",
-        _mo003_retired_palette_removed,
+        "the retired pre-blend-3 palette comes back to webpwa.py's offline body "
+        "(the specimen this row pinned as PRESENT until OSV1-005 closed it, now "
+        "guarded from the other side)",
+        _mo003b_the_retired_palette_returns,
     ),
     Mutation(
         "OSV1-004",
@@ -1036,15 +1059,16 @@ def _mo034_the_changelog_records_a_look(w: World) -> None:
     ),
     Mutation(
         "OSV1-005",
-        "the worst literal INLINE site is migrated (census 66 -> 65)",
-        _mo005_the_worst_literal_site_is_migrated,
+        "one inline `style=` attribute carries a literal colour again (Core 4 "
+        "tolerates zero, so one site is the whole defect)",
+        _mo005_a_literal_inline_site_returns,
     ),
     Mutation(
         "OSV1-005",
-        "webtrust.py's page-local `<style>` block stops declaring its own retired "
-        "palette (block census 40 -> 32) -- the half Core 4 could not reach before "
-        "the 2026-09-04 true-up",
-        _mo005b_the_page_local_palette_goes,
+        "a module outside the token module ships its own stylesheet again, "
+        "re-declaring role tokens as literal hexes -- the second-source-of-visual-"
+        "truth half Core 4 could not reach before the 2026-09-04 true-up",
+        _mo005b_a_page_local_stylesheet_returns,
     ),
     Mutation(
         "OSV1-006",
@@ -1174,10 +1198,15 @@ def _mo034_the_changelog_records_a_look(w: World) -> None:
         "Conformance 5's good half is deferred again behind an xfail naming OSV1-001",
         _mo024_the_hero_good_half_is_deferred_again,
     ),
+    Mutation(
+        "OSV1-024",
+        "OSV1-001 reopens, so Conformance 5 is no longer demonstrated end-to-end",
+        _mo024_the_hero_row_goes_red_again,
+    ),
     Mutation(
         "OSV1-025",
-        "OSV1-005 closes, so Conformance 6's deferred good half should now pass",
-        _mo025_the_literal_style_row_goes_green,
+        "OSV1-005 reopens, so Conformance 6 is no longer demonstrated end-to-end",
+        _mo025_the_literal_style_row_goes_red_again,
     ),
     Mutation(
         "OSV1-026",
@@ -1223,10 +1252,22 @@ def _mo034_the_changelog_records_a_look(w: World) -> None:
     ),
     Mutation(
         "OSV1-032",
-        "the exemption register grows (the zero-literal half is not in-memory simulable "
-        "-- OSV1-005's mutation is what proves the LITERAL bucket discriminates)",
+        "the exemption register grows (Freeze 6's enumerated half)",
         _mo032_the_register_grows,
     ),
+    Mutation(
+        "OSV1-032",
+        "a literal inline site returns (Freeze 6's second conjunct, inline half -- "
+        "simulable now that the row is green; it was not while simulating the FIX "
+        "meant rewriting 66 real sites)",
+        _mo005_a_literal_inline_site_returns,
+    ),
+    Mutation(
+        "OSV1-032",
+        "a page-local stylesheet returns with literal declarations (Freeze 6's "
+        "second conjunct, `<style>`-block half)",
+        _mo005b_a_page_local_stylesheet_returns,
+    ),
     Mutation(
         "OSV1-033",
         "the corrected Changelog quotation re-acquires the markdown emphasis that "
diff --git a/ledger/checks/test_operator_rows.py b/ledger/checks/test_operator_rows.py
index ad47800..54108d8 100644
--- a/ledger/checks/test_operator_rows.py
+++ b/ledger/checks/test_operator_rows.py
@@ -401,15 +401,20 @@ def test_row_osv1_003() -> None:
             f"`--blocked` on a calm page, re-derive this row from the new sweep "
             f"(work_item_pipeline-qgo)."
         )
-    assert contains(WEBPWA, "background:#0D0D0C;color:#F2EEE6"), (
-        "OSV1-003 (Core 2): the retired palette at webpwa.py:121-122 is gone. That is "
-        "the Conformance 1 bad fixture's specimen and a Core 4 violation closing "
-        "(OSV1-005) -- re-derive both rows."
+    # THE PALETTE SPECIMENS CLOSED 2026-09-05 (work_item_pipeline-np3, OSV1-005).
+    # This row's own VIOLATION is unchanged -- a calm L1 still paints `--blocked`,
+    # which is what the recorded sweep above measures. But the two specimens it
+    # also named are gone from the tree, so they are asserted from the OTHER side
+    # now: a pin that a defect is still present would be a false pin, and silently
+    # deleting the assertions would lose the only in-process guard that the
+    # retired palette does not come back.
+    assert not contains(WEBPWA, "#0D0D0C"), (
+        "OSV1-003 (Core 2) REGRESSION: the retired pre-blend-3 ground is back in "
+        "webpwa.py's offline body. Core 4 (OSV1-005) closed it on 2026-09-05."
     )
-    assert contains(WEBTRUST, "--amber:#D9A253"), (
-        "OSV1-003 (Core 2): webtrust.py's retired `--amber:#D9A253` is gone -- the "
-        "hardcoded amber outside the token set that Conformance 1's bad half "
-        "reinstates. Re-derive this row and OSV1-005's note."
+    assert not contains(WEBTRUST, "#D9A253"), (
+        "OSV1-003 (Core 2) REGRESSION: webtrust.py hardcodes the retired amber again. "
+        "It consumes `webtheme.trust_style_tag()` now -- see OSV1-005."
     )
 
 
@@ -453,84 +458,67 @@ def test_row_osv1_004() -> None:
 
 
 def test_row_osv1_005() -> None:
-    """Core 4 VIOLATION pin: the literal-style census, RE-RUN here.
-
-    The count is computed, never transcribed, so this pin cannot drift away
-    from the tree. Two named specimens are asserted individually as well, so
-    that migrating the 44 easy `margin-top` sites while leaving the retired
-    palette in place does not look like progress the row did not make.
-
-    TWO HALVES since the 2026-09-04 DRAFT true-up widened Core 4: the inline
-    `style=` attribute census, and the `<style>`-BLOCK census the widening
-    made reachable. They are pinned separately so that fixing one while
-    leaving the other is progress the row records rather than a flip it did
-    not earn.
+    """Core 4 CONFORMS: the literal-style census, RE-RUN here, reads ZERO.
+
+    FLIPPED 2026-09-05 from VIOLATION (VIOLATION-MOVEMENT: the pin went red
+    because the tree moved TOWARD the clause). Flip direction is now
+    REGRESSION -- this probe asserts the invariant, and the mutations
+    reinstate each half of the closed defect.
+
+    BOTH HALVES, still measured separately, because they close for different
+    reasons and can regress independently: the inline `style=` attribute
+    census, and the `<style>`-BLOCK census the 2026-09-04 true-up made
+    reachable. The counts are COMPUTED here, never transcribed, so this row
+    cannot drift away from the tree.
     """
     literal = style_sites_in(LITERAL)
-    assert len(literal) == 66, (
-        f"OSV1-005 (Core 4) CENSUS MOVED: pinned 66 inline `style=` sites carrying a "
-        f"literal colour, font, or size; observed {len(literal)}.\n"
-        f"  If FEWER: the migration is under way -- update the pinned count (or flip "
-        f"the row to CONFORMS at zero) and retarget this probe IN THE SAME CHANGE "
-        f"(work_item_pipeline-np3). A passing pin is not conformance.\n"
-        f"  If MORE: a new literal site landed. That is a regression against a clause "
-        f"that tolerates zero.\n"
+    assert literal == [], (
+        f"OSV1-005 (Core 4) REGRESSION: {len(literal)} inline `style=` site(s) carry "
+        f"a literal colour, font, or size. Core 4 tolerates zero.\n"
+        f"  The fix is never a new inline value: add a class or a token to "
+        f"`webtheme.py` (the token module Core 4 names) and reference it.\n"
         f"  observed: {literal}"
     )
-    assert "webpwa.py:121" in literal, (
-        "OSV1-005 (Core 4): webpwa.py:121's retired-palette inline body is no longer "
-        "counted as a literal site -- the worst specimen in the census. Re-derive."
-    )
-    assert "webbrowse.py:814" in literal, (
-        "OSV1-005 (Core 4): webbrowse.py:814's textarea (literal font-size, max-width "
-        "and padding) is no longer counted. Re-derive."
-    )
-    total = len(inline_style_sites())
-    assert total == 137, (
-        f"OSV1-005 (Core 4): the total inline `style=` population moved from 137 to "
-        f"{total}. Neither direction is neutral -- re-run the census and re-derive "
-        f"both OSV1-005 and OSV1-006."
-    )
-
-    # --- the `<style>`-block half, reachable since the 2026-09-04 true-up ---
-    blocks = [(f, ln) for f, ln, _css in style_blocks_outside_token_module()]
-    assert blocks == [("webtrust.py", 256)], (
-        f"OSV1-005 (Core 4): the population of `<style>` blocks OUTSIDE the token "
-        f"module moved -- pinned exactly one, `webtrust.py:256` (the `_CSS` constant "
-        f"embedded at webtrust.py:374), observed {blocks}.\n"
-        f"  If GONE: webtrust.py now imports the token CSS -- that is the fix landing "
-        f"(work_item_pipeline-np3). Flip the block half of this row and retarget IN "
-        f"THE SAME CHANGE.\n"
-        f"  If MORE: a second module started shipping its own stylesheet, which is "
-        f"the defect Core 4 was widened to reach."
-    )
     block_literals = style_block_literal_sites()
-    assert len(block_literals) == 40, (
-        f"OSV1-005 (Core 4) `<style>`-BLOCK CENSUS MOVED: pinned 40 literal "
-        f"colour/font/size declarations inside a `<style>` block outside the token "
-        f"module; observed {len(block_literals)}.\n"
-        f"  If FEWER: the migration is under way -- update the pinned count (or flip "
-        f"the row to CONFORMS at zero on BOTH halves) and retarget this probe IN THE "
-        f"SAME CHANGE (work_item_pipeline-np3). A passing pin is not conformance.\n"
-        f"  If MORE: a new literal declaration landed in a page-local stylesheet.\n"
+    assert block_literals == [], (
+        f"OSV1-005 (Core 4) REGRESSION: {len(block_literals)} literal colour/font/size "
+        f"declaration(s) in a `<style>` block OUTSIDE the token module. A page-local "
+        f"stylesheet is a second source of visual truth -- the exact defect the "
+        f"2026-09-04 true-up widened this clause to reach.\n"
         f"  observed: {[f'{f}:{n} {d}' for f, n, d, _r in block_literals]}"
     )
-    palette = sorted(d for f, n, d, _r in block_literals if n in (258, 259))
-    assert palette == [
-        "--amber:#D9A253",
-        "--ground:#0D0D0C",
-        "--ink:#F2EEE6",
-        "--mid:#A6A199",
-        "--quiet:#9C978F",
-        "--raise:#151513",
-        "--rule-hi:#333330",
-        "--rule:#1F1F1D",
-    ], (
-        f"OSV1-005 (Core 4): the retired palette webtrust.py:258-259 hardcodes is no "
-        f"longer counted as literal -- observed {palette}. That block is the specimen "
-        f"the true-up widened Core 4 to reach, and the one Conformance 1's bad half "
-        f"reinstates. If it was tokenised, that is the fix landing: re-derive this row "
-        f"and OSV1-003 (work_item_pipeline-np3)."
+    blocks = [f"{f}:{ln}" for f, ln, _css in style_blocks_outside_token_module()]
+    assert blocks == [], (
+        f"OSV1-005 (Core 4): a module outside the token module started shipping a "
+        f"`<style>` block again: {blocks}.\n"
+        f"  This is not YET a Core 4 violation on its own -- the clause forbids "
+        f"literal colour/font/size INSIDE such a block, and the assertion above is "
+        f"what measures that. It is asserted here because zero is the shape this row "
+        f"was flipped on (`webtrust.py` now consumes `webtheme.trust_style_tag()`), "
+        f"and a page-local sheet reappearing is how the literal count comes back."
+    )
+    total = len(inline_style_sites())
+    assert total == 55, (
+        f"OSV1-005 (Core 4): the total inline `style=` population moved from 55 to "
+        f"{total}. Neither direction is neutral -- a DECREASE is convergent (Backlogged "
+        f"2 wants zero inline `style=` at all) and welcome, but it must be recorded "
+        f"here and in OSV1-006's register in the same change; an INCREASE is a new "
+        f"inline site whose bucket nobody has looked at. Re-run the census and "
+        f"re-derive both rows."
+    )
+    # The two specimens this row pinned by name while it was red -- asserted
+    # from the OTHER side now, so the fix cannot be silently undone.
+    assert not contains(WEBPWA, "background:#0D0D0C"), (
+        "OSV1-005 (Core 4) REGRESSION: webpwa.py's offline body carries the retired "
+        "pre-blend-3 ground again. It was the worst specimen in this census -- a "
+        "palette three generations stale, in a document that only ever renders when "
+        "the network is down, so nobody sees the drift."
+    )
+    assert contains(WEBTRUST, "T.trust_style_tag()"), (
+        "OSV1-005 (Core 4) REGRESSION: webtrust.py no longer emits the token module's "
+        "own style tag. It is the plain-HTTP trust page: it must stay SELF-CONTAINED "
+        "(inlined, never fetched), and `webtheme.TRUST_CSS` is how it gets the live "
+        "tokens inlined without re-declaring a palette of its own."
     )
 
 
@@ -546,29 +534,14 @@ def test_row_osv1_005() -> None:
 #: that as the failure to avoid, because two censuses disagree silently.
 EXEMPTION_REGISTER: frozenset[str] = frozenset(
     {
-        "chartsvg.py:268",
-        "chartsvg.py:464",
-        "chartsvg.py:488",
-        "webapp.py:1122",
-        "webapp.py:1144",
-        "webapp.py:1709",
-        "webapp.py:1711",
-        "webapp.py:1829",
-        "webapp.py:1832",
-        "webapp.py:2101",
-        "webapp.py:2142",
-        "webapp.py:2266",
-        "webapp.py:2572",
-        "webapp.py:3376",
-        "webapp.py:4421",
-        "webapp.py:4936",
-        "webtheme.py:4185",
-        "webtheme.py:4204",
-        "webtheme.py:4211",
-        "widgets.py:704",
-        "widgets.py:831",
-        "widgets.py:834",
-        "widgets.py:1110",
+        "webapp.py:1127",  # flex:{n} 1 0            -- state-bar segment ratio
+        "webapp.py:1823",  # width:{today_w}px       -- throughput bar, today
+        "webapp.py:1826",  # width:{prior_w}px       -- throughput bar, prior 6d
+        "webtheme.py:4197",  # {style}               -- axis ruler numeral offset
+        "webtheme.py:4216",  # left:{_grad_x(f):.1f}px -- graduation tick offset
+        "webtheme.py:4223",  # width:{px}px          -- age bar length
+        "widgets.py:837",  # width:{pct}%            -- status-mix segment (hatched)
+        "widgets.py:839",  # width:{pct}%            -- status-mix segment
     }
 )
 
@@ -1589,14 +1562,16 @@ def test_row_osv1_025() -> None:
         "register. ONE census, ONE register (Phase-1 ruling Need 2) -- a second copy "
         "disagrees with this one, silently."
     )
-    assert "OSV1-005" in _kit_deferred_rows(kit, "test_visual_single_source"), (
-        "OSV1-025 (Conformance 6) PIN BROKE THE RIGHT WAY: the good half is no longer "
-        "deferred against OSV1-005. Flip OSV1-005 AND this row and retarget both "
-        "probes in the same change (work_item_pipeline-np3)."
+    assert not _kit_deferred_rows(kit, "test_visual_single_source"), (
+        "OSV1-025 (Conformance 6) REGRESSION: Conformance 6's good half is deferred "
+        "again. This row is green because the pair PASSES -- the bad half reports the "
+        'contract\'s own `style="color:#D9A253"` specimen and an unregistered computed '
+        "site, and the good half passes over the real `src/` tree."
     )
-    assert row("OSV1-005")["disposition"] in PINNING_DISPOSITIONS, (
-        "OSV1-025 (Conformance 6) PIN BROKE THE RIGHT WAY: OSV1-005 is no longer red, "
-        "so Conformance 6's good half should now pass. Re-derive from the PASSING pair."
+    assert row("OSV1-005")["disposition"] not in PINNING_DISPOSITIONS, (
+        "OSV1-025 (Conformance 6) REGRESSION: OSV1-005 is red again, so Conformance 6 "
+        "is no longer demonstrated end-to-end. These two move together by "
+        "construction -- re-derive both."
     )
     assert contains(OPERATOR_CONTRACT_PATH, 'style="color:#D9A253"'), (
         "OSV1-025: Conformance 6's named bad specimen moved in the contract -- re-review the row."
@@ -1962,11 +1937,14 @@ def test_row_osv1_031() -> None:
         "to CONFORMS and retarget this probe to assert no Core row is red "
         "(work_item_pipeline-umm)."
     )
-    assert len(red) == 5, (
-        f"OSV1-031 (Freeze 5): pinned 5 red Core-carrying rows, observed {len(red)}: "
+    assert len(red) == 4, (
+        f"OSV1-031 (Freeze 5): pinned 4 red Core-carrying rows, observed {len(red)}: "
         f"{red}. Movement in either direction means this gate's tally changed -- update "
-        f"the pin and the row's notes in the same change. (Was 10 at seed; OSV1-009 "
-        f"went green 2026-09-04, work_item_pipeline-sxh.)"
+        f"the pin and the row's notes in the same change. (10 at seed; OSV1-009 went "
+        f"green 2026-09-04, work_item_pipeline-sxh; OSV1-015 and -016 went green "
+        f"2026-09-04, work_item_pipeline-8vv and -dg3; OSV1-001 and OSV1-004 went green "
+        f"2026-09-05, work_item_pipeline-ujy and the Tier-A kit; OSV1-005 went green "
+        f"2026-09-05, work_item_pipeline-np3.)"
     )
     assert {r["id"] for r in core_rows if r["disposition"] == "NOT-ASSERTABLE"} == {
         "OSV1-018",
@@ -1979,34 +1957,37 @@ def test_row_osv1_031() -> None:
 
 
 def test_row_osv1_032() -> None:
-    """Freeze 6 pin: the register is enumerated, but literal sites remain.
-
-    Freeze 6's "no literal colour, font, or size site remaining" reads through
-    Core 4, so the 2026-09-04 true-up widened what "site" means here too: an
-    inline `style=` attribute OR a declaration in a `<style>` block outside the
-    token module. Both halves are pinned separately -- migrating all 66 inline
-    sites while leaving webtrust.py's page-local stylesheet in place must NOT
-    read as this gate closing.
+    """Freeze 6 CONFORMS: the register is enumerated AND no literal site remains.
+
+    FLIPPED 2026-09-05 from GAP (VIOLATION-MOVEMENT). Freeze 6's second
+    conjunct -- "no literal colour, font, or size site remaining" -- reads
+    through Core 4, so the 2026-09-04 true-up made "site" mean BOTH an inline
+    `style=` attribute and a declaration in a `<style>` block outside the token
+    module. Both are now zero, so both conjuncts hold and this gate closes.
+
+    Still asserted as two separate halves: the failure mode this row exists to
+    prevent is stamping a Freeze gate on a green inline census while a
+    page-local stylesheet quietly hardcodes a palette. That failure mode does
+    not go away because the count reached zero once.
     """
     literal = style_sites_in(LITERAL)
-    assert literal, (
-        "OSV1-032 (Freeze 6) PIN BROKE THE RIGHT WAY (inline half): zero literal "
-        "colour/font/size INLINE sites remain. If the `<style>`-block half below is "
-        "also at zero, both of Freeze 6's conjuncts now hold -- flip OSV1-032 (and "
-        "OSV1-005) to CONFORMS and retarget both probes IN THE SAME CHANGE "
-        "(work_item_pipeline-np3). Note that a register at zero also fires Backlogged "
-        "2's promotion trigger."
-    )
-    assert style_block_literal_sites(), (
-        "OSV1-032 (Freeze 6) PIN BROKE THE RIGHT WAY (`<style>`-block half): zero "
-        "literal colour/font/size declarations remain in any `<style>` block outside "
-        "the token module. That is webtrust.py's retired palette closing -- the half "
-        "Core 4's frozen text could not reach until the 2026-09-04 true-up. Re-derive "
-        "this row and OSV1-005 in the same change (work_item_pipeline-np3)."
-    )
-    assert len(style_sites_in("COMPUTED")) == 23, (
-        "OSV1-032 (Freeze 6): the enumerated half moved -- see OSV1-006, which owns "
-        "the register itself."
+    assert literal == [], (
+        f"OSV1-032 (Freeze 6) REGRESSION (inline half): {len(literal)} literal "
+        f"colour/font/size inline site(s) are back, so Freeze 6's second conjunct no "
+        f"longer holds: {literal}. See OSV1-005, which owns the census."
+    )
+    block_literals = style_block_literal_sites()
+    assert block_literals == [], (
+        f"OSV1-032 (Freeze 6) REGRESSION (`<style>`-block half): "
+        f"{len(block_literals)} literal declaration(s) are back in a page-local "
+        f"stylesheet. See OSV1-005, which owns that census too."
+    )
+    computed = style_sites_in("COMPUTED")
+    assert len(computed) == 8, (
+        f"OSV1-032 (Freeze 6): the enumerated half moved -- 8 computed-geometry sites "
+        f"were enumerated when this gate closed, observed {len(computed)}. See "
+        f"OSV1-006, which owns the register itself; a DECREASE is convergent and "
+        f"welcome, and AT ZERO it fires Backlogged 2's promotion trigger."
     )
 
 
diff --git a/ledger/rows.yaml b/ledger/rows.yaml
index fbcabe5..67793ea 100644
--- a/ledger/rows.yaml
+++ b/ledger/rows.yaml
@@ -1033,8 +1033,8 @@
 
     HONEST LIMIT: this is a declaration check over the token block. A literal
     hue painted OUTSIDE the token system is not visible to it -- that is Core 4
-    (OSV1-005, which measures 66 such inline sites) and the calm-pixel sweep
-    (OSV1-003).
+    (OSV1-005, which measured 66 such inline sites and now measures zero) and
+    the calm-pixel sweep (OSV1-003).
 
 - id: OSV1-003
   title: a calm L1 paints 97 --blocked pixels with nothing blocked
@@ -1096,9 +1096,55 @@
     the light renders for the dark values -- reporting a confident zero for a
     page it had not examined. The tokens are read from the live page.
 
-    STILL TRUE, and still pinned by this probe: the retired-palette specimens
-    at webpwa.py:121-122 and webtrust.py:258-259 remain in the tree (also
-    scored by Core 4, OSV1-005).
+    THE TWO PALETTE SPECIMENS CLOSED 2026-09-05 (work_item_pipeline-np3,
+    OSV1-005), and this row's PROBE moved with them while its DISPOSITION did
+    not. Both are gone: webpwa.py's offline body carries no colour, font or
+    size at all (it asks the UA via `<meta name="color-scheme">`), and
+    webtrust.py ships no stylesheet -- it emits `webtheme.trust_style_tag()`,
+    which inlines the live tokens.
+
+    DISPOSITION UNCHANGED, VIOLATION, and for the reason the measurement above
+    gives: a calm L1 still paints `--blocked` with nothing blocked. The
+    specimens were never what made this row red -- the recorded sweep is.
+
+    THE PROBE'S TWO SPECIMEN ASSERTIONS FLIPPED SIDES rather than being
+    deleted. They pinned "the retired palette is still in the tree"; a pin that
+    a defect is present is a FALSE pin once the defect is gone, and silently
+    deleting them would drop the only in-process guard that the palette stays
+    gone. They now assert the palette is ABSENT from both modules.
+    `_mo003b_the_retired_palette_returns` proves the new guards discriminate;
+    `_mo003_the_calm_page_stops_painting_blocked` still proves the pixel pin
+    does.
+
+    THE CONFORMANCE 1 BAD FIXTURE no longer has an in-tree specimen to point
+    at, which is the good problem: it must now CONSTRUCT its hardcoded amber.
+    The contract's own named specimen (`style="color:#D9A253"`) is already
+    exactly that, and Conformance 6's bad half (OSV1-025) already runs it.
+
+    RE-RECORDED 2026-09-05 at highway wave-3 integration, on the union tree,
+    same pinned chromium 148.0.7778.0 / playwright 1.60.0. EVERY NUMBER THIS
+    ROW ASSERTS IS UNCHANGED -- L0 clean 0/0 in both themes, L1 0 `--alarm`
+    and 97 `--blocked` in both, swept areas identical, and the three
+    discrimination arms still read 10 531 / 264 / 16 681. The visual-truth
+    lane changed classes, not the calm page's status pixels.
+
+    WHAT DID MOVE, recorded because a re-record that only reports "no change"
+    is not a measurement: the `--watch` bucket, which this sweep collects and
+    Core 2 deliberately does NOT score. It fell 1 161 -> 979 px on a dark L1
+    on the first union recording -- a real regression the lane's chart-ink
+    migration introduced through a CSS-specificity trap (see OSV1-005's own
+    notes) -- and reads 1 161 again after the repair, byte-identical to the
+    pre-lane value.
+
+    HONEST LIMIT ON REPRODUCIBILITY, recorded rather than smoothed: the run
+    was repeated on this tree, and 290 of the 294 recorded fields are
+    byte-identical between runs -- including every field any row asserts. The
+    four that are not are the LIGHT-theme `--watch` counts, which jitter by up
+    to ~90 px on ~5 200 (under 2%) run to run, consistent with antialiasing at
+    the sweep's 8/255 hue tolerance. Nothing reads them. They are recorded as
+    observed; if a row ever wants to assert one, it must first pin down that
+    jitter rather than inherit it.
+
 - id: OSV1-004
   title: state is never colour-only -- measured on rendered L0/L1/L2, and it holds
   contract:
@@ -1153,7 +1199,7 @@
 
 - id: OSV1-005
   title: >-
-    66 inline style= sites and 40 <style>-block declarations carry a literal
+    zero inline style= sites and zero <style>-block declarations carry a literal
     colour, font, or size
   contract:
     file: contracts/operator-surface.v1.md
@@ -1161,87 +1207,128 @@
     quote: |
       Literal colour, font, or size in an inline `style=` attribute, or in a `<style>` block
       outside the token module (`webtheme.py`'s token block), is a violation; zero are tolerated.
-  disposition: VIOLATION
+  disposition: CONFORMS
   work: work_item_pipeline-np3
   assertion:
     kind: probe
     ref: test_row_osv1_005
   notes: >
-    PINNING ROW -- the probe asserts the CURRENT, KNOWN-WRONG shape on purpose;
-    a passing probe here is NOT conformance. Flip direction VIOLATION-MOVEMENT.
+    FLIPPED 2026-09-05 from VIOLATION (VIOLATION-MOVEMENT: the pinning probe
+    went red because the tree moved TOWARD the clause). The probe was retargeted
+    at the fixed shape in the same change, and its two mutations rewritten to
+    reinstate each half of the closed defect. Flip direction is now REGRESSION.
 
-    THE CENSUS LIVES HERE, NOT IN THE CONTRACT -- Phase-1 ruling Need 2: "the
-    register and the ceiling live in `ledger/`", so shrinking the count is a
-    convergent change needing no amendment and no SYNC re-hash. The probe
-    RE-RUNS this census every ledger run; the numbers below are its output on
-    4aaee50, not a transcription.
-
-    137 inline `style="` sites in `src/amplifier_work_tracker/` (parsed count
-    == raw count, asserted by the probe -- a parser that silently loses a site
-    would understate the violation):
-      LITERAL   66   chartsvg 1, webapp 44, webbrowse 15, webpwa 1, webtrust 3, widgets 2
-      COMPUTED  23   chartsvg 3, webapp 13, webtheme 3, widgets 4   -- see OSV1-006
-      TOKEN     48   chartsvg 5, webapp 20, webbrowse 15, widgets 8
-
-    CLASSIFICATION RULE, encoded in the probe so the census is reproducible
-    rather than asserted: LITERAL = a hex or rgb()/hsl() colour not routed
-    through `var(--token)`, OR a font-family/size/weight carrying a literal
-    value, OR a length literal (px/rem/em/%) on a size or spacing property.
-    COMPUTED = the declaration carries an interpolated `{...}` placeholder.
-    TOKEN = only `var(--token)` values and/or properties that are none of
-    colour, font or size. The parser splices Python string-literal
-    concatenation boundaries first, so an attribute split across adjacent
-    literals (webapp.py:1712, webbrowse.py:741) is read as ONE attribute.
-
-    THE 66 LITERAL SITES, enumerated so the migration has no ambiguity:
-      chartsvg.py:271
-      webapp.py:1677,1703,1712,1715,1742,2264,2267,2288,2293,2295,2297,2299,
-        2313,2330,2728,2750,2763,3008,3037,3050,3055,3100,3108,3109,3111,3112,
-        3113,3161,3170,3174,3178,3183,3342,3346,3350,3352,3356,3359,3363,4216,
-        4396,4909,4912,4918
-      webbrowse.py:499,580,645,654,741,747,753,759,763,767,792,798,850,868,869
-      webpwa.py:121
-      webtrust.py:326,343,382
-      widgets.py:1044,1061
-    The worst is webpwa.py:121 -- the service worker's offline body carries
-    `background:#0D0D0C;color:#F2EEE6;font:16px -apple-system,sans-serif`, the
-    RETIRED pre-blend-3 palette, while the live ground token is `#05070f`. The
-    webapp.py bulk is overwhelmingly `margin-top:Npx` spacing literals that
-    belong on the `--space-*` scale.
-
-    RE-READ 2026-09-04 against the owner-ratified DRAFT true-up #1 ("yep, do
-    it all."), which SETTLED the reading this row returned to the root at seed
-    and widened Core 4 to reach "a `<style>` block outside the token module
-    (`webtheme.py`'s token block)". Quote RE-ANCHORED to the widened sentence
-    -- same clause, and the sentence this row was always about. Disposition
-    unchanged (VIOLATION); the row now measures TWO halves, pinned separately
-    so that fixing one is progress it records rather than a flip it did not
-    earn.
-
-    THE `<style>`-BLOCK HALF, measured on this branch by the same probe: ONE
-    `<style>` block exists outside the token module -- webtrust.py:256-302
-    (the `_CSS` constant, embedded at webtrust.py:374) -- and it carries 40
-    literal colour/font/size declarations. Eight of them are the retired
-    pre-blend-3 palette this row recorded-but-did-not-score at seed:
-      webtrust.py:258  --ground:#0D0D0C  --raise:#151513  --ink:#F2EEE6  --mid:#A6A199
-      webtrust.py:259  --quiet:#9C978F   --amber:#D9A253  --rule:#1F1F1D  --rule-hi:#333330
-    The other 32 are literal fonts and sizes in the same sheet (Georgia/
-    Helvetica Neue font stacks, `font-size:32px`, `padding:52px 24px 80px`,
-    and so on). The block deliberately does not import `webtheme.CSS`
-    (webtrust.py:249-253 says so in its own comment) -- which is exactly why
-    it is a second source of visual truth, and exactly what the widened clause
-    forbids. It is also the specimen the Conformance 1 bad fixture reinstates.
-
-    HONEST LIMIT of the block census, the same one the inline census carries:
-    `classify_style` skips a size declaration whose value mentions `var(`, so
-    `border:1px solid var(--rule-hi)` is NOT counted as literal. That
-    under-counts rather than over-counts, which is the safe direction for a
-    pin; the rule is shared between both halves ON PURPOSE, so one cannot
-    quietly become stricter than the other.
-
-    NOT FIXED HERE, DELIBERATELY: the palette itself. That is
-    work_item_pipeline-np3's job, and this branch amends the contract and the
-    ledger only.
+    THE CENSUS STILL LIVES HERE, NOT IN THE CONTRACT -- Phase-1 ruling Need 2.
+    The probe RE-RUNS it on every ledger run; the numbers below are its output
+    on this change, not a transcription.
+
+    INLINE HALF, measured before and after:
+      LITERAL   66 -> 0    chartsvg 1->0, webapp 44->0, webbrowse 15->0,
+                           webpwa 1->0, webtrust 3->0, widgets 2->0
+      COMPUTED  23 -> 8    see OSV1-006, which owns the register
+      TOKEN     48 -> 47
+      TOTAL    137 -> 55
+    `<style>`-BLOCK HALF: 40 literal declarations -> 0, and the population of
+    blocks outside the token module went 1 -> 0.
+
+    HOW, so a reader can check the fix rather than trust the count. The literal
+    values did not move sideways into another file; they moved into the ONE
+    module Core 4 exempts by name:
+      webtheme.py  gains `SINGLE_SOURCE_CSS`, appended last in the cascade
+                   (so a utility beats the component rule it replaces without
+                   `!important` -- the priority the inline attribute used to
+                   buy, bought once). It carries the `.mt-*`/`.ml-*`/`.mr-*`
+                   spacing utilities, the `.hist-*` histogram rules, the
+                   `.fill-*`/`.mix-*` state fills, `tr.attn-row`, `.hero-alarm`,
+                   `h1.page-h1`, `.field-textarea`, and the chart fills.
+      webtheme.py  also splits `TOKENS_CSS` out of `CSS` (the token block
+                   alone; `CSS` is byte-identical to before, verified) and adds
+                   `TRUST_CSS` + `trust_style_tag()`.
+      webtrust.py  ships NO stylesheet and no style tag at all any more. It
+                   used to embed a page-local sheet re-declaring the whole role
+                   set as its own literal near-black-and-warm-amber values --
+                   the retired pre-blend-3 palette, drifted three generations
+                   behind the live `--color-ground:#05070f`. It now emits
+                   `webtheme.trust_style_tag()`, which INLINES `TRUST_CSS`
+                   (`TOKENS_CSS` + the page's own rules, all on `var()` tokens).
+                   The page stays self-contained -- inlined, never fetched --
+                   which it must: a device reading it has not installed the CA
+                   yet, so an external asset link would be a broken fetch at the
+                   worst possible moment.
+      webpwa.py    the offline body carries no colour, font or size AT ALL now,
+                   deliberately rather than by omission. It is produced with no
+                   stylesheet reachable (the service worker caches nothing, by
+                   design), so any styling it carries can only ever be a second,
+                   unverifiable copy of the visual truth -- which is exactly how
+                   it came to hold a three-generation-stale palette unnoticed.
+                   It asks the user agent instead:
+                   `<meta name="color-scheme" content="dark light">`.
+
+    SPACING WAS SNAPPED TO THE 4px SCALE, one documented rule applied
+    uniformly, ties rounding UP: 6->8, 10->12, 14->16, 18->20, 22->24, 30->32,
+    `.3rem`->4px. Maximum drift 2px on any one margin. That drift is the point
+    of the clause: the scale decides the value, not whoever last typed a number
+    into an attribute.
+
+    LAUNDERED LITERALS WERE COUNTED AS LITERALS, not exempted. Several sites
+    read as COMPUTED to the census only because a fixed string was built in
+    Python and interpolated (`heading_style` in three places,
+    `_CONTENT_MONO_STACK`, `seg_base`/`ax_base`, `_STATE_FILL`,
+    `_MIX_COLOR_VAR`, `_BUCKET_HEIGHT`). Those are literals wearing a
+    placeholder; they are gone too, which is most of why the register fell from
+    23 to 8. See OSV1-006.
+
+    HONEST LIMIT, unchanged and still the safe direction: `classify_style`
+    skips a size declaration whose value mentions `var(`, so
+    `border:1px solid var(--rule-hi)` is not counted as literal. It
+    under-counts rather than over-counts. Now that this row is green, that
+    limit means a literal length could hide beside a `var()` in the same
+    declaration -- narrower than it sounds (the value must mention `var(`), and
+    it is recorded here rather than fixed, because changing the rule would
+    change what BOTH halves measure and belongs in one change of its own.
+
+    ONE RENDERED BEHAVIOUR CHANGED ON PURPOSE, and it is reported rather than
+    folded in. The Blocked KPI card's icon carried its alarm ink as an INLINE
+    style, and an inline style outranks every stylesheet rule -- including
+    `.wt-observatory .kpi-card.is-blocked.is-zero .k .icon{color:var(--ink-quiet)}`,
+    which exists precisely so that "0 blocked" stops reading as alarm-red. That
+    rule had never been able to win. With the ink moved to `.icon.ic-blocked`
+    the is-zero rule now applies, so a calm screen paints one fewer alarm-
+    coloured pixel. That is the direction Core 2 asks for ("zero `--alarm`
+    pixels on a calm screen"), and it is a change in rendered output, so it is
+    named here. HONEST SCALE, added at integration: the icon is small enough
+    and antialiased enough that the Tier-B sweep measures NO change in the
+    scored buckets -- a calm L0 read 0 `--alarm` and 0 `--blocked` both before
+    and after. The cascade fix is real and readable in the stylesheet; the
+    pixel claim is "one fewer", not "measurably fewer".
+
+    A SECOND RENDERED CHANGE WAS FOUND AT INTEGRATION AND WAS A REGRESSION --
+    the same cascade trap, in the other direction, and the reason this section
+    no longer says "no other rendered output moved". Moving the chart ink out
+    of `chartsvg.py`'s inline `style=` into `.axis-label[data-watch]` /
+    `[data-val]` / `[data-today]` (specificity 0,2,0) put it BEHIND the
+    pre-existing `.wt-observatory .svg-chart .axis-label{fill:var(--ink-tertiary)}`
+    (0,3,0), which an inline attribute had always outranked. The watch band's
+    axis labels, the histogram's value labels and the velocity chart's
+    today tick therefore stopped painting their own ink, and `.val-label` lost
+    its default fill entirely (SVG falls back to black -- invisible on the dark
+    ground). MEASURED, not reasoned: the Tier-B re-record on the union tree read
+    979 `--watch` px on a dark L1 against 1 161 before. Repaired by scoping
+    every chart-ink selector through `.svg-chart` (>= 0,3,0, and later in the
+    cascade), and the re-recorded sweep reads 1 161 again -- byte-identical to
+    the pre-lane value. Guarded by two new discriminating tests in
+    `tests/unit/test_chartsvg.py`
+    (`test_chart_state_ink_outranks_the_generic_axis_label_rule`,
+    `test_every_chart_label_kind_has_a_default_ink`), each demonstrated failing
+    against the pre-fix stylesheet. Nothing else in the sweep moved.
+
+    Apart from those two, no rendered output moved except spacing, per the 4px
+    snap above.
+
+    NOT DONE HERE: `style=` is not gone -- 55 inline attributes remain, 47 of
+    them TOKEN-bucket (`color:var(--ink)`, `margin-top:var(--space-3)`,
+    `overflow-wrap:anywhere`) which Core 4 permits, and 8 computed-geometry.
+    Backlogged 2 ("no inline `style=` at all") is not claimed by this row.
 
 - id: OSV1-006
   title: every computed-geometry inline site is on the ledger's exemption register
@@ -1259,58 +1346,55 @@
     THIS ROW IS THE EXEMPTION REGISTER. Core 4 says the register lives in
     `ledger/`, not in the contract, "so that shrinking it is a convergent
     change requiring no amendment" -- Phase-1 ruling Need 2 made that binding
-    and forbade a ceiling constant in Core. The register is the 23 sites below;
-    the probe asserts computed-geometry sites are exactly this set. A DECREASE
-    is convergent (shrink the register, let the ledger confirm). An INCREASE --
-    a new inline computed site not listed here -- fails the probe loudly.
-
-    CONFORMS is honest and not circular: the claim is "no computed-geometry
-    site exists outside the register", and that is what the probe checks on
-    every run against a set fixed at this seed. It is not a claim that 23 is
-    an acceptable number; Backlogged 2 ("no inline `style=` at all") promotes
-    when this register reaches ZERO, and that promotion is a named contract
-    trigger, not a silent win.
-
-    THE REGISTER, measured 2026-09-04 against 4aaee50 -- 23 sites, each
-    carrying an interpolated value:
-      chartsvg.py:268   fill:{val_color}                      bar fill, resolved-count
-      chartsvg.py:464   {stub_style}                          axis stub, watch-vs-quiet
-      chartsvg.py:488   {value_style}                         value label
-      webapp.py:1122    {style}                               computed row style
-      webapp.py:1144    background:{swatch}                   legend swatch
-      webapp.py:1709    {seg_style}                           histogram segment
-      webapp.py:1711    {ax_style}                            axis label
-      webapp.py:1829    width:{today_w}px                     bar width (today)
-      webapp.py:1832    width:{prior_w}px                     bar width (prior)
-      webapp.py:2101    {row_style}                           computed row style
-      webapp.py:2142    background:{tint};box-shadow:inset 4px 0 0 {accent}
-      webapp.py:2266    color:{accent}                        computed accent
-      webapp.py:2572    {style}                               computed style
-      webapp.py:3376    {heading_style}                       computed heading
-      webapp.py:4421    {heading_style}                       computed heading
-      webapp.py:4936    {remove_heading_style}                computed heading
-      webtheme.py:4185  {style}                               computed style
-      webtheme.py:4204  left:{_grad_x(f):.1f}px               gradient stop offset
-      webtheme.py:4211  width:{px}px                          swatch width
-      widgets.py:704    color:var({color_var})                token chosen at runtime
-      widgets.py:831    width:{pct}%                          mix-bar width
-      widgets.py:834    width:{pct}%;background:var({_MIX_COLOR_VAR[key]})
-      widgets.py:1110   background:var({_MIX_COLOR_VAR[key]})
-
-    The three `webtheme.py` coordinates were RE-DERIVED on 2026-09-04 by
-    work_item_pipeline-sxh (OSV1-009), which added comment lines above them:
-    4120/4139/4146 -> 4131/4150/4157. Same three sites, same code, same
-    register SET -- only the line numbers moved. A `file:line` register is
-    coordinate-fragile by construction; any edit above a site shifts it.
-
-    HONEST LIMIT: several registered sites interpolate a COLOUR, not a
-    geometry (webapp.py:2142/2266, chartsvg.py:268, widgets.py:704/834/1110).
-    They pass Core 4's literal test because the value is computed rather than
-    literal, and several resolve to a `var(--token)` -- but "a bar width, a
-    chart offset" is the clause's own gloss of what the exemption is FOR.
-    Whether a computed COLOUR belongs on a computed-GEOMETRY register is a
-    reading this reconcile returns to the root rather than settling. They are
-    listed, not hidden.
+    and forbade a ceiling constant in Core. The probe asserts computed-geometry
+    sites are EXACTLY the set below. A DECREASE is convergent (shrink the
+    register, let the ledger confirm). An INCREASE -- a new inline computed site
+    not listed here -- fails the probe loudly.
+
+    THE REGISTER SHRANK 23 -> 8 on 2026-09-05 (work_item_pipeline-np3). That is
+    a convergent change and needs no amendment; it is recorded here because the
+    register IS this row.
+
+    THE REGISTER, measured 2026-09-05 -- 8 sites, each carrying a value that is
+    genuinely computed per render:
+      webapp.py:1127    flex:{n} 1 0              state-bar segment ratio
+      webapp.py:1823    width:{today_w}px         throughput bar, today
+      webapp.py:1826    width:{prior_w}px         throughput bar, prior 6 d
+      webtheme.py:4197  {style}                   axis ruler numeral offset
+      webtheme.py:4216  left:{_grad_x(f):.1f}px   graduation tick offset
+      webtheme.py:4223  width:{px}px              age bar length
+      widgets.py:837    width:{pct}%              status-mix segment (hatched)
+      widgets.py:839    width:{pct}%              status-mix segment
+    Every one is "a bar width, a chart offset" -- the clause's own gloss of what
+    this exemption is FOR.
+
+    THE ROOT'S TRIAGE RULING WAS APPLIED, and it is what removed 15 sites. Two
+    kinds were on the register that should not have been:
+      (a) A COMPUTED COLOUR. Six sites interpolated a colour rather than a
+          geometry (chartsvg.py:268, webapp.py:2142/2266, widgets.py:704/834/
+          1110). Every one of them was chosen from an ENUMERABLE set -- a
+          two-state today/not-today, a watch/not-watch band, a fixed five- or
+          six-slot state key -- so each became a class or a data attribute the
+          stylesheet resolves, and left the register. NONE of the six now
+          interpolates a colour inline; the "a token-derived colour may stay,
+          with its derivation noted" arm of the ruling was not needed.
+          widgets.py:834 kept its site because its WIDTH is real computed
+          geometry; only its background moved to a class.
+      (b) A LAUNDERED LITERAL. Nine sites read as computed only because a FIXED
+          string was assembled in Python and interpolated -- `{heading_style}`
+          three times, `{style}` for the content block, `{seg_style}`/
+          `{ax_style}`, `background:{swatch}`. Nothing about those was computed;
+          the placeholder was hiding a literal from the census. They are classes
+          now (`h1.page-h1`, `.content-block.mono-measure`, `.hist-seg`,
+          `.hist-ax`, `.sw.fill-*`).
+
+    A `file:line` register is coordinate-fragile by construction: any edit above
+    a site shifts it. That is deliberate -- it forces a human to look -- and it
+    is why the probe prints the observed set on failure.
+
+    AT ZERO THIS FIRES BACKLOGGED 2's promotion trigger ("no inline `style=` at
+    all"), which is an owner amendment, not a silent win. It is not zero: 8
+    remain, and each is a length or a ratio that genuinely depends on data.
 
 - id: OSV1-007
   title: no GET handler reaches a mutating adapter call
@@ -2272,14 +2356,14 @@
 
 - id: OSV1-025
   title: >-
-    Conformance 6 (inline-style register) -- fixture exists and discriminates,
-    good half deferred against OSV1-005
+    Conformance 6 (inline-style register) -- fixture exists, discriminates, and
+    its good half passes over the real tree
   contract:
     file: contracts/operator-surface.v1.md
     clause: Conformance 6
     quote: |
       **Test location:** `tests/conformance/operator_surface/test_tier_a.py` (Core 4).
-  disposition: GAP
+  disposition: CONFORMS
   work: work_item_pipeline-c1a
   assertion:
     kind: probe
@@ -2296,9 +2380,11 @@
         site is reported as unregistered -- injected over the census's OWN
         reader, so the real engine does the classifying and nothing on disk is
         touched.
-      GOOD, DEFERRED  66 literal inline sites and 40 `<style>`-block
-        declarations remain, so the good half is `xfail(strict=True)` naming
-        OSV1-005.
+      GOOD, PASSING (2026-09-05)  the good half runs the three conjuncts over
+        the real `src/` tree -- zero literal inline sites, zero unregistered
+        computed sites, zero literal declarations in a `<style>` block outside
+        the token module -- and passes. The `xfail(strict=True)` marker naming
+        OSV1-005 was deleted in the same change that closed OSV1-005.
 
     THE OVERLAP IS KEPT DELIBERATE, as this row required at seed: the kit does
     not grow its own census. It imports `ledger/checks/_support.py`'s engines
@@ -2308,9 +2394,17 @@
     asserts that the imported register and the live COMPUTED census agree, so
     the two cannot drift apart silently.
 
-    THIS ROW GOES GREEN WHEN OSV1-005 DOES. The probe asserts both facts -- the
-    fixture is present with its pair and reads the ledger's register, and
-    OSV1-005 is still red -- so flipping either one alone fails loudly.
+    FLIPPED 2026-09-05 from GAP (VIOLATION-MOVEMENT), in the same change that
+    closed OSV1-005 -- which is what this row said would happen ("THIS ROW GOES
+    GREEN WHEN OSV1-005 DOES"). Flip direction is now REGRESSION: the probe
+    asserts the good half is NOT deferred and that OSV1-005 is not red, so
+    reinstating either alone fails loudly.
+
+    The register the kit imports shrank 23 -> 8 in the same change (OSV1-006).
+    The kit needed no edit for that, which is the point of the one-register
+    ruling -- it reads `EXEMPTION_REGISTER` rather than keeping a copy, and its
+    own `..._the_register_is_the_ledgers_own` test re-proves the two agree on
+    every run.
 
 - id: OSV1-026
   title: >-
@@ -2574,18 +2668,25 @@
 
     NOT WHAT THIS ROW ASSERTS, recorded so a future reader does not widen it:
     Freeze 4 asks that every fixture's BAD half has been run and caught its
-    defect. It does not ask that every GOOD half passes. Conformance 6 and 7
-    still carry `xfail(strict)` good halves against the open product defects
-    OSV1-005 and OSV1-012, and those two rows (OSV1-025, OSV1-026) stay red for
-    exactly that reason. A strict xfail is a check that RUNS -- the deferral is
-    visible, the demonstration is not missing.
+    defect. It does not ask that every GOOD half passes. A strict xfail is a
+    check that RUNS -- the deferral is visible, the demonstration is not
+    missing.
+
+    UPDATED 2026-09-05 at highway wave-3 integration: Conformance 6's good half
+    is no longer deferred. The visual-truth lane closed OSV1-005, deleted the
+    `xfail(strict)` marker naming it, and OSV1-025 flipped GAP -> CONFORMS in
+    the same change. Conformance 7 (`calm.keeps_slot`, two good halves) is now
+    the ONLY deferred pair in the kit, against the still-open OSV1-012, and
+    OSV1-026 stays red for exactly that reason. This row's own disposition does
+    not move: its subject is the bad halves, all of which still run and still
+    catch their defects.
 
     THE HOUSE PRECEDENT this follows: the custody family's CCV1-023 recorded
     discrimination by REVERTING each fix in turn and observing exactly the
     matching bad half go red while every good half stayed green.
 - id: OSV1-031
   title: >-
-    Freeze 5 -- 5 of the 19 Core-carrying rows are still red, and all five are
+    Freeze 5 -- 4 of the 19 Core-carrying rows are still red, and all four are
     now MEASURED VIOLATIONs (no Core row is an unasserted GAP any more)
   contract:
     file: contracts/operator-surface.v1.md
@@ -2644,6 +2745,16 @@
     measurement (see its own notes and the tests named there), not flipped
     because a file appeared.
 
+    THE VISUAL-TRUTH LANE COUNTED SIX on its own pre-integration base
+    (work_item_pipeline-np3), where OSV1-015 and -016 were still red and the
+    browser tier did not exist. That count is SUPERSEDED by the wave-3 re-count
+    at the end of this row; it is left recorded rather than deleted because the
+    flip it carried is real and is the reason the tally moved:
+      OSV1-005 VIOLATION -> CONFORMS (work_item_pipeline-np3): zero literal
+                  inline sites and zero literal `<style>`-block declarations
+                  remain. Re-derived from the re-run census, not from a file
+                  appearing -- see OSV1-005's own before/after numbers.
+
     THE FAILURE MODE THIS ROW EXISTS TO CATCH: a GAP row whose only defect is
     "the kit is not built" being flipped to CONFORMS because a file now exists,
     rather than re-derived from the kit's real results. OSV1-004 was flipped
@@ -2682,10 +2793,28 @@
     Five red. Freeze 5 is met when all five are green and the two
     NOT-ASSERTABLE rows still name their cadence.
 
+    RE-COUNTED 2026-09-05 at highway wave-3 integration (orchestrator), FOUR
+    RED, computed by the probe against the union tree rather than transcribed
+    from any lane's own paragraph. ONE flip moves it: OSV1-005 (Core 4)
+    VIOLATION -> CONFORMS, the visual-truth lane (work_item_pipeline-np3),
+    re-derived from the census RE-RUN on this tree -- 0 literal inline sites
+    (66 on the base), 0 literal `<style>`-block declarations (40 on the base),
+    register 23 -> 8. The pin moves 5 -> 4, not 5 -> 6: the lane measured its
+    own base, where OSV1-015/-016 were still red and the browser tier did not
+    exist, and this integration re-measures rather than adopting that number.
+    The tally is now:
+      CONFORMS 13       OSV1-001, -002, -004, -005, -006, -007, -009, -011,
+                        -013, -014, -015, -016, -017
+      NOT-ASSERTABLE 2  OSV1-018 (Core 12), OSV1-019 (Core 13) -- unchanged
+      VIOLATION 4       OSV1-003, -008, -010, -012
+      GAP 0             every Core clause is still ASSERTED
+    Four red, every one of them a MEASURED failure. Freeze 5 is met when all
+    four are green and the two NOT-ASSERTABLE rows still name their cadence.
+
 - id: OSV1-032
   title: >-
-    Freeze 6 -- 66 literal inline sites and 40 <style>-block declarations
-    remain, so the register is not complete
+    Freeze 6 -- the exemption register is complete and no literal colour, font
+    or size site remains
   contract:
     file: contracts/operator-surface.v1.md
     clause: Freeze 6
@@ -2693,38 +2822,36 @@
       **Freeze 6:** the exemption register named in Core 4 is complete in `ledger/` — every
       computed-geometry inline-style site enumerated, and no literal colour, font, or size site
       remaining.
-  disposition: GAP
+  disposition: CONFORMS
   work: work_item_pipeline-np3
   assertion:
     kind: probe
     ref: test_row_osv1_032
   notes: >
-    PINNING ROW -- the probe pins that literal sites still remain; a passing
-    probe here is NOT conformance. Flip direction VIOLATION-MOVEMENT.
-
-    TWO CONJUNCTS, MEASURED SEPARATELY 2026-09-04 against 4aaee50:
-      "every computed-geometry inline-style site enumerated"  -- ALREADY TRUE.
-      OSV1-006 enumerates all 23 and asserts the set is exact on every run.
-      "no literal colour, font, or size site remaining"       -- FALSE. 66
-      remain (OSV1-005).
-    So this condition fails on its second half only, and it closes exactly when
-    OSV1-005 does. It is rowed separately rather than folded into OSV1-005
-    because it is the Freeze Bar's own gate: the register being COMPLETE is a
-    stronger statement than the census being CURRENT, and a future reader
-    stamping FROZEN reads this row, not the census row.
-
-    RE-READ 2026-09-04 against the DRAFT true-up #1. Freeze 6's own text is
-    UNCHANGED by the true-up and this row's quote still verifies byte-for-byte
-    -- but the word "site" in its second half reads through Core 4, and Core 4
-    was widened. So what this gate now requires is zero literal sites in BOTH
-    senses: inline `style=` attributes (66 remain) AND declarations in a
-    `<style>` block outside the token module (40 remain, all in
-    webtrust.py:256-302). The probe was extended to pin both halves
-    SEPARATELY, because the failure mode this row exists to prevent is exactly
-    the plausible one: migrating all 66 inline sites, seeing a green inline
-    census, and stamping a Freeze gate while a whole page-local stylesheet
-    still hardcodes the retired palette. Disposition unchanged (GAP); the same
-    work item (work_item_pipeline-np3) closes both halves.
+    FLIPPED 2026-09-05 from GAP (VIOLATION-MOVEMENT: the pinning probe went red
+    because both halves closed). Retargeted in the same change; flip direction
+    is now REGRESSION.
+
+    TWO CONJUNCTS, MEASURED SEPARATELY 2026-09-05:
+      "every computed-geometry inline-style site enumerated"  -- TRUE, and it
+      was already true at seed. OSV1-006 now enumerates 8 (was 23) and asserts
+      the set is EXACT on every run.
+      "no literal colour, font, or size site remaining"       -- NOW TRUE. 66
+      inline sites -> 0, and 40 `<style>`-block declarations -> 0 (OSV1-005).
+
+    THE WORD "site" READS THROUGH CORE 4, which the 2026-09-04 true-up widened,
+    so this gate required zero in BOTH senses: an inline `style=` attribute AND
+    a declaration in a `<style>` block outside the token module. Both are zero,
+    so the gate closes. The probe still asserts the two halves SEPARATELY, and
+    that is not redundancy: the failure mode this row exists to prevent is
+    stamping a Freeze gate on a green inline census while a page-local
+    stylesheet quietly hardcodes a palette. Reaching zero once does not retire
+    that failure mode.
+
+    ROWED SEPARATELY FROM OSV1-005 STILL, for the reason it always was: the
+    register being COMPLETE is a stronger statement than the census being
+    CURRENT, and a future reader stamping FROZEN reads this row, not the census
+    row.
 
 - id: OSV1-033
   title: Freeze 7 -- every quotation citing an in-repo file verifies against it
diff --git a/src/amplifier_work_tracker/chartsvg.py b/src/amplifier_work_tracker/chartsvg.py
index 8eab4af..a575155 100644
--- a/src/amplifier_work_tracker/chartsvg.py
+++ b/src/amplifier_work_tracker/chartsvg.py
@@ -252,6 +252,13 @@ def _cx(i: int) -> float:
         bh = _bar_height(day["resolved"])
         by = round(baseline_y - bh, 2)
         bx = round(cx - bar_width / 2, 2)
+        # STATE RIDES A DATA ATTRIBUTE, NOT THE CLASS. `class` here names what
+        # the element IS (bar / val-label / axis-label / zero-stub) and the
+        # chart's structure tests read it as exactly that; "which day is today"
+        # and "is this the watch band" are state, so they are data attributes
+        # the stylesheet selects on (`.val-label[data-today]`, webtheme's
+        # SINGLE_SOURCE_CSS). No fill is named in this file.
+        today_attr = ' data-today="1"' if is_today else ""
         bar_style = ' style="fill:var(--brand-cyan-ink)"' if is_today else ""
         bars.append(
             f'<rect class="bar" x="{bx}" y="{by}" width="{bar_width}" height="{bh}" rx="3"'
@@ -262,16 +269,15 @@ def _cx(i: int) -> float:
             # --ink-quiet -> --ink-tertiary (visual-polish punchlist item
             # 1): an in-chart value label is functional data-ink, not
             # decoration.
-            val_color = "var(--brand-cyan-ink)" if is_today else "var(--ink-tertiary)"
             val_labels.append(
-                f'<text class="val-label" x="{cx}" y="{round(by - 6, 2)}" text-anchor="middle" '
-                f'style="fill:{val_color}">{int(day["resolved"])}</text>'
+                f'<text class="val-label"{today_attr} x="{cx}" y="{round(by - 6, 2)}" '
+                f'text-anchor="middle">{int(day["resolved"])}</text>'
             )
 
-        axis_style = ' style="fill:var(--brand-cyan-ink);font-weight:600"' if is_today else ""
         axis_labels.append(
-            f'<text class="axis-label" x="{cx}" y="{round(baseline_y + 18, 2)}" '
-            f'text-anchor="middle"{axis_style}>{_esc(day["label"])}</text>'
+            f'<text class="axis-label"{today_attr} x="{cx}" '
+            f'y="{round(baseline_y + 18, 2)}" '
+            f'text-anchor="middle">{_esc(day["label"])}</text>'
         )
 
         if not is_all_zero:
@@ -455,15 +461,16 @@ def age_histogram(
         bx = round(cx - bar_width / 2, 2)
         is_watch = bucket["is_watch"]
         count = bucket["count"]
+        # See `velocity_chart` above: `class` is WHAT the element is, state
+        # rides a data attribute the stylesheet selects on.
+        watch_attr = ' data-watch="1"' if is_watch else ""
 
         if count <= 0:
             by = round(baseline_y - zero_stub_height, 2)
-            stub_style = "fill:var(--watch)" if is_watch else "fill:var(--ink-quiet)"
             bars.append(
-                f'<rect x="{bx}" y="{by}" width="{bar_width}" height="{zero_stub_height}" '
-                f'rx="1" style="{stub_style}"/>'
+                f'<rect class="zero-stub"{watch_attr} x="{bx}" y="{by}" '
+                f'width="{bar_width}" height="{zero_stub_height}" rx="1"/>'
             )
-            label_style = ' style="fill:var(--watch)"' if is_watch else ""
         else:
             bh = round((count / max_count) * max_bar_height, 2)
             by = round(baseline_y - bh, 2)
@@ -473,24 +480,21 @@ def age_histogram(
                     f'<rect x="{bx}" y="{by}" width="{bar_width}" height="{bh}" rx="3" '
                     'style="fill:var(--watch)"/>'
                 )
-                value_style = "fill:var(--watch);font-weight:600"
-                label_style = ' style="fill:var(--watch)"'
             else:
                 bars.append(
                     f'<rect class="bar" x="{bx}" y="{by}" width="{bar_width}" height="{bh}" '
                     'rx="3"/>'
                 )
-                value_style = "fill:var(--ink-primary);font-weight:600"
-                label_style = ""
 
             value_labels.append(
-                f'<text class="axis-label" x="{cx}" y="{round(by - 4, 2)}" text-anchor="middle" '
-                f'style="{value_style}">{int(count)}</text>'
+                f'<text class="axis-label" data-val="1"{watch_attr} x="{cx}" '
+                f'y="{round(by - 4, 2)}" text-anchor="middle">{int(count)}</text>'
             )
 
         axis_labels.append(
-            f'<text class="axis-label" x="{cx}" y="{round(baseline_y + 16, 2)}" '
-            f'text-anchor="middle"{label_style}>{_esc(bucket["label"])}</text>'
+            f'<text class="axis-label"{watch_attr} x="{cx}" '
+            f'y="{round(baseline_y + 16, 2)}" text-anchor="middle">'
+            f"{_esc(bucket['label'])}</text>"
         )
 
     return (
diff --git a/src/amplifier_work_tracker/webapp.py b/src/amplifier_work_tracker/webapp.py
index 27818de..110c8c2 100644
--- a/src/amplifier_work_tracker/webapp.py
+++ b/src/amplifier_work_tracker/webapp.py
@@ -1053,25 +1053,24 @@ def _secondary_readings_html(
 
 
 _STATE_ORDER = ("ready", "held", "blocked", "deferred", "resolved")
-_STATE_FILL = {
-    "ready": "var(--st-ready)",
-    "held": "var(--amber)",  # same hue as `.state.warnv` elsewhere -- held
-    # is ATTENTION, not alarm, not good news; never a second, competing hue.
-    "blocked": "var(--crimson)",  # same hue as `.st-blkd` -- escalation.
-    "deferred": "var(--st-deferred)",
-    "resolved": "var(--st-resolved)",
-}
+# THE FILL PER STATE IS NOT DECLARED HERE ANY MORE. It used to be a dict of
+# token names interpolated into an inline `background:` -- a second place the
+# workspace bar's palette lived, and one the stylesheet could not see. It is
+# now `.sbar i.fill-*` / `.sw.fill-*` in webtheme's SINGLE_SOURCE_CSS, keyed by
+# the same `_STATE_ORDER` slot name this module already emits as a class:
+# held reuses --amber (ATTENTION, not alarm, not good news -- never a second,
+# competing hue), blocked reuses --crimson (escalation, same hue as `.st-blkd`),
+# and a zero-count slot draws `--st-empty` via `.sw.fill-empty`.
 
 # The three states that must never render as a mere hairline once they go
 # non-zero -- see `_state_bar_html`'s own comment for why the hue alone
 # (already correct: held/blocked already reuse the app's amber/crimson
-# escalation hues) is not enough on a workspace with hundreds of items.
+# escalation hues) is not enough on a workspace with hundreds of items. The
+# floor WIDTH itself (bigger than the calm seam's 3px `--st-empty`, small
+# enough it never dominates a genuinely large count -- flex-grow still wins
+# once the real proportional width exceeds it) is `.sbar i.alarm-floor` in
+# webtheme; this set is only which states get it.
 _ALARM_STATES = frozenset({"held", "blocked", "deferred"})
-# A real alarm segment's floor width -- bigger than the calm seam's 3px
-# (`--st-empty`, see webtheme.py), small enough it never dominates a
-# genuinely large count (flex-grow still wins once the real proportional
-# width would exceed this floor; this only ever WIDENS a would-be sliver).
-_ALARM_MIN_PX = 16
 
 
 def _state_counts(s: A.ProjectSummary) -> dict[str, int]:
@@ -1116,10 +1115,16 @@ def _state_bar_html(counts: dict[str, int]) -> str:
     for key in _STATE_ORDER:
         n = counts[key]
         if n > 0:
-            style = f"flex:{n} 1 0;background:{_STATE_FILL[key]}"
+            # The FILL and the alarm-state minimum width are slot facts, so
+            # they are class names resolved in the stylesheet (`.sbar i.fill-*`
+            # / `.sbar i.alarm-floor`, webtheme's SINGLE_SOURCE_CSS). Only the
+            # flex RATIO is genuinely computed per render, and it is the one
+            # thing left inline -- the registered computed-geometry exemption
+            # (ledger OSV1-006).
+            cls = f"fill-{key}"
             if key in _ALARM_STATES:
-                style += f";min-width:{_ALARM_MIN_PX}px"
-            parts.append(f'<i style="{style}"></i>')
+                cls += " alarm-floor"
+            parts.append(f'<i class="{cls}" style="flex:{n} 1 0"></i>')
         else:
             parts.append('<span class="seam"></span>')
     return f'<div class="sbar">{"".join(parts)}</div>'
@@ -1138,10 +1143,10 @@ def _state_legend_html(counts: dict[str, int]) -> str:
     items = []
     for key in _STATE_ORDER:
         n = counts[key]
-        swatch = _STATE_FILL[key] if n else "var(--st-empty)"
+        fill = f"fill-{key}" if n else "fill-empty"
         cls = "n" if n else "n z"
         items.append(
-            f'<div class="li"><span class="sw" style="background:{swatch}"></span>'
+            f'<div class="li"><span class="sw {fill}"></span>'
             f'<span class="{cls}">{n}</span><span class="l">{key}</span></div>'
         )
     return f'<div class="legend">{"".join(items)}</div>'
@@ -1648,7 +1653,10 @@ def _status_tabs_html(name: str, status: str | None, q: str, counts: dict[str, i
     return f'<nav class="tabs" aria-label="Filter items by status">{"".join(tabs)}</nav>'
 
 
-_BUCKET_HEIGHT = {"0-1": 12, "2-3": 22, "4-6": 34, "7+": 44}
+# The band -> tick-class map. The tick HEIGHT that used to sit beside it here
+# (12/22/34/44px, interpolated into every single tick's `style=`) is now
+# `.ticks .tick.t0..t3` in webtheme's SINGLE_SOURCE_CSS -- same four values,
+# declared once in the stylesheet instead of once per rendered tick.
 _BUCKET_BAND = {"0-1": "t0", "2-3": "t1", "4-6": "t2", "7+": "t3"}
 
 
@@ -1674,23 +1682,16 @@ def _heartbeat_html(buckets: dict[str, int]) -> str:
         empty_note = "Nothing is ready to be claimed anywhere."
         return (
             '<div class="beat"><span class="eyebrow">Ready queue by age</span>'
-            f'<div class="subtle" style="margin-top:14px">{empty_note}</div></div>'
+            f'<div class="subtle mt-4">{empty_note}</div></div>'
         )
-    seg_base = (
-        "flex:1 1 0;min-width:0;display:flex;align-items:flex-end;gap:2px;"
-        "overflow:hidden;padding:0 8px"
-    )
-    ax_base = (
-        "flex:1 1 0;min-width:0;display:flex;flex-direction:column;"
-        "align-items:center;gap:3px;padding:0 8px"
-    )
-    divider = ";border-left:1px solid var(--rule)"
+    # The band geometry (segment/axis-column layout, the between-band divider,
+    # every tick's height, the axis label's type) is `.hist-*` in webtheme's
+    # SINGLE_SOURCE_CSS. This function decides only WHICH band a thing is in.
     segments = []
     axis = []
     for idx, (label, lo, hi) in enumerate(A.READY_AGE_BUCKETS):
         n = buckets.get(label, 0)
         band = _BUCKET_BAND[label]
-        height = _BUCKET_HEIGHT[label]
         # readable day-range for this band -- the axis unit the old
         # "FRESHER -> OLDER" strip lacked: "0-1d", "2-3d", "4-6d", "7d+".
         if hi is None:
@@ -1699,21 +1700,14 @@ def _heartbeat_html(buckets: dict[str, int]) -> str:
             day = f"0\u2013{hi}d"
         else:
             day = f"{lo}\u2013{hi}d"
-        ticks = "".join(
-            f'<span class="tick {band}" style="height:{height}px;flex:0 0 3px"></span>'
-            for _n in range(n)
-        )
-        seg_style = seg_base + (divider if idx else "")
-        ax_style = ax_base + (divider if idx else "")
-        num_color = "var(--amber)" if (hi is None and n) else "var(--mid)"
-        segments.append(f'<span style="{seg_style}">{ticks}</span>')
+        ticks = "".join(f'<span class="tick {band}"></span>' for _n in range(n))
+        divided = " divided" if idx else ""
+        hot = " hot" if (hi is None and n) else ""
+        segments.append(f'<span class="hist-seg{divided}">{ticks}</span>')
         axis.append(
-            f'<span style="{ax_style}">'
-            '<span style="font-family:var(--sans);font-size:10px;font-weight:500;'
-            "letter-spacing:.1em;text-transform:uppercase;color:var(--dim);"
-            f'white-space:nowrap">{_esc(day)}</span>'
-            '<span style="font-family:var(--sans);font-size:14px;font-weight:500;'
-            f'line-height:1;color:{num_color}">{n}</span></span>'
+            f'<span class="hist-ax{divided}">'
+            f'<span class="hist-day">{_esc(day)}</span>'
+            f'<span class="hist-num{hot}">{n}</span></span>'
         )
     fresh = buckets.get("0-1", 0)
     stale = buckets.get("7+", 0)
@@ -1739,7 +1733,7 @@ def _heartbeat_html(buckets: dict[str, int]) -> str:
     {legend}
   </div>
   <div class="ticks" role="img" aria-label="{aria}">{"".join(segments)}</div>
-  <div style="display:flex;margin-top:8px">{"".join(axis)}</div>
+  <div class="hist-axis">{"".join(axis)}</div>
 </div>"""
 
 
@@ -2075,17 +2069,18 @@ def _dashboard_row(s: A.ProjectSummary) -> str:
         # 5 of 10 attempts against a healthy project. Amber "Unavailable"
         # says the true thing: unknown, not bad.
         unavailable = A.is_unavailable_status(st)
+        # The accent and its tint always travel together, so they are ONE
+        # class (`tr.attn-row` / `tr.attn-row.is-blocked`, webtheme's
+        # SINGLE_SOURCE_CSS) rather than two strings a caller could pair
+        # wrongly -- and the pair is declared where every other status hue is.
         if creating:
-            kind, word, accent = "warn", "Provisioning", "var(--amber)"
-            tint = "var(--alarm-surface)"
+            kind, word, tone = "warn", "Provisioning", ""
             detail = "Being created \u2014 counts appear once its database is ready."
         elif unavailable:
-            kind, word, accent = "warn", "Unavailable", "var(--amber)"
-            tint = "var(--alarm-surface)"
+            kind, word, tone = "warn", "Unavailable", ""
             detail = st  # "UNAVAILABLE: ..." (already truncated by the adapter)
         else:
-            kind, word, accent = "bad", "Broken", "var(--crimson)"
-            tint = "var(--blocked-surface)"
+            kind, word, tone = "bad", "Broken", " is-blocked"
             detail = st  # e.g. "ERROR: ..." (already truncated by the adapter)
         # keep the reading width sane: one legible line, full text on hover
         shown = detail if len(detail) <= 120 else detail[:119] + "\u2026"
@@ -2096,9 +2091,8 @@ def _dashboard_row(s: A.ProjectSummary) -> str:
         else:
             state_word = "broken"
         key = f"{s.name} {state_word} {st}".lower()
-        row_style = f"background:{tint};box-shadow:inset 4px 0 0 {accent}"
         return (
-            f'<tr class="alarm" data-t="{_esc(key)}" style="{row_style}">'
+            f'<tr class="alarm attn-row{tone}" data-t="{_esc(key)}">'
             f'<td class="link-cell"><a href="/projects/{_esc(s.name)}">{_esc(s.name)}</a></td>'
             f'<td colspan="5"><span class="c">{T.state_html(kind, word)} '
             f'<span class="muted" title="{_esc(st)}" style="overflow-wrap:anywhere">'
@@ -2135,18 +2129,16 @@ def _dashboard_row(s: A.ProjectSummary) -> str:
     # (.12 alpha), since "this queue has a stuck item" is real attention,
     # not "this queue's backend cannot be read."
     alarm_active = bool(counts["held"] or counts["blocked"] or counts["deferred"])
-    row_style = ""
+    row_cls = ""
     if alarm_active:
-        accent = "var(--crimson)" if counts["blocked"] else "var(--amber)"
-        tint = "var(--blocked-surface)" if counts["blocked"] else "var(--alarm-surface)"
-        row_style = f' style="background:{tint};box-shadow:inset 4px 0 0 {accent}"'
+        row_cls = ' class="attn-row is-blocked"' if counts["blocked"] else ' class="attn-row"'
 
     key_bits = [s.name]
     key_bits += [state for state in ("held", "blocked", "deferred") if counts[state]]
     if not alarm_active:
         key_bits.append("healthy")
     key = " ".join(key_bits).lower()
-    return f"""<tr data-t="{_esc(key)}"{row_style}>
+    return f"""<tr data-t="{_esc(key)}"{row_cls}>
   <td class="link-cell"><a href="/projects/{_esc(s.name)}">{_esc(s.name)}</a></td>
   <td class="mb">{mini_bar}</td>
   <td class="r"><span class="c r"><span class="n">{total}</span></span></td>
@@ -2252,19 +2244,18 @@ def _project_hero_html(name: str, summary: A.ProjectSummary, oldest_item: A.Item
         st = summary.status
         creating = st.lower().startswith(("creating", "provisioning"))
         if creating:
-            label, accent, tint = "Provisioning", "var(--amber)", "var(--alarm-surface)"
+            label, tone = "Provisioning", ""
             body = (
                 "This project is still being created. Its counts appear once its database is ready."
             )
         else:
-            label, accent, tint = "Unavailable", "var(--crimson)", "var(--blocked-surface)"
+            label, tone = "Unavailable", " is-broken"
             body = st
         return (
             '<div class="hero alarm" style="display:block">'
-            f'<div style="border-left:4px solid {accent};background:{tint};'
-            'padding:20px 24px;max-width:640px">'
-            f'<span class="eyebrow" style="color:{accent}">{label}</span>'
-            '<div class="subtle" style="margin-top:12px;overflow-wrap:anywhere">'
+            f'<div class="hero-alarm{tone}">'
+            f'<span class="eyebrow">{label}</span>'
+            '<div class="subtle mt-3" style="overflow-wrap:anywhere">'
             f"{_esc(body)}</div></div></div>"
         )
     age = summary.oldest_unclaimed_age_seconds
@@ -2285,18 +2276,17 @@ def _project_hero_html(name: str, summary: A.ProjectSummary, oldest_item: A.Item
             )
             item_href = f"/projects/{_esc(name)}/items/{_esc(oldest_item.id)}"
             said = (
-                '<div class="said" style="max-width:560px">'
-                # `.who` is an unstyled div, so name and id butted together
-                # ("cortex" + "cortex-i2u" -> "cortexcortex-i2u"). Lay it out
-                # as a baseline flex row with a real gap, and give the id the
-                # same dim secondary treatment the hero attribution uses.
-                '<div class="who" style="display:flex;gap:8px;align-items:baseline;'
-                f'flex-wrap:wrap">{_esc(name)}'
-                '<span class="id" style="color:var(--dim);font-weight:400;'
-                f'letter-spacing:.04em">{_esc(oldest_item.id)}</span></div>'
-                f'<a class="what" href="{item_href}" style="display:inline-block;'
-                f'max-width:100%;overflow-wrap:anywhere">{_esc(oldest_item.title)}</a>'
-                '<div class="subtle" style="margin-top:8px">'
+                '<div class="said u-measure-sm">'
+                # `.who` used to be an unstyled div, so name and id butted
+                # together ("cortex" + "cortex-i2u" -> "cortexcortex-i2u").
+                # It is now a baseline flex row with a real gap, and the id
+                # gets the same dim secondary treatment the hero attribution
+                # uses -- `.said .who` / `.said .who .id` in webtheme's
+                # SINGLE_SOURCE_CSS, not an inline style repeated per render.
+                f'<div class="who">{_esc(name)}'
+                f'<span class="id">{_esc(oldest_item.id)}</span></div>'
+                f'<a class="what" href="{item_href}">{_esc(oldest_item.title)}</a>'
+                '<div class="subtle mt-2">'
                 f"Unclaimed since {_esc(since)}, no holder</div></div>"
             )
         else:
@@ -2310,7 +2300,7 @@ def _project_hero_html(name: str, summary: A.ProjectSummary, oldest_item: A.Item
         <span class="k">Resolved</span></div>
       <div class="tally"><div class="v">{summary.held}</div><span class="k">Held</span></div>
     </div>"""
-    throughput = f"""<div class="grp" style="margin-top:22px">
+    throughput = f"""<div class="grp mt-6">
       <span class="glbl">Throughput</span>
       <div class="stat"><span class="v">{summary.resolved_24h}</span>
         <span class="k">Resolved &middot; 24h</span></div>
@@ -2327,7 +2317,7 @@ def _project_hero_html(name: str, summary: A.ProjectSummary, oldest_item: A.Item
     <div class="figrow">{fig}</div>
     {said}
   </div>
-  <div class="beat" style="min-width:260px;flex:1 1 260px">
+  <div class="beat grow">
     <div class="bhead">{beat_head}</div>
     {tallies}
     {throughput}
@@ -2568,8 +2558,7 @@ def _content_block_html(text: str | None, *, empty_message: str) -> str:
     if not text:
         return f'<div class="content-block"><span class="muted">{_esc(empty_message)}</span></div>'
     rendered = _render_item_markdown(text)
-    style = f"font-family:{_CONTENT_MONO_STACK};max-width:90ch"
-    return f'<div class="content-block" style="{style}">{rendered}</div>'
+    return f'<div class="content-block mono-measure">{rendered}</div>'
 
 
 def _fact_value_html(value: str) -> str:
@@ -2725,7 +2714,7 @@ def _blocked_by_list_html(name: str, links: list[dict]) -> str:
     if not banners:
         return ""
     return (
-        '<h2 class="eyebrow am" style="display:block;margin-top:30px">Blocked by</h2>'
+        '<h2 class="eyebrow am section-head">Blocked by</h2>'
         f'<div class="blocker-chain">{banners}</div>'
     )
 
@@ -2747,8 +2736,7 @@ def _cheap_ref_list_html(name: str, heading: str, links: list[dict]) -> str:
     if not rows:
         return ""
     return (
-        f'<h2 class="eyebrow" style="display:block;margin-top:30px">{_esc(heading)}</h2>'
-        f'<ul class="links-list">{rows}</ul>'
+        f'<h2 class="eyebrow section-head">{_esc(heading)}</h2><ul class="links-list">{rows}</ul>'
     )
 
 
@@ -2760,7 +2748,7 @@ def _discovered_note_html(name: str, links: list[dict], *, label: str) -> str:
     refs = [r for r in refs if r]
     if not refs:
         return ""
-    return f'<p class="muted" style="margin-top:10px">{_esc(label)} {", ".join(refs)}</p>'
+    return f'<p class="muted mt-3">{_esc(label)} {", ".join(refs)}</p>'
 
 
 def _link_chip_html(name: str, link: dict) -> str:
@@ -3005,7 +2993,7 @@ def _tls_status_html(request: Request) -> str:
         return (
             '<div class="formsec">'
             '<span class="flegend">TLS status</span>'
-            '<p class="subtle" style="margin-top:10px">Serving over '
+            '<p class="subtle mt-3">Serving over '
             '<b style="color:var(--ink)">HTTP</b> &mdash; not a secure origin. Installing this '
             "dashboard as an app (&ldquo;Add to Home Screen&rdquo;) needs HTTPS. Pick a method "
             "below, generate a certificate, then restart the service to serve it.</p>"
@@ -3034,7 +3022,7 @@ def _tls_status_html(request: Request) -> str:
         ""
         if scheme == "https"
         else (
-            '<p class="subtle" style="color:var(--amber);margin-top:8px">A certificate exists '
+            '<p class="subtle u-alarm mt-2">A certificate exists '
             "on disk, but this server is currently serving plain HTTP &mdash; a running server "
             "cannot hot-swap its own TLS material. Restart the service to pick it up.</p>"
         )
@@ -3047,12 +3035,12 @@ def _tls_status_html(request: Request) -> str:
     return f"""
     <div class="formsec">
       <span class="flegend">TLS status</span>
-      <div class="kv" style="margin-top:10px">
+      <div class="kv mt-3">
         <div><span class="k">Scheme</span>{scheme_html}</div>
         <div><span class="k">Issuer</span><span class="v">{issuer_label}</span></div>
         <div><span class="k">Expires</span>{expires_html}</div>
       </div>
-      <p class="subtle" style="margin-top:10px">Covers <span class="mono">{hostnames_str}</span></p>
+      <p class="subtle mt-3">Covers <span class="mono">{hostnames_str}</span></p>
       {stale_note}
     </div>
     """
@@ -3096,21 +3084,16 @@ def _setup_method_row(
         if disabled
         else '<button type="submit" class="secondary">Generate</button>'
     )
-    badge = (
-        ' <span style="color:var(--amber);font-weight:700;text-transform:none;'
-        'letter-spacing:normal">&bull; Recommended</span>'
-        if recommended
-        else ""
-    )
+    badge = ' <span class="rec-badge">&bull; Recommended</span>' if recommended else ""
     return f"""
     <div class="formsec">
       <span class="flegend">{_esc(title)}{badge}</span>
-      <p class="subtle" style="margin-top:8px">{description}</p>
-      <p class="subtle" style="margin-top:6px">
+      <p class="subtle mt-2">{description}</p>
+      <p class="subtle mt-2">
         <b style="color:var(--ink)">When to pick this:</b> {when_to_pick}</p>
-      <p class="subtle" style="margin-top:6px">{availability_html}</p>
-      <p class="subtle" style="margin-top:8px">CLI equivalent: <code>{_esc(command)}</code></p>
-      <form method="post" action="/setup/tls" style="margin-top:10px">
+      <p class="subtle mt-2">{availability_html}</p>
+      <p class="subtle mt-2">CLI equivalent: <code>{_esc(command)}</code></p>
+      <form method="post" action="/setup/tls" class="mt-3">
         <input type="hidden" name="method" value="{_esc(method)}">
         {btn}
       </form>
@@ -3158,8 +3141,7 @@ def _setup_friction_spectrum_html(*, recommended: str) -> str:
 
     def _mark(method: str) -> str:
         return (
-            ' <span style="color:var(--amber);font-weight:700">&mdash; recommended for '
-            "personal use</span>"
+            ' <span class="rec-mark">&mdash; recommended for personal use</span>'
             if recommended == method
             else ""
         )
@@ -3167,20 +3149,20 @@ def _mark(method: str) -> str:
     return f"""
     <div class="formsec">
       <span class="flegend">Which method fits how you reach this server?</span>
-      <p class="subtle" style="margin-top:8px">A publicly-trusted certificate can only be
+      <p class="subtle mt-2">A publicly-trusted certificate can only be
         issued for a name a public certificate authority can verify &mdash; never a bare LAN
         IP or a private hostname. That is a hard constraint, not a preference, and it is what
         decides the right method below:</p>
-      <p class="subtle" style="margin-top:12px">
+      <p class="subtle mt-3">
         <b style="color:var(--ink)">Tailscale name</b>{_mark("tailscale")} &mdash;
         browser-trusted, zero install, works from any device already on your tailnet. Covers
         only the tailnet name, never the bare LAN IP.</p>
-      <p class="subtle" style="margin-top:8px">
+      <p class="subtle mt-2">
         <b style="color:var(--ink)">Local CA</b>{_mark("ca")} &mdash; covers the LAN IP,
         hostname, and tailnet name together, but needs a one-time CA install per device
         &mdash; painless via the <span class="mono">/trust</span> page (see below once one is
         configured).</p>
-      <p class="subtle" style="margin-top:8px">
+      <p class="subtle mt-2">
         <b style="color:var(--ink)">Self-signed</b> &mdash; works anywhere, on any device,
         with a browser warning every single visit. Best for a quick check, not a device
         you'll return to.</p>
@@ -3339,28 +3321,28 @@ def _setup_ca_download_html(request: Request) -> str:
     return f"""
     <div class="formsec">
       <span class="flegend">Install the local CA</span>
-      <p class="subtle" style="margin-top:8px">A local CA is configured on this host. Install it
+      <p class="subtle mt-2">A local CA is configured on this host. Install it
         once on each client device to eliminate the browser warning for the Local CA certificate
         above. The leaf certificate rotates yearly without re-trusting anything -- the CA is the
         one thing you install.</p>
-      <p class="subtle" style="margin-top:12px"><b style="color:var(--ink)">Adding a new
+      <p class="subtle mt-3"><b style="color:var(--ink)">Adding a new
         device?</b> Skip the manual steps below &mdash; open <code>{_esc(trust_url)}</code> on
         that device and follow its guided install.{trust_caveat} It needs no login and no
         browser warning to reach; everything else on that port simply redirects here.</p>
-      <p style="margin-top:10px"><a class="btn secondary" href="/setup/ca.crt">Download CA
+      <p class="mt-3"><a class="btn secondary" href="/setup/ca.crt">Download CA
         certificate</a></p>
-      <p class="subtle" style="margin-top:16px">
+      <p class="subtle mt-4">
         <b style="color:var(--ink)">Windows</b> (PowerShell, no admin needed):</p>
       <p class="subtle"><code>Import-Certificate -FilePath &lt;path-to-ca.crt&gt;
         -CertStoreLocation Cert:\\CurrentUser\\Root</code></p>
-      <p class="subtle" style="margin-top:12px"><b style="color:var(--ink)">macOS</b>:</p>
+      <p class="subtle mt-3"><b style="color:var(--ink)">macOS</b>:</p>
       <p class="subtle"><code>sudo security add-trusted-cert -d -r trustRoot -k
         /Library/Keychains/System.keychain &lt;path-to-ca.crt&gt;</code></p>
-      <p class="subtle" style="margin-top:12px">
+      <p class="subtle mt-3">
         <b style="color:var(--ink)">Linux</b> (system-wide):</p>
       <p class="subtle"><code>sudo cp &lt;path-to-ca.crt&gt;
         /usr/local/share/ca-certificates/ &amp;&amp; sudo update-ca-certificates</code></p>
-      <p class="subtle" style="margin-top:12px"><b style="color:var(--ink)">iOS</b>: open the
+      <p class="subtle mt-3"><b style="color:var(--ink)">iOS</b>: open the
         downloaded file to install the profile, then enable full trust for it under
         Settings &rsaquo; General &rsaquo; About &rsaquo; Certificate Trust Settings.</p>
     </div>
@@ -3368,12 +3350,9 @@ def _setup_ca_download_html(request: Request) -> str:
 
 
 def _setup_body(request: Request) -> str:
-    heading_style = (
-        "font-family:var(--sans);font-size:24px;font-weight:500;color:var(--ink);margin:20px 0 4px"
-    )
     return f"""
     {_flash(request)}
-    <h1 style="{heading_style}">Setup</h1>
+    <h1 class="page-h1">Setup</h1>
     <p class="subtle">TLS/HTTPS configuration for this deployment.</p>
     {_tls_status_html(request)}
     {_setup_method_options_html()}
@@ -4241,7 +4220,7 @@ def _impairment_banner(pairs: list[tuple[str, str]]) -> str:
             '<div class="flash flash-error" role="alert">'
             f"Heads up &mdash; {len(pairs)} {noun} not healthy and must not be "
             "read as an empty queue:"
-            f'<ul style="margin:8px 0 0;padding-left:22px">{rows}</ul>'
+            f'<ul class="flash-list">{rows}</ul>'
             "</div>"
         )
 
@@ -4413,15 +4392,11 @@ async def login_form(request: Request):  # type: ignore[no-untyped-def]
             else '<input type="hidden" name="username" value="operator">'
         )
         error_html = f'<div class="flash flash-error">{_esc(error)}</div>' if error else ""
-        heading_style = (
-            "font-family:var(--sans);font-size:24px;font-weight:500;"
-            "color:var(--ink);margin:20px 0 4px"
-        )
         body = f"""
-        <h1 style="{heading_style}">Sign in</h1>
+        <h1 class="page-h1">Sign in</h1>
         <p class="subtle">{mode_hint}</p>
         {error_html}
-        <form method="post" action="/login" style="max-width:340px;margin-top:16px">
+        <form method="post" action="/login" class="form-narrow mt-4">
           <input type="hidden" name="next" value="{_esc(next_value)}">
           {username_field}
           <label for="password">Password</label>
@@ -4644,7 +4619,7 @@ async def dashboard(request: Request):  # type: ignore[no-untyped-def]
                 value=blocked_total,
                 href="#attention-queue",
                 icon="i-octagon-x",
-                icon_color_var="--blocked",
+                icon_class="ic-blocked",
                 is_blocked=True,
             ),
             WD.KpiCard(
@@ -4927,23 +4902,19 @@ async def rename_project(name: str, new_name: str = Form(...)):  # type: ignore[
 
     @app.get("/projects/{name}/remove", response_class=HTMLResponse)
     async def remove_confirm(request: Request, name: str):  # type: ignore[no-untyped-def]
-        remove_heading_style = (
-            "font-family:var(--sans);font-size:24px;font-weight:500;"
-            "color:var(--ink);margin:20px 0 14px"
-        )
         body = f"""
         {_flash(request)}
-        <h1 style="{remove_heading_style}">Remove project '{_esc(name)}'</h1>
-        <p class="subtle" style="max-width:640px">This permanently deletes the project's local
+        <h1 class="page-h1 roomy">Remove project '{_esc(name)}'</h1>
+        <p class="subtle u-measure">This permanently deletes the project's local
           directory AND its shared-server database. It is refused if any item is currently
           <strong style="color:var(--ink)">held</strong>. This cannot be undone.</p>
-        <form method="post" action="/projects/{_esc(name)}/remove" style="margin-top:18px">
+        <form method="post" action="/projects/{_esc(name)}/remove" class="mt-5">
           <label for="confirm_name">Type the project name
             (<code>{_esc(name)}</code>) to confirm</label>
           <input type="text" id="confirm_name" name="confirm_name" required autocomplete="off">
           <button type="submit" class="danger">Permanently remove</button>
         </form>
-        <p style="margin-top:14px">
+        <p class="mt-4">
           <a href="/projects/{_esc(name)}">&laquo; cancel, back to project</a></p>
         """
         return _page(
diff --git a/src/amplifier_work_tracker/webbrowse.py b/src/amplifier_work_tracker/webbrowse.py
index 13c42d7..2dc41eb 100644
--- a/src/amplifier_work_tracker/webbrowse.py
+++ b/src/amplifier_work_tracker/webbrowse.py
@@ -564,8 +564,7 @@ def _page_href(p: int) -> str:
         )
         truncation = f"{note_html}{pagination_html}" if note_html or pagination_html else ""
         empty_html = (
-            '<div class="empty-state" style="padding:2rem 0;text-align:center;'
-            'color:var(--ink-tertiary)">No items match this filter.</div>'
+            '<div class="empty-state centered">No items match this filter.</div>'
             if not shown
             else ""
         )
@@ -644,8 +643,8 @@ def _page_href(p: int) -> str:
           <div class="glass-panel chart-card">
             <div class="items-toolbar">
               {tabs_html}
-              <form method="get" action="/projects/{quote(name)}" class="search-input"
-                    style="min-width:180px;max-width:220px">
+              <form method="get" action="/projects/{quote(name)}"
+                    class="search-input compact">
                 <input type="hidden" name="status" value="{_esc(status)}">
                 <span class="icon"><svg><use href="#i-search"/></svg></span>
                 <input type="search" name="q" placeholder="Filter\u2026" aria-label="Filter items"
@@ -715,7 +714,7 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
             # is an ADDITIONAL, clearly-marked block below it, never a
             # rewrite of what was actually published.
             corrected_badge = (
-                '<span class="chip" style="margin-left:8px" '
+                '<span class="chip ml-2" '
                 'title="the resolution below has been corrected -- see Errata">'
                 "corrected</span>"
                 if item.corrected
@@ -724,7 +723,7 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
             errata_html = ""
             if item.errata:
                 rows = "".join(
-                    f'<div style="margin-top:6px"><span class="v mono">{_esc(e.at)}'
+                    f'<div class="mt-2"><span class="v mono">{_esc(e.at)}'
                     f' \u00b7 {_esc(e.by)}</span><div class="blink">{_esc(e.text)}</div></div>'
                     for e in item.errata
                 )
@@ -811,33 +810,21 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
                 class="prose" style="margin-top:var(--space-2)">
             <label for="title" class="eyebrow">Title</label>
             <textarea id="title" name="title" required rows="2"
-                      style="width:100%;max-width:900px;font-family:var(--font-sans);
-                      font-size:1rem;color:var(--ink-primary);background:var(--glass-fill);
-                      border:1px solid var(--glass-hairline-soft);border-radius:var(--radius-sm);
-                      padding:.5rem .75rem">{_esc(item.title)}</textarea>
+                      class="field-textarea title">{_esc(item.title)}</textarea>
             <h4>Description</h4>
             <textarea name="description" rows="6" placeholder="No description provided."
-                      style="width:100%;max-width:900px;font-family:var(--font-sans);
-                      font-size:.9375rem;color:var(--ink-primary);background:var(--glass-fill);
-                      border:1px solid var(--glass-hairline-soft);border-radius:var(--radius-sm);
-                      padding:.75rem 1rem">{_esc(item.description or "")}</textarea>
+                      class="field-textarea">{_esc(item.description or "")}</textarea>
             <h4>Acceptance criteria</h4>
             <textarea name="acceptance" rows="4" placeholder="No acceptance criteria provided."
-                      style="width:100%;max-width:900px;font-family:var(--font-sans);
-                      font-size:.9375rem;color:var(--ink-primary);background:var(--glass-fill);
-                      border:1px solid var(--glass-hairline-soft);border-radius:var(--radius-sm);
-                      padding:.75rem 1rem">{_esc(item.acceptance or "")}</textarea>
+                      class="field-textarea">{_esc(item.acceptance or "")}</textarea>
             <h4>Design notes</h4>
             <textarea name="design" rows="4" placeholder="No design notes provided."
-                      style="width:100%;max-width:900px;font-family:var(--font-sans);
-                      font-size:.9375rem;color:var(--ink-primary);background:var(--glass-fill);
-                      border:1px solid var(--glass-hairline-soft);border-radius:var(--radius-sm);
-                      padding:.75rem 1rem">{_esc(item.design or "")}</textarea>
-            <p class="field-hint" style="color:var(--ink-tertiary);font-size:.8125rem">
+                      class="field-textarea">{_esc(item.design or "")}</textarea>
+            <p class="field-hint">
               Title/description/acceptance/design are editable here and persist on Save.
               Status, holder and timestamps are lifecycle facts -- they change only
               through claim/resolve.</p>
-            <button type="submit" class="action-btn" style="margin-top:.3rem">Save changes</button>
+            <button type="submit" class="action-btn mt-1">Save changes</button>
           </form>
         </div>
         """
@@ -862,14 +849,11 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
             # and the confirm dialog side by side.
             actions_html = f"""
             <div class="actions-drawer" open>
-              <div style="padding:var(--space-4) var(--space-5);display:flex;
-                   align-items:center;gap:var(--space-3);font-weight:600;
-                   color:var(--ink-primary);font-size:.875rem">
+              <div class="confirm-head">
                 <span class="icon" style="color:var(--ink-tertiary)">
                   <svg><use href="#i-check-circle"/></svg></span> Resolve {_esc(item.id)}?
               </div>
-              <div style="padding:0 var(--space-5) var(--space-4);color:var(--ink-tertiary);
-                   font-size:.8125rem">This closes the item. This cannot be undone.</div>
+              <div class="confirm-note">This closes the item. This cannot be undone.</div>
               <form method="post"
                     action="/projects/{quote(name)}/items/{quote(item.id)}/resolve"
                     style="padding:0 var(--space-5) var(--space-5);display:flex;
@@ -920,7 +904,7 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
             <div class="detail-title">
               <span class="id">{_esc(item.id)}</span> {_esc(item.title)}
               <span class="status-chip">
-                <span class="icon sm" style="margin-right:4px">
+                <span class="icon sm mr-1">
                   <svg><use href="#i-bot"/></svg></span>{_esc(item.status.upper())}</span>
             </div>
           </div>
@@ -938,8 +922,8 @@ async def item_detail(request: Request, name: str, item_id: str):  # type: ignor
             <div class="field"><span class="k">Created</span>
               <span class="v mono">{_item_age_html(item.created_at)}</span></div>
           </div>
-          <div class="kv" style="margin-top:10px">{facts_kv}</div>
-          <div class="kv" style="margin-top:10px">{time_kv}</div>
+          <div class="kv mt-3">{facts_kv}</div>
+          <div class="kv mt-3">{time_kv}</div>
           {resolution_html}
           {blocker_status_html}
           {links_html}
diff --git a/src/amplifier_work_tracker/webpwa.py b/src/amplifier_work_tracker/webpwa.py
index b194fc9..0f43553 100644
--- a/src/amplifier_work_tracker/webpwa.py
+++ b/src/amplifier_work_tracker/webpwa.py
@@ -85,8 +85,21 @@
 MANIFEST_JSON = json.dumps(_MANIFEST)
 
 # Ported verbatim in behaviour from muxplex's own sw.js (see this module's
-# docstring). Colours match webtheme.CSS's --ground/--ink; text matches the
-# task's own wording for the offline notice.
+# docstring). Text matches the task's own wording for the offline notice.
+#
+# THE OFFLINE NOTICE CARRIES NO COLOURS, FONT OR SIZE OF ITS OWN, and that is
+# deliberate rather than an omission (operator-surface.v1 Core 4, ledger row
+# OSV1-005). It used to: a literal near-black ground and off-white ink written
+# straight into a `style=` attribute here -- a palette three generations behind
+# the live `--color-ground`, which nobody noticed precisely because this
+# document only ever renders when the network is down. That is the structural
+# trap: this response is produced with NO stylesheet reachable (there is no
+# cache, by design, two paragraphs up), so any styling it carries can only ever
+# be a SECOND, unverifiable copy of the visual truth. It therefore carries
+# none, and asks the user agent for the app's colour scheme instead --
+# `<meta name="color-scheme" content="dark light">` makes the browser paint its
+# own dark ground and light ink, honouring the reader's system preference
+# without this file naming a single value.
 SERVICE_WORKER_JS = r"""// amplifier-work-tracker -- minimal service worker.
 //
 // Exists ONLY to satisfy Chrome's install-PROMPT requirement (the "Add to
@@ -118,9 +131,11 @@
     fetch(event.request).catch(function () {
       return new Response(
         '<!doctype html><meta charset="utf-8">' +
-          '<body style="background:#0D0D0C;color:#F2EEE6;' +
-          'font:16px -apple-system,sans-serif;padding:32px;text-align:center">' +
-          "Can't reach the work tracker right now &mdash; check your connection.</body>",
+          '<meta name="color-scheme" content="dark light">' +
+          '<meta name="viewport" content="width=device-width,initial-scale=1">' +
+          '<body><p>' +
+          "Can't reach the work tracker right now &mdash; check your connection." +
+          '</p></body>',
         { headers: { 'Content-Type': 'text/html; charset=utf-8' } }
       );
     })
diff --git a/src/amplifier_work_tracker/webtheme.py b/src/amplifier_work_tracker/webtheme.py
index 863831b..ef8275c 100644
--- a/src/amplifier_work_tracker/webtheme.py
+++ b/src/amplifier_work_tracker/webtheme.py
@@ -84,7 +84,14 @@
 # re-architecture; `webapp.py` needed zero structural changes as a result.
 # ---------------------------------------------------------------------------
 
-CSS = r"""
+#: THE TOKEN BLOCK -- the one place a literal colour, font, or size is not a
+#: defect but the definition (operator-surface.v1 Core 4 names this module by
+#: name). Split out of `CSS` as its own constant so a page that must be
+#: SELF-CONTAINED and cannot afford the whole dashboard stylesheet -- the
+#: plain-HTTP trust-bootstrap page, `TRUST_CSS` below -- can consume the live
+#: tokens instead of hardcoding a second, drifting copy of them. `CSS` is
+#: this block plus everything that follows, byte-for-byte as before.
+TOKENS_CSS = r"""
 *,*::before,*::after{margin:0;padding:0;box-sizing:border-box}
 /*
   ---------------------------------------------------------------------------
@@ -467,7 +474,11 @@
   --brand-cyan-ink:#22d3ee;
   --brand-purple-ink:#c084fc;
 }
+"""
 
+CSS = (
+    TOKENS_CSS
+    + r"""
 /* -- AFFORDANCE GRAMMAR (one documented convention) ----------------------
    Three signals of "clickable" were in use (a trailing chevron, bold-amber
    text, and a lone underline). Consolidated to ONE rule, enforced by the
@@ -2177,6 +2188,7 @@ class name, or test needs to change.
   .dot.on{animation:none;opacity:1}
 }
 """
+)
 
 # ---------------------------------------------------------------------------
 # wt-v4 "Observatory" component CSS (Lane B: obs-widgets) -- extracted
@@ -4327,10 +4339,264 @@ def state_html(kind: str, label: str) -> str:
 CSS = CSS + "\n" + L0_HERO_CSS
 
 
+# ---------------------------------------------------------------------------
+# ONE SOURCE OF VISUAL TRUTH -- the utility + component layer that absorbed the
+# inline literals (operator-surface.v1 Core 4; ledger rows OSV1-005/OSV1-032).
+#
+# Every rule below is a value that USED to sit in an inline `style=` attribute
+# in webapp.py / webbrowse.py / webtrust.py / widgets.py / chartsvg.py. It is
+# deliberately LAST in the cascade, so a utility beats the component rule it
+# replaces on equal specificity without needing `!important` -- exactly the
+# priority the inline attribute used to buy, bought once, here.
+#
+# SPACING IS ON THE 4px SCALE. Every migrated `margin-top:Npx` literal was
+# snapped to the nearest `--space-*` step, ties rounding UP -- ONE documented
+# rule, applied uniformly: 6->8, 10->12, 14->16, 18->20, 22->24, 30->32, and
+# `.3rem`->4px. Maximum drift is 2px. That drift is the point of Core 4: the
+# scale decides the value, not whoever last typed a number into an attribute.
+# ---------------------------------------------------------------------------
+
+SINGLE_SOURCE_CSS = r"""
+/* ---------- spacing utilities (the 4px --space-* scale) ---------- */
+.mt-1{margin-top:var(--space-1)}
+.mt-2{margin-top:var(--space-2)}
+.mt-3{margin-top:var(--space-3)}
+.mt-4{margin-top:var(--space-4)}
+.mt-5{margin-top:var(--space-5)}
+.mt-6{margin-top:var(--space-6)}
+.mt-8{margin-top:var(--space-8)}
+.ml-2{margin-left:var(--space-2)}
+.mr-1{margin-right:var(--space-1)}
+
+/* ---------- measures ---------- */
+.u-measure{max-width:640px}
+.u-measure-sm{max-width:560px}
+.form-narrow{max-width:340px}
+
+/* ---------- page headings (was three copies of one `heading_style`
+     string built in webapp.py: `_setup_body`, the login page, and the
+     remove-project confirm) ---------- */
+h1.page-h1{font-family:var(--sans);font-size:24px;font-weight:500;color:var(--ink);
+  margin:var(--space-5) 0 var(--space-1)}
+h1.page-h1.roomy{margin-bottom:var(--space-4)}
+
+/* ---------- ready-queue age histogram (webapp `_heartbeat_html`) ---------- */
+.hist-seg{flex:1 1 0;min-width:0;display:flex;align-items:flex-end;gap:2px;
+  overflow:hidden;padding:0 8px}
+.hist-ax{flex:1 1 0;min-width:0;display:flex;flex-direction:column;
+  align-items:center;gap:3px;padding:0 8px}
+.hist-seg.divided,.hist-ax.divided{border-left:1px solid var(--rule)}
+.hist-axis{display:flex;margin-top:var(--space-2)}
+.hist-day{font-family:var(--sans);font-size:10px;font-weight:500;letter-spacing:.1em;
+  text-transform:uppercase;color:var(--dim);white-space:nowrap}
+.hist-num{font-family:var(--sans);font-size:14px;font-weight:500;line-height:1;
+  color:var(--mid)}
+.hist-num.hot{color:var(--amber)}
+/* the per-band tick heights, which used to be interpolated per element from
+   webapp's `_BUCKET_HEIGHT`; the band class was already on every tick. */
+.ticks .tick{flex:0 0 3px}
+.ticks .tick.t0{height:12px}
+.ticks .tick.t1{height:22px}
+.ticks .tick.t2{height:34px}
+.ticks .tick.t3{height:44px}
+
+/* ---------- workspace state bar + its legend (webapp `_state_bar_html`
+     / `_state_legend_html`): the fill per state, keyed by the state slot
+     rather than interpolated from a Python dict of token names ---------- */
+.sbar i.fill-ready{background:var(--st-ready)}
+.sbar i.fill-held{background:var(--amber)}
+.sbar i.fill-blocked{background:var(--crimson)}
+.sbar i.fill-deferred{background:var(--st-deferred)}
+.sbar i.fill-resolved{background:var(--st-resolved)}
+.sbar i.alarm-floor{min-width:16px}
+.sw.fill-ready{background:var(--st-ready)}
+.sw.fill-held{background:var(--amber)}
+.sw.fill-blocked{background:var(--crimson)}
+.sw.fill-deferred{background:var(--st-deferred)}
+.sw.fill-resolved{background:var(--st-resolved)}
+.sw.fill-empty{background:var(--st-empty)}
+
+/* ---------- fleet rows and project hero in an attention/blocked state ------
+     Two states, two classes -- the accent and its tint always travel
+     together, so they can never be paired wrongly by a caller. */
+tr.attn-row{background:var(--alarm-surface);box-shadow:inset 4px 0 0 var(--amber)}
+tr.attn-row.is-blocked{background:var(--blocked-surface);
+  box-shadow:inset 4px 0 0 var(--crimson)}
+.hero-alarm{border-left:4px solid var(--amber);background:var(--alarm-surface);
+  padding:var(--space-5) var(--space-6);max-width:640px}
+.hero-alarm.is-broken{border-left-color:var(--crimson);background:var(--blocked-surface)}
+.hero-alarm .eyebrow{color:var(--amber)}
+.hero-alarm.is-broken .eyebrow{color:var(--crimson)}
+
+/* ---------- project hero: the oldest unclaimed item's attribution ------- */
+.said.u-measure-sm{max-width:560px}
+.said .who{display:flex;gap:var(--space-2);align-items:baseline;flex-wrap:wrap}
+.said .who .id{color:var(--dim);font-weight:400;letter-spacing:.04em}
+.said a.what{display:inline-block;max-width:100%;overflow-wrap:anywhere}
+.beat.grow{min-width:260px;flex:1 1 260px}
+
+/* ---------- item detail / setup page bits ---------- */
+.eyebrow.section-head{display:block;margin-top:var(--space-8)}
+.u-alarm{color:var(--amber)}
+.rec-badge{color:var(--amber);font-weight:700;text-transform:none;letter-spacing:normal}
+.rec-mark{color:var(--amber);font-weight:700}
+.flash ul.flash-list{margin:var(--space-2) 0 0;padding-left:var(--space-6)}
+.content-block.mono-measure{font-family:var(--mono,ui-monospace,SFMono-Regular,'SF Mono',
+  Menlo,Consolas,'Liberation Mono',monospace);max-width:90ch}
+
+/* ---------- browse app (webbrowse) ---------- */
+.empty-state.centered{padding:2rem 0;text-align:center;color:var(--ink-tertiary)}
+.search-input.compact{min-width:180px;max-width:220px}
+.field-textarea{width:100%;max-width:900px;font-family:var(--font-sans);
+  font-size:.9375rem;color:var(--ink-primary);background:var(--glass-fill);
+  border:1px solid var(--glass-hairline-soft);border-radius:var(--radius-sm);
+  padding:.75rem 1rem}
+.field-textarea.title{font-size:1rem;padding:.5rem .75rem}
+.prose .field-hint{color:var(--ink-tertiary);font-size:.8125rem}
+.confirm-head{padding:var(--space-4) var(--space-5);display:flex;align-items:center;
+  gap:var(--space-3);font-weight:600;color:var(--ink-primary);font-size:.875rem}
+.confirm-note{padding:0 var(--space-5) var(--space-4);color:var(--ink-tertiary);
+  font-size:.8125rem}
+
+/* ---------- observatory widgets ---------- */
+.icon.ic-blocked{color:var(--blocked)}
+.feed-item .dot .icon{width:.7em;height:.7em}
+.feed-details summary .note{font-weight:400;margin-left:var(--space-2)}
+.status-mix span.mix-resolved{background:var(--ink-quiet)}
+.status-mix span.mix-ready{background:var(--ink-secondary)}
+.status-mix span.mix-held{background:var(--brand-cyan-ink)}
+.status-mix span.mix-intake{background:var(--ink-tertiary)}
+.status-mix span.mix-blocked{background:var(--blocked)}
+.sw.mix-resolved{background:var(--ink-quiet)}
+.sw.mix-ready{background:var(--ink-secondary)}
+.sw.mix-held{background:var(--brand-cyan-ink)}
+.sw.mix-intake{background:var(--ink-tertiary)}
+.sw.mix-blocked{background:var(--blocked)}
+
+/* ---------- SVG charts (chartsvg) --------------------------------------
+     In the charts a `class` names WHAT an element is (bar / val-label /
+     axis-label / zero-stub) -- the chart structure tests read it as exactly
+     that -- so STATE ("this is today", "this is the watch band", "this label
+     carries a value rather than an axis tick") rides a data attribute the
+     stylesheet selects on instead of being conflated into the same
+     attribute.
+
+     EVERY SELECTOR HERE IS SCOPED THROUGH `.svg-chart`, and that is
+     load-bearing rather than tidy. The chart ink these rules replace used to
+     be INLINE, which outranks every stylesheet rule; a bare
+     `.axis-label[data-watch]` (0,2,0) does NOT -- it loses to the existing
+     `.wt-observatory .svg-chart .axis-label{fill:var(--ink-tertiary)}`
+     (0,3,0), so the watch band, the value labels and today's tick all
+     silently reverted to tertiary ink when the inline styles were removed.
+     Measured, not reasoned: the Tier-B sweep read 182 fewer `--watch` px on
+     a dark L1. `.svg-chart` restores the specificity the inline attribute
+     used to buy, WITHOUT depending on `.wt-observatory` being an ancestor
+     (the browse surface renders the same charts). */
+.svg-chart .val-label{fill:var(--ink-tertiary)}
+.svg-chart .val-label[data-today],
+.svg-chart .axis-label[data-today]{fill:var(--brand-cyan-ink);font-weight:600}
+.svg-chart .zero-stub{fill:var(--ink-quiet)}
+.svg-chart .zero-stub[data-watch]{fill:var(--watch)}
+.svg-chart .axis-label[data-val]{fill:var(--ink-primary);font-weight:600}
+.svg-chart .axis-label[data-watch]{fill:var(--watch)}
+.svg-chart .axis-label[data-val][data-watch]{fill:var(--watch);font-weight:600}
+"""
+
+CSS = CSS + "\n" + SINGLE_SOURCE_CSS
+
+
+# ---------------------------------------------------------------------------
+# TRUST-PAGE STYLESHEET -- the plain-HTTP trust-bootstrap page's own sheet.
+#
+# It lives HERE, in the token module, rather than in `webtrust.py`, and that is
+# the whole point: it used to be a page-local stylesheet in `webtrust.py` that
+# re-declared the whole role set (--ground / --ink / --amber / ...) as its own
+# literal near-black-and-warm-amber values -- the retired pre-blend-3 palette,
+# a second source of visual truth that had silently drifted three generations
+# behind the live `--color-ground:#05070f`. Core 4 forbids exactly that.
+# Composed from `TOKENS_CSS` so the trust page renders
+# the LIVE palette, in both schemes, and can never drift again.
+#
+# Still SELF-CONTAINED, which the page requires: this is inlined into the
+# document, never fetched. A device that has not yet installed the CA is
+# reading this page over plain HTTP precisely because nothing else is
+# reachable yet; an external stylesheet link would be a broken asset at the
+# worst possible moment. `TOKENS_CSS` is the token block ONLY (~10 KB), not
+# the whole dashboard sheet.
+# ---------------------------------------------------------------------------
+
+TRUST_CSS = (
+    TOKENS_CSS
+    + r"""
+body{
+  background:var(--ground); color:var(--ink); margin:0;
+  padding:var(--space-12) var(--space-6) var(--space-16);
+  font-family:var(--sans); line-height:1.55;
+}
+main{max-width:640px;margin:0 auto}
+h1{
+  font-family:var(--serif); font-weight:500; font-size:var(--text-display-size);
+  line-height:var(--text-display-line); margin:0 0 var(--space-3); color:var(--ink);
+}
+p{margin:0 0 var(--space-4)}
+p.subtle{color:var(--mid)}
+p.lead{color:var(--ink); font-size:var(--text-body-size); margin:var(--space-5) 0}
+code{
+  font-family:var(--mono); background:var(--raise); color:var(--amber);
+  padding:2px 6px; border-radius:var(--radius-sm);
+  font-size:0.88em; word-break:break-all;
+}
+.btn{
+  display:inline-block; background:var(--amber); color:var(--ink-on-ground-inverse) !important;
+  font-weight:var(--text-section-label-weight); padding:var(--space-3) var(--space-6);
+  border-radius:var(--radius-pill); text-decoration:none;
+  margin:var(--space-2) var(--space-3) var(--space-2) 0; font-size:var(--text-body-size);
+}
+.btn.secondary{background:transparent; color:var(--amber) !important;
+  border:1px solid var(--amber)}
+.formsec{
+  border:1px solid var(--rule-hi); border-radius:var(--radius-md);
+  padding:var(--space-5); margin-top:var(--space-5); background:var(--raise);
+}
+.formsec.highlight{border-color:var(--amber)}
+.flegend{
+  font-size:var(--text-section-label-size); text-transform:uppercase;
+  letter-spacing:var(--text-section-label-spacing); color:var(--quiet);
+  font-weight:var(--text-section-label-weight);
+  display:block; margin-bottom:var(--space-2);
+}
+details{color:var(--mid); margin-top:var(--space-4)}
+details summary{cursor:pointer; color:var(--amber); margin-bottom:var(--space-2)}
+details .formsec{margin-top:var(--space-3)}
+.url-box{
+  background:var(--raise); border:1px solid var(--rule); border-radius:var(--radius-sm);
+  padding:var(--space-3) var(--space-4); word-break:break-all;
+  font-family:var(--mono); font-size:var(--text-body-size); color:var(--ink);
+}
+.mt-4{margin-top:var(--space-4)}
+.mt-5{margin-top:var(--space-5)}
+.mt-8{margin-top:var(--space-8)}
+"""
+)
+
+
+def trust_style_tag() -> str:
+    """The trust page's complete `<style>` element.
+
+    The TAG is emitted from this module, not from `webtrust.py`, so that
+    `webtrust.py` ships no stylesheet of its own at all -- Core 4's rule is
+    about where visual truth LIVES, and after this change there is exactly
+    one place it lives for both apps.
+    """
+    return "<style>" + TRUST_CSS + "</style>"
+
+
 __all__ = [
     "CSS",
     "ICONS",
+    "TOKENS_CSS",
     "TRACK_W",
+    "TRUST_CSS",
     "age_band_class",
     "age_cell_html",
     "age_short",
@@ -4346,4 +4612,5 @@ def state_html(kind: str, label: str) -> str:
     "state_html",
     "statusbar",
     "top_bar",
+    "trust_style_tag",
 ]
diff --git a/src/amplifier_work_tracker/webtrust.py b/src/amplifier_work_tracker/webtrust.py
index d63163d..1f4c9bd 100644
--- a/src/amplifier_work_tracker/webtrust.py
+++ b/src/amplifier_work_tracker/webtrust.py
@@ -63,6 +63,7 @@
 from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
 from starlette.responses import Response
 
+from . import webtheme as T
 from . import webtls as WT
 
 # ---------------------------------------------------------------------------
@@ -246,61 +247,29 @@ def _build_mobileconfig(ca_cert_path: Path) -> bytes:
 
 
 # ---------------------------------------------------------------------------
-# Page rendering -- self-contained inline CSS (never imports `webtheme.CSS`;
-# this is a separate tiny app, deliberately independent of the dashboard's
-# own module graph). Colors are the same "J-editorial-dark" tokens as the
-# dashboard (`webtheme.py`'s `:root`), copied here as plain values rather
-# than shared, so this module has zero import-time dependency on webapp.py.
+# Page rendering. This module ships NO stylesheet of its own.
+#
+# It used to: an inline stylesheet block right here re-declaring the whole
+# role set (--ground / --raise / --ink / --mid / --quiet / --amber / --rule /
+# --rule-hi) as its own literal near-black-and-warm-amber values -- the
+# retired pre-blend-3 palette -- explicitly so it would not have to import
+# `webtheme`. That independence bought one import edge and cost a second
+# source of visual truth, which then drifted three palette generations behind
+# the live `--color-ground:#05070f` without anyone noticing. operator-surface.v1
+# Core 4 forbids exactly that -- a stylesheet block outside the token module.
+#
+# The sheet now lives in `webtheme.TRUST_CSS`, composed from the SAME
+# `TOKENS_CSS` the dashboard uses, and `webtheme.trust_style_tag()` emits the
+# whole style element -- so there is no stylesheet, and no style tag, anywhere
+# in this file. `webtheme` is a leaf module (stdlib only, no FastAPI,
+# no `webapp`), so importing it costs this app nothing at import time.
+#
+# The page stays SELF-CONTAINED, which it must: the sheet is INLINED into the
+# document, never fetched. A device reading this page has not installed the CA
+# yet -- an external asset link would be a broken fetch at the worst possible
+# moment.
 # ---------------------------------------------------------------------------
 
-_CSS = """
-:root{
-  --ground:#0D0D0C; --raise:#151513; --ink:#F2EEE6; --mid:#A6A199;
-  --quiet:#9C978F; --amber:#D9A253; --rule:#1F1F1D; --rule-hi:#333330;
-}
-*{box-sizing:border-box}
-body{
-  background:var(--ground); color:var(--ink); margin:0; padding:52px 24px 80px;
-  font-family:'Helvetica Neue',Arial,sans-serif; line-height:1.55;
-}
-main{max-width:640px;margin:0 auto}
-h1{
-  font-family:Georgia,'Bodoni Moda',serif; font-weight:500; font-size:32px;
-  margin:0 0 10px; color:var(--ink);
-}
-p{margin:0 0 14px}
-p.subtle{color:var(--mid)}
-p.lead{color:var(--ink); font-size:16px; margin:18px 0}
-code{
-  font-family:ui-monospace,'SFMono-Regular',Menlo,Consolas,monospace;
-  background:var(--raise); color:var(--amber); padding:2px 6px; border-radius:4px;
-  font-size:0.88em; word-break:break-all;
-}
-.btn{
-  display:inline-block; background:var(--amber); color:var(--ground) !important;
-  font-weight:600; padding:12px 22px; border-radius:6px; text-decoration:none;
-  margin:6px 10px 6px 0; font-size:15px;
-}
-.btn.secondary{background:transparent; color:var(--amber) !important; border:1px solid var(--amber)}
-.formsec{
-  border:1px solid var(--rule-hi); border-radius:8px; padding:18px 20px; margin-top:20px;
-  background:var(--raise);
-}
-.formsec.highlight{border-color:var(--amber)}
-.flegend{
-  font-size:12px; text-transform:uppercase; letter-spacing:0.06em; color:var(--quiet);
-  display:block; margin-bottom:6px;
-}
-details{color:var(--mid); margin-top:16px}
-details summary{cursor:pointer; color:var(--amber); margin-bottom:8px}
-details .formsec{margin-top:10px}
-.url-box{
-  background:var(--raise); border:1px solid var(--rule); border-radius:6px;
-  padding:12px 16px; word-break:break-all; font-family:ui-monospace,Menlo,monospace;
-  font-size:14px; color:var(--ink);
-}
-"""
-
 
 def _esc(value: object) -> str:
     return html.escape("" if value is None else str(value), quote=True)
@@ -323,7 +292,7 @@ def _ca_install_section(*, os_hint: str) -> str:
     <div class="formsec highlight">
       <span class="flegend">Detected: {_esc(primary_label)}</span>
       <p class="subtle">{primary_instr}</p>
-      <p style="margin-top:14px">
+      <p class="mt-4">
         <a class="btn" href="/ca.crt">Download CA certificate</a>
         {mobileconfig_btn}
       </p>
@@ -340,7 +309,7 @@ def _trust_page_html(
 ) -> str:
     https_url = f"https://{hostname}:{https_port}/"
     continue_btn = (
-        f'<p style="margin-top:20px"><a class="btn" href="{_esc(https_url)}">'
+        f'<p class="mt-5"><a class="btn" href="{_esc(https_url)}">'
         "Continue to the app &rarr;</a></p>"
     )
 
@@ -371,7 +340,7 @@ def _trust_page_html(
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Trust this server &middot; amplifier-work-tracker</title>
-<style>{_CSS}</style>
+{T.trust_style_tag()}
 </head>
 <body>
   <main>
@@ -379,7 +348,7 @@ def _trust_page_html(
     <p class="subtle">Install this certificate to trust <code>{_esc(hostname)}</code> on this
       device. This is a one-time step per device &mdash; not per visit.</p>
     {body}
-    <p class="subtle" style="margin-top:32px">On another device? Open this same page there:</p>
+    <p class="subtle mt-8">On another device? Open this same page there:</p>
     <p class="url-box">{_esc(request_url)}</p>
   </main>
 </body>
diff --git a/src/amplifier_work_tracker/widgets.py b/src/amplifier_work_tracker/widgets.py
index c4e1581..21c772f 100644
--- a/src/amplifier_work_tracker/widgets.py
+++ b/src/amplifier_work_tracker/widgets.py
@@ -680,7 +680,10 @@ class KpiCard(TypedDict):
     value: int
     href: str
     icon: NotRequired[str]
-    icon_color_var: NotRequired[str]
+    #: A STYLESHEET CLASS for the icon's ink (e.g. `"ic-blocked"`), never a
+    #: token name to interpolate into an inline `style=` -- operator-surface.v1
+    #: Core 4: a colour is named in the stylesheet or it is not named.
+    icon_class: NotRequired[str]
     is_blocked: NotRequired[bool]
 
 
@@ -700,9 +703,12 @@ def render_kpi_strip(data: KpiStripData) -> str:
         icon_html = ""
         icon = c.get("icon")
         if icon:
-            color_var = c.get("icon_color_var")
-            style = f' style="color:var({color_var})"' if color_var else ""
-            icon_html = f'<span class="icon sm"{style}><svg><use href="#{icon}"/></svg></span> '
+            # The ink is a CLASS, not a token name interpolated into an
+            # inline style: the stylesheet is where a colour is allowed to be
+            # named (`.icon.ic-blocked`, webtheme's SINGLE_SOURCE_CSS).
+            tone = c.get("icon_class")
+            cls = f"icon sm {tone}" if tone else "icon sm"
+            icon_html = f'<span class="{cls}"><svg><use href="#{icon}"/></svg></span> '
         cards_html.append(
             f'<a href="{_esc(c["href"])}" class="{classes}">'
             f'<div class="k"><span>{icon_html}{_esc(c["label"])}</span>'
@@ -799,13 +805,13 @@ def render_attention_queue(data: AttentionQueueData) -> str:
     "deferred",
     "blocked",
 )
-_MIX_COLOR_VAR: dict[str, str] = {
-    "resolved": "--ink-quiet",
-    "ready": "--ink-secondary",
-    "held": "--brand-cyan-ink",
-    "intake": "--ink-tertiary",
-    "blocked": "--blocked",
-}
+# The colour per mix slot is NOT declared here. It used to be a dict of token
+# names interpolated into `background:var(...)` at two call sites -- the mix
+# bar and the donut legend -- which meant the palette of a single reading lived
+# in Python rather than in the stylesheet. It is now `.status-mix span.mix-*`
+# and `.sw.mix-*` in webtheme's SINGLE_SOURCE_CSS, keyed by the same
+# `_MIX_ORDER` slot name emitted as a class. `deferred` is still the exception
+# it always was: it draws through `.pat-hatch`, a texture, never a flat colour.
 
 
 class FleetStatusMix(TypedDict):
@@ -830,9 +836,7 @@ def _status_mix_bar_html(mix: FleetStatusMix) -> str:
         if key == "deferred":
             segments.append(f'<span style="width:{pct}%" class="pat-hatch"></span>')
         else:
-            segments.append(
-                f'<span style="width:{pct}%;background:var({_MIX_COLOR_VAR[key]})"></span>'
-            )
+            segments.append(f'<span class="mix-{key}" style="width:{pct}%"></span>')
     tooltip = (
         f"{mix['ready']} ready · {mix['held']} held · {mix['blocked']} blocked · "
         f"{mix['deferred']} deferred · {mix['intake']} intake · {mix['resolved']} resolved"
@@ -1041,7 +1045,7 @@ def render_activity_feed(data: ActivityFeedData) -> str:
         icon = _FEED_ICON[item["kind"]]
         items_html.append(
             f'<a href="{_esc(item["href"])}" class="feed-item k-{item["kind"]}">'
-            f'<span class="dot"><span class="icon" style="width:.7em;height:.7em">'
+            f'<span class="dot"><span class="icon">'
             f'<svg><use href="#{icon}"/></svg></span></span>'
             f'<span class="txt"><b>{_esc(item["actor"])}</b> {_esc(item["verb"])} '
             f'<span class="proj">{_esc(item["project_item"])}</span> — '
@@ -1058,7 +1062,7 @@ def render_activity_feed(data: ActivityFeedData) -> str:
         # already persists whatever state the user leaves it in across
         # a refresh, so defaulting to open costs nothing on that front.
         '<details class="dormant-details feed-details" open>'
-        '<summary>Activity feed <span class="note" style="font-weight:400;margin-left:8px">'
+        '<summary>Activity feed <span class="note">'
         "cross-project · reverse-chronological</span> "
         '<span class="icon sm chev"><svg><use href="#i-chevron"/></svg></span></summary>'
         '<div class="glass-panel chart-card" style="margin-top:var(--space-3)">'
@@ -1107,7 +1111,7 @@ def render_status_breakdown(data: StatusBreakdownData) -> str:
         swatch = (
             '<span class="sw pat-hatch"></span>'
             if key == "deferred"
-            else f'<span class="sw" style="background:var({_MIX_COLOR_VAR[key]})"></span>'
+            else f'<span class="sw mix-{key}"></span>'
         )
         legend_rows.append(
             f'<div class="li">{swatch}<span class="name">{_MIX_NAME[key]}</span>'
diff --git a/tests/conformance/operator_surface/browser/LAST_RUN.json b/tests/conformance/operator_surface/browser/LAST_RUN.json
index 490d2f3..b36dcb4 100644
--- a/tests/conformance/operator_surface/browser/LAST_RUN.json
+++ b/tests/conformance/operator_surface/browser/LAST_RUN.json
@@ -27,7 +27,7 @@
         "blocked": 0,
         "pixels_swept": 2813440,
         "retired_amber": 0,
-        "watch": 5318
+        "watch": 5229
       },
       "bad-alarm-fixture/L0/dark": {
         "alarm": 0,
@@ -48,7 +48,7 @@
         "blocked": 0,
         "pixels_swept": 2813440,
         "retired_amber": 16681,
-        "watch": 5116
+        "watch": 5047
       },
       "calm/L0/dark": {
         "alarm": 0,
@@ -62,7 +62,7 @@
         "blocked": 0,
         "pixels_swept": 2813440,
         "retired_amber": 0,
-        "watch": 5259
+        "watch": 5168
       },
       "calm/L1/dark": {
         "alarm": 0,
@@ -76,7 +76,7 @@
         "blocked": 97,
         "pixels_swept": 3792640,
         "retired_amber": 0,
-        "watch": 6449
+        "watch": 6443
       }
     },
     "kit.pinned_browser": {
@@ -392,6 +392,6 @@
       }
     }
   },
-  "recorded_at": "2026-09-05T10:35:48Z",
+  "recorded_at": "2026-09-05T11:55:58Z",
   "schema": "operator-surface-tier-b/1"
 }
diff --git a/tests/conformance/operator_surface/test_tier_a.py b/tests/conformance/operator_surface/test_tier_a.py
index 66d1db3..b21b3b1 100644
--- a/tests/conformance/operator_surface/test_tier_a.py
+++ b/tests/conformance/operator_surface/test_tier_a.py
@@ -25,7 +25,6 @@
 saying so. Their good halves are `pytest.mark.xfail(strict=True)` with the row
 id in the reason -- never `skip`, never deleted:
 
-    visual.single_source      OSV1-005  66 literal inline sites + 40 in blocks
     calm.keeps_slot           OSV1-012  an empty widget keeps its slot but
                                         says nothing
     antigoals.enforced        OSV1-015  `_oldest_ready_item` calls `bd.list`
@@ -550,12 +549,6 @@ def test_visual_single_source_bad_half_the_register_is_the_ledgers_own() -> None
     )
 
 
-@pytest.mark.xfail(
-    strict=True,
-    reason="OSV1-005 (Core 4): 66 inline `style=` sites and 40 `<style>`-block "
-    "declarations still carry a literal colour, font or size. Flip the row and "
-    "delete this marker in the same change.",
-)
 def test_visual_single_source() -> None:
     """Conformance 6's GOOD half: a static pass over `src/` plus the register."""
     problems = check_visual_single_source()
diff --git a/tests/integration/test_web.py b/tests/integration/test_web.py
index 028c5dd..3a1ef6d 100644
--- a/tests/integration/test_web.py
+++ b/tests/integration/test_web.py
@@ -398,9 +398,7 @@ def test_item_detail_shows_discovered_from_provenance(client, project_factory):
     # would false-positive on the stylesheet rather than real content. A
     # rendered `<li>` always carries `class="blocker-item ..."` (a space,
     # not the CSS selector's dot) -- that's the precise, unambiguous signal.
-    assert '<h2 class="eyebrow am" style="display:block;margin-top:30px">Blocked by</h2>' not in (
-        resp.text
-    )
+    assert '<h2 class="eyebrow am section-head">Blocked by</h2>' not in resp.text
     assert 'class="blocker-item' not in resp.text
 
 
@@ -438,9 +436,7 @@ def test_item_detail_with_no_dependencies_shows_no_open_blockers_empty_state(
     # bare substring check would false-positive on the stylesheet rather
     # than real content (same discipline
     # `test_item_detail_shows_discovered_from_provenance` already uses).
-    assert '<h2 class="eyebrow am" style="display:block;margin-top:30px">Blocked by</h2>' not in (
-        resp.text
-    )
+    assert '<h2 class="eyebrow am section-head">Blocked by</h2>' not in resp.text
 
 
 def test_item_detail_with_unsatisfied_blocker_does_not_also_show_no_open_blockers(
diff --git a/tests/unit/test_chartsvg.py b/tests/unit/test_chartsvg.py
index b8566ba..66e17db 100644
--- a/tests/unit/test_chartsvg.py
+++ b/tests/unit/test_chartsvg.py
@@ -16,6 +16,7 @@
 import xml.etree.ElementTree as ET
 
 from amplifier_work_tracker import chartsvg as C
+from amplifier_work_tracker import webtheme as T
 
 # A raw hex/rgb colour literal -- the design-system firewall (widgets.py's
 # firewall_check) forbids this anywhere in widget-authored HTML; chartsvg's
@@ -437,13 +438,21 @@ def test_age_histogram_zero_bucket_draws_a_deliberate_stub_no_value_label() -> N
     zero_normal, nonzero, zero_watch = bars
     assert float(zero_normal.get("height", "")) == 2.0
     assert float(zero_normal.get("y", "")) == round(baseline_y - 2.0, 2)
-    assert "fill:var(--ink-quiet)" in (zero_normal.get("style") or "")
+    # The stub's fill is named ONCE, in the stylesheet -- the markup carries
+    # only what the element IS (`zero-stub`) and, for the watch band, its
+    # state. Both halves are asserted, or "it has the class" would pass with
+    # no rule behind it.
+    assert zero_normal.get("class") == "zero-stub"
+    assert zero_normal.get("data-watch") is None
+    assert ".svg-chart .zero-stub{fill:var(--ink-quiet)}" in T.CSS
 
     assert float(nonzero.get("height", "")) > 2.0
     assert nonzero.get("class") == "bar"
 
     assert float(zero_watch.get("height", "")) == 2.0
-    assert "fill:var(--watch)" in (zero_watch.get("style") or "")
+    assert zero_watch.get("class") == "zero-stub"
+    assert zero_watch.get("data-watch") == "1"
+    assert ".svg-chart .zero-stub[data-watch]{fill:var(--watch)}" in T.CSS
 
     value_labels = root.findall("text[@class='axis-label']")
     value_texts = [t.text for t in value_labels if t.text and t.text.isdigit()]
@@ -455,3 +464,104 @@ def test_age_histogram_zero_bucket_draws_a_deliberate_stub_no_value_label() -> N
     assert "0-1d" in axis_label_texts
     assert "2-3d" in axis_label_texts
     assert "7+d" in axis_label_texts
+
+
+# ===========================================================================
+# The chart ink used to be INLINE. Moving it to the stylesheet (Core 4,
+# OSV1-005) is only equivalent if the new rules WIN the cascade -- an inline
+# `style=` outranks every stylesheet rule, so a selector that merely exists is
+# not a replacement for one. The first form of that migration shipped
+# `.axis-label[data-watch]{fill:var(--watch)}` (0,2,0), which LOSES to the
+# pre-existing `.wt-observatory .svg-chart .axis-label{fill:var(--ink-tertiary)}`
+# (0,3,0): the watch band, the value labels and today's tick all silently
+# reverted to tertiary ink, and the Tier-B sweep measured 182 fewer `--watch`
+# pixels on a dark L1. These tests are the guard for that whole class of bug.
+# ===========================================================================
+
+_CSS_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+#: One `selector-list { declarations }` rule. Bodies never nest, so this also
+#: finds the rules inside an `@media` block (the at-rule itself never matches).
+_CSS_RULE = re.compile(r"([^{}]+)\{([^{}]*)\}")
+_FILL_DECL = re.compile(r"(?:^|;)\s*fill\s*:", re.MULTILINE)
+_TYPE_SELECTOR = re.compile(r"(?:^|[\s>+~])[a-zA-Z]")
+
+
+def _specificity(selector: str) -> tuple[int, int, int]:
+    """CSS specificity (ids, classes+attributes+pseudo-classes, type names).
+
+    Only the shapes this stylesheet actually uses are handled, and a selector
+    carrying a TYPE name is rejected rather than mis-scored -- a helper that
+    quietly returns the wrong number would make this whole file lie.
+    """
+    assert not _TYPE_SELECTOR.search(selector), (
+        f"{selector!r} carries a type selector; this helper only scores the "
+        f"class/attribute shapes the chart rules use. Extend it before using it."
+    )
+    ids = len(re.findall(r"#[\w-]+", selector))
+    classes = len(re.findall(r"\.[\w-]+", selector))
+    attrs = len(re.findall(r"\[[^\]]+\]", selector))
+    return (ids, classes + attrs, 0)
+
+
+def _fill_rules(css: str) -> list[tuple[str, int]]:
+    """(selector, offset) for every selector in a rule that declares `fill`."""
+    plain = _CSS_COMMENT.sub(" ", css)
+    out: list[tuple[str, int]] = []
+    for m in _CSS_RULE.finditer(plain):
+        if not _FILL_DECL.search(m.group(2)):
+            continue
+        for sel in m.group(1).split(","):
+            out.append((sel.strip(), m.start()))
+    return out
+
+
+def _wins(challenger: tuple[str, int], incumbent: tuple[str, int]) -> bool:
+    """Does `challenger` beat `incumbent` in the cascade? Higher specificity,
+    or equal specificity and declared later."""
+    c_sel, c_at = challenger
+    i_sel, i_at = incumbent
+    c, i = _specificity(c_sel), _specificity(i_sel)
+    return c > i or (c == i and c_at > i_at)
+
+
+def test_chart_state_ink_outranks_the_generic_axis_label_rule() -> None:
+    """Every `[data-*]` chart-ink rule must beat every unconditional rule that
+    also paints an `.axis-label` -- otherwise the state never renders."""
+    rules = _fill_rules(T.CSS)
+    axis = [r for r in rules if ".axis-label" in r[0]]
+    assert axis, "no rule paints `.axis-label` at all -- the chart ink is gone"
+
+    generic = [r for r in axis if "[data-" not in r[0]]
+    stateful = [r for r in axis if "[data-" in r[0]]
+    assert generic, (
+        "no unconditional `.axis-label` fill rule remains. That rule is the "
+        "trap these tests exist for; if it really went away, delete this test "
+        "deliberately rather than letting it pass vacuously."
+    )
+    assert stateful, "no stateful chart-ink rule found -- did the data attributes move?"
+
+    for challenger in stateful:
+        for incumbent in generic:
+            assert _wins(challenger, incumbent), (
+                f"`{challenger[0]}` {_specificity(challenger[0])} does NOT beat "
+                f"`{incumbent[0]}` {_specificity(incumbent[0])} in the cascade, so the "
+                f"state it encodes never paints. The ink it replaced was INLINE, which "
+                f"outranks everything -- scope the selector (e.g. through `.svg-chart`) "
+                f"rather than trusting declaration order alone."
+            )
+
+
+def test_every_chart_label_kind_has_a_default_ink() -> None:
+    """`.val-label` and `.zero-stub` carried their fill INLINE on every render.
+    Once that is removed, an SVG `<text>`/`<rect>` with no rule falls back to
+    the initial `fill:black` -- invisible on the dark ground -- so each kind
+    must keep an UNCONDITIONAL rule, not only its `[data-*]` states."""
+    rules = _fill_rules(T.CSS)
+    for kind in (".val-label", ".zero-stub", ".axis-label"):
+        unconditional = [r for r in rules if kind in r[0] and "[data-" not in r[0]]
+        assert unconditional, (
+            f"`{kind}` has no unconditional fill rule. Its ink used to be inline on "
+            f"every render; without a default the element falls back to the SVG "
+            f"initial value (black), which reads as invisible in dark mode and as a "
+            f"colour nobody chose in light."
+        )
diff --git a/tests/unit/test_dashboard_ledger.py b/tests/unit/test_dashboard_ledger.py
index e6baff7..e8bbb09 100644
--- a/tests/unit/test_dashboard_ledger.py
+++ b/tests/unit/test_dashboard_ledger.py
@@ -20,6 +20,7 @@
 
 from amplifier_work_tracker import adapter as A  # noqa: E402
 from amplifier_work_tracker import webapp as W  # noqa: E402
+from amplifier_work_tracker import webtheme as T  # noqa: E402
 
 
 def _summary(name: str, **kwargs) -> A.ProjectSummary:
@@ -75,11 +76,23 @@ def test_state_legend_zero_count_shows_real_number_not_hidden():
 
 
 def test_state_legend_nonzero_states_use_their_dedicated_fill():
+    """Each slot carries its own fill CLASS, and the stylesheet resolves that
+    class to the intended token.
+
+    Asserted in BOTH halves on purpose. The fill used to be an inline
+    `background:var(--...)` this test could read straight off the markup;
+    after the Core 4 migration the markup carries only a class name, so a
+    class-only assertion would pass just as happily if webtheme declared
+    nothing at all. The second half is what keeps this test about COLOUR.
+    """
     counts = {"ready": 1, "held": 1, "blocked": 1, "deferred": 1, "resolved": 1}
     html = W._state_legend_html(counts)  # noqa: SLF001
-    assert "var(--st-ready)" in html
-    assert "var(--amber)" in html  # held reuses the app-wide attention hue
-    assert "var(--crimson)" in html  # blocked reuses the app-wide escalation hue
+    for key in ("ready", "held", "blocked", "deferred", "resolved"):
+        assert f'class="sw fill-{key}"' in html
+    assert ".sw.fill-ready{background:var(--st-ready)}" in T.CSS
+    # held reuses the app-wide attention hue; blocked the escalation hue
+    assert ".sw.fill-held{background:var(--amber)}" in T.CSS
+    assert ".sw.fill-blocked{background:var(--crimson)}" in T.CSS
 
 
 # ------------------------------------------------------- alarm floor width
@@ -91,7 +104,7 @@ def test_state_bar_calm_zero_alarm_states_have_no_min_width_floor():
     held/blocked/deferred segment)."""
     counts = {"ready": 5, "held": 0, "blocked": 0, "deferred": 0, "resolved": 3}
     html = W._state_bar_html(counts)  # noqa: SLF001
-    assert "min-width" not in html
+    assert "alarm-floor" not in html
 
 
 def test_state_bar_tiny_held_count_among_huge_total_still_gets_alarm_floor():
@@ -100,18 +113,22 @@ def test_state_bar_tiny_held_count_among_huge_total_still_gets_alarm_floor():
     near-invisible) sliver -- it must carry the alarm floor width."""
     counts = {"ready": 998, "held": 1, "blocked": 0, "deferred": 0, "resolved": 1}
     html = W._state_bar_html(counts)  # noqa: SLF001
-    assert f"flex:1 1 0;background:var(--amber);min-width:{W._ALARM_MIN_PX}px" in html  # noqa: SLF001
+    assert '<i class="fill-held alarm-floor" style="flex:1 1 0">' in html
+    # ... and the floor is a REAL width, declared once in the stylesheet --
+    # without this half the assertion above is only about a class name.
+    assert ".sbar i.alarm-floor{min-width:16px}" in T.CSS
     # the calm ready/resolved segments never get the floor -- they are not
     # alarm states and routinely carry large real counts of their own.
-    assert "flex:998 1 0;background:var(--st-ready)" in html
-    assert "min-width" not in html.split("var(--st-ready)")[1].split("<i")[0]
+    assert '<i class="fill-ready" style="flex:998 1 0">' in html
+    assert "alarm-floor" not in html.split('class="fill-ready"')[1].split("<i")[0]
 
 
 def test_state_bar_blocked_and_deferred_also_get_the_alarm_floor():
     counts = {"ready": 1, "held": 0, "blocked": 2, "deferred": 3, "resolved": 0}
     html = W._state_bar_html(counts)  # noqa: SLF001
-    assert f"flex:2 1 0;background:var(--crimson);min-width:{W._ALARM_MIN_PX}px" in html  # noqa: SLF001
-    assert f"flex:3 1 0;background:var(--st-deferred);min-width:{W._ALARM_MIN_PX}px" in html  # noqa: SLF001
+    assert '<i class="fill-blocked alarm-floor" style="flex:2 1 0">' in html
+    assert '<i class="fill-deferred alarm-floor" style="flex:3 1 0">' in html
+    assert ".sbar i.alarm-floor{min-width:16px}" in T.CSS
 
 
 # ------------------------------------------------------------- sort order
@@ -259,7 +276,7 @@ def test_workspace_composition_zero_total_never_divides_by_zero():
 def test_dashboard_row_broken_project_is_unmissable_alarm_row():
     s = A.ProjectSummary(name="brokenq", status="ERROR: database unreachable")
     html = W._dashboard_row(s)  # noqa: SLF001
-    assert 'class="alarm"' in html
+    assert 'class="alarm attn-row is-blocked"' in html
     assert 'colspan="5"' in html
     assert "Broken" in html
 
@@ -283,14 +300,20 @@ def test_dashboard_row_calm_project_has_no_alarm_styling():
     background noise on every row."""
     s = _summary("calmq", total=10, ready=10)
     html = W._dashboard_row(s)  # noqa: SLF001
-    assert "box-shadow" not in html
+    assert "attn-row" not in html
     assert "healthy" in html  # data-t search key still names the calm state
 
 
 def test_dashboard_row_held_item_flags_the_row_amber():
     s = _summary("heldq", total=5, ready=4, held=1)
     html = W._dashboard_row(s)  # noqa: SLF001
-    assert "box-shadow:inset 4px 0 0 var(--amber)" in html
+    assert 'class="attn-row"' in html
+    # the class is only half the claim -- the stylesheet is where the accent
+    # and its tint are actually declared, and they must travel together.
+    assert (
+        "tr.attn-row{background:var(--alarm-surface);"
+        "box-shadow:inset 4px 0 0 var(--amber)}" in T.CSS
+    )
     assert "held" in html.split('data-t="')[1].split('"')[0]
 
 
@@ -300,14 +323,14 @@ def test_dashboard_row_blocked_item_flags_the_row_crimson_outranking_held():
     `_state_bar_html`'s own hue assignment)."""
     s = _summary("stuckq", total=5, ready=3, held=1, blocked=1)
     html = W._dashboard_row(s)  # noqa: SLF001
-    assert "box-shadow:inset 4px 0 0 var(--crimson)" in html
-    assert "var(--amber)" not in html.split("box-shadow")[0][-40:]
+    assert 'class="attn-row is-blocked"' in html
+    assert "box-shadow:inset 4px 0 0 var(--crimson)}" in T.CSS
 
 
 def test_dashboard_row_deferred_item_also_flags_the_row():
     s = _summary("deferredq", total=5, ready=4, deferred=1)
     html = W._dashboard_row(s)  # noqa: SLF001
-    assert "box-shadow:inset 4px 0 0 var(--amber)" in html
+    assert 'class="attn-row"' in html
     assert "deferred" in html.split('data-t="')[1].split('"')[0]
 
 
diff --git a/tests/unit/test_observatory_widgets.py b/tests/unit/test_observatory_widgets.py
index 834c2fe..8885129 100644
--- a/tests/unit/test_observatory_widgets.py
+++ b/tests/unit/test_observatory_widgets.py
@@ -374,7 +374,7 @@ def _hero_counts(*, held: int, blocked: int, attention: int, ready: int) -> list
             value=blocked,
             href="#attention-queue",
             icon="i-octagon-x",
-            icon_color_var="--blocked",
+            icon_class="ic-blocked",
             is_blocked=True,
         ),
         WD.KpiCard(
@@ -550,7 +550,7 @@ def test_render_kpi_strip_blocked_zero_gets_quiet_class() -> None:
                 value=0,
                 href="#",
                 icon="i-octagon-x",
-                icon_color_var="--blocked",
+                icon_class="ic-blocked",
                 is_blocked=True,
             ),
             WD.KpiCard(key="resolved24h", label="Resolved 24h", value=29, href="#"),
diff --git a/tests/unit/test_webapp_item_render.py b/tests/unit/test_webapp_item_render.py
index 052af13..b279ba5 100644
--- a/tests/unit/test_webapp_item_render.py
+++ b/tests/unit/test_webapp_item_render.py
@@ -18,6 +18,7 @@
 pytest.importorskip("fastapi", reason="the 'web' extra is not installed")
 
 from amplifier_work_tracker import adapter as A  # noqa: E402
+from amplifier_work_tracker import webtheme as T  # noqa: E402
 from amplifier_work_tracker.webapp import (  # noqa: E402
     _activity_feed_html,
     _content_block_html,
@@ -99,9 +100,14 @@ def test_content_block_html_shows_empty_message_when_text_is_empty_string():
 def test_content_block_html_renders_provided_text_with_monospace_and_measure():
     html = _content_block_html("hello world", empty_message="unused")
     assert "hello world" in html
-    assert 'class="content-block"' in html
-    assert "monospace" in html
-    assert "max-width:90ch" in html
+    assert 'class="content-block mono-measure"' in html
+    # The font stack and the ~90ch measure used to be built in Python and
+    # interpolated into an inline `style=`. They now live once in the
+    # stylesheet, so BOTH halves are asserted -- the markup carrying the class,
+    # and the class actually resolving to a monospace face and that measure.
+    rule = T.CSS.split(".content-block.mono-measure{", 1)[1].split("}", 1)[0]
+    assert "monospace" in rule
+    assert "max-width:90ch" in rule
 
 
 def test_content_block_html_renders_markdown_inside_the_block():
