refactor(ui): the badge layer gets one owner per shape (#3132 items 1-3)

ITEM 1 — the dead canon. StatusBadge is recorded canon (#2960) and its only
consumer, TaskCard, has been unreachable since 2026-04-08, when
TasksListView was deleted in favour of the Knowledge view. Four and a half
months of a canon that rendered nowhere, which is worse than no canon: a
session pulls #2960, builds from it, and matches a component nobody has
seen. TaskCard is deleted (rule 22), and the canon is made real by adoption
rather than by being left as a museum piece.

ITEM 2 — MY OWN ISSUE OVERSTATED THIS, and the correction is the finding.
"Three scoped re-spellings" assumed one shape spelled thrice. Reading them:

  KnowledgeView   a task-status chip, just smaller     -> a real duplicate
  WorkspaceTaskPanel  a CLICKABLE cycler: pointer,
                  outlined, transparent background     -> a control, not a chip
  ProjectView     PROJECT lifecycle (active/paused/
                  completed/archived)                  -> a different vocabulary

Only the first was ever a duplicate. The others shared a class NAME and
nothing else — which is exactly what would make a future consolidation merge
three unrelated things. So: KnowledgeView adopts StatusBadge/PriorityBadge
via the `compact` variant the canon already anticipated ("interactive/compact
re-spellings are variants of it"); the cycler becomes `.status-cycler`; and
project status becomes its own vocabulary.

And there was a FOURTH, in ProjectListView — the genuine duplicate of
ProjectView's project pill, differing by the amounts two hands differ by:
0.68rem vs 0.7rem, a 14% tint vs 15%, one bordered and one not. Both now use
one ProjectStatusBadge. `statusLabel` went with its only caller.

ITEM 3 — weight. StatusBadge and PriorityBadge used font-weight 600; the
house style allows 400 and 500 only. Also "In Progress" -> "In progress",
which was invisible under `text-transform: uppercase` and becomes visible the
moment the compact variant turns that off.

THE GUARD MISSED FOUR LIVE SITES, which is the part worth keeping. The
project pills painted a hue on an inline `color-mix` tint of itself —
measured 1.61-2.39:1 — and the checker only knew the `--fs-X-bg` token form.
Widened, it finds 48 across the app, 26 of them --fs-accent.

That backlog is not this task, so the check now splits: it GATES the token
form, which is clean, and REPORTS the inline form with a count and its worst
offenders. A gate nobody can satisfy today gets switched off, and then it
guards nothing. Gate re-verified by reintroducing a defect — exit 1 with it,
exit 0 without.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

scripts/check_design_tokens.py

@@ -106,14 +106,36 @@ SAME_TOKEN_PAIR = re.compile(
 )
 
 
-def same_hue_text_on_tint(css: str) -> list[str]:
-    """Tokens used as TEXT on a tint of themselves, within one rule block."""
-    hits = []
+def same_hue_text_on_tint(css: str) -> tuple[list[str], list[str]]:
+    """Tokens used as TEXT on a tint of themselves, within one rule block.
+
+    TWO SPELLINGS of the same background, because the first version of this
+    check only knew the first and missed four live instances:
+
+      background: var(--fs-X-bg)                       the token
+      background: color-mix(in srgb, var(--fs-X) N%, transparent)   inline
+
+    The inline form is what the project-status pills used, and it is the more
+    dangerous of the two — it does not even name a `-bg` token, so nothing
+    about it looks like the pattern until you measure it.
+
+    Returned separately because they are at different stages. The token form
+    is CLEAN and therefore gates. The inline form has a live backlog (48 sites
+    when this split was written, 26 of them --fs-accent), so it reports with a
+    count: a gate nobody can satisfy today gets switched off, and then it
+    guards nothing.
+    """
+    token_form, inline_form = [], []
     for body in re.findall(r"\{([^{}]*)\}", css):
         fg = set(re.findall(r"color\s*:\s*var\(\s*(--fs-[\w-]+?)\s*\)", body))
-        bg = set(re.findall(r"background(?:-color)?\s*:\s*var\(\s*(--fs-[\w-]+?)-bg\s*\)", body))
-        hits.extend(sorted(fg & bg))
-    return hits
+        bg_tok = set(re.findall(r"background(?:-color)?\s*:\s*var\(\s*(--fs-[\w-]+?)-bg\s*\)", body))
+        bg_inl = set(re.findall(
+            r"background(?:-color)?\s*:\s*color-mix\([^;]*?var\(\s*(--fs-[\w-]+?)\s*\)[^;]*?\)",
+            body,
+        ))
+        token_form.extend(sorted(fg & bg_tok))
+        inline_form.extend(sorted(fg & (bg_inl - bg_tok)))
+    return token_form, inline_form
 
 
 def main() -> int:
@@ -144,6 +166,7 @@ def main() -> int:
 
     unresolved: list[tuple[pathlib.Path, str]] = []
     same_hue_hits: list[tuple[pathlib.Path, str]] = []
+    inline_tint_hits: list[tuple[pathlib.Path, str]] = []
     superseded_hits: list[tuple[pathlib.Path, str, str]] = []
     literal_count = 0
 
@@ -167,8 +190,11 @@ def main() -> int:
 
         literal_count += len(HEX_LITERAL.findall(css))
 
-        for tok in same_hue_text_on_tint(css):
+        tok_hits, inl_hits = same_hue_text_on_tint(css)
+        for tok in tok_hits:
             same_hue_hits.append((path, tok))
+        for tok in inl_hits:
+            inline_tint_hits.append((path, tok))
 
     if unresolved:
         print(f"FAIL — {len(unresolved)} unresolvable var() reference(s).")
@@ -203,7 +229,17 @@ def main() -> int:
             print(f"    {path}: color: var({tok}) on var({tok}-bg) -> var({tok}-fg)")
         print()
     else:
-        print("OK — no text painted with a token on a tint of itself.\n")
+        print("OK — no text painted with a token on a tint of its own -bg.\n")
+
+    if inline_tint_hits:
+        by_tok: dict[str, int] = {}
+        for _p, tok in inline_tint_hits:
+            by_tok[tok] = by_tok.get(tok, 0) + 1
+        print(f"REPORT — {len(inline_tint_hits)} rule(s) paint text with a token on "
+              f"an INLINE color-mix tint of that same token.")
+        print("  Same defect, spelled without a -bg token so it does not gate yet.")
+        print("  Worst offenders: " + ", ".join(
+            f"{t} x{n}" for t, n in sorted(by_tok.items(), key=lambda kv: -kv[1])[:4]) + "\n")
 
     if args.report_literals:
         print(f"REPORT — {literal_count} raw colour literal(s) in component CSS.")