@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_skill_inventory.py

@@ -0,0 +1,368 @@
+"""skill_inventory.py: SKILL.md frontmatter parsing + `projects` field
+coercion.
+
+Covers the path that tags skills with their declared project scope.
+The hook consumes this list and uses it as a hard filter, so misreads
+here turn into silently-wrong filter decisions at runtime."""
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+import skill_inventory as si   # provided by coach/tests/conftest.py
+
+
+@pytest.fixture
+def isolated_argv(monkeypatch):
+    """``si.main()`` calls ``argparse.parse_args()`` which reads
+    ``sys.argv``. Inside pytest that's pytest's own argv (``tests/``,
+    ``-v``, etc.) and argparse bails. Pin it to a clean single-element
+    list so the parser sees no flags — the tests rely on defaults."""
+    monkeypatch.setattr(sys, "argv", ["skill_inventory.py"])
+
+
+# --- _parse_frontmatter_text ----------------------------------------------
+
+def test_parse_frontmatter_reads_scalar_fields():
+    text = """---
+name: demo
+description: "Do a demo thing"
+---
+
+Body here.
+"""
+    fm = si._parse_frontmatter_text(text)
+    assert fm["name"] == "demo"
+    assert fm["description"] == "Do a demo thing"
+
+
+def test_parse_frontmatter_reads_inline_list():
+    text = """---
+name: demo
+projects: [service, acme-app]
+---
+
+Body.
+"""
+    fm = si._parse_frontmatter_text(text)
+    assert fm["projects"] == ["service", "acme-app"]
+
+
+def test_parse_frontmatter_reads_block_list():
+    text = """---
+name: demo
+projects:
+  - service
+  - acme-app
+  - widget
+---
+"""
+    fm = si._parse_frontmatter_text(text)
+    assert fm["projects"] == ["service", "acme-app", "widget"]
+
+
+def test_parse_frontmatter_no_frontmatter():
+    assert si._parse_frontmatter_text("just a markdown file\n") == {}
+
+
+def test_parse_frontmatter_malformed_yaml_is_silent():
+    """The deterministic insights pass runs unattended on cron; a single
+    broken SKILL.md must not crash the whole inventory pass. Bad YAML →
+    empty dict → skill is skipped for lack of description (its own
+    graceful failure further up)."""
+    text = """---
+this is: not: valid: yaml
+  - because
+     indentation:
+---
+body
+"""
+    assert si._parse_frontmatter_text(text) == {}
+
+
+def test_parse_frontmatter_non_dict_root_returns_empty():
+    """If a SKILL.md author writes a YAML list at the top level instead
+    of a mapping, we still degrade to empty rather than crash."""
+    text = """---
+- alpha
+- beta
+---
+"""
+    assert si._parse_frontmatter_text(text) == {}
+
+
+# --- _coerce_projects ------------------------------------------------------
+
+def test_coerce_projects_list():
+    assert si._coerce_projects(["service", "widget"]) == ["service", "widget"]
+
+
+def test_coerce_projects_scalar_string_becomes_single_list():
+    """Single-project shorthand: ``projects: service`` is common user
+    shorthand and shouldn't be rejected just because it isn't a list."""
+    assert si._coerce_projects("service") == ["service"]
+
+
+def test_coerce_projects_none_is_empty():
+    assert si._coerce_projects(None) == []
+
+
+def test_coerce_projects_strips_empty_and_whitespace():
+    assert si._coerce_projects(["service", "", "  ", "widget  "]) == ["service", "widget"]
+
+
+def test_coerce_projects_ignores_non_strings():
+    # A number or dict snuck into the list must not crash and must be
+    # filtered — we only emit strings downstream.
+    assert si._coerce_projects(["service", 42, {"x": 1}, "widget"]) == ["service", "widget"]
+
+
+def test_coerce_projects_unknown_type_is_empty():
+    assert si._coerce_projects(42) == []
+    assert si._coerce_projects({"a": 1}) == []
+
+
+# --- end-to-end: main() emits the expected shape ---------------------------
+
+def _write_skill(root: Path, sid: str, frontmatter: str) -> None:
+    d = root / sid
+    d.mkdir(parents=True)
+    (d / "SKILL.md").write_text(f"---\n{frontmatter}\n---\n\nBody.\n")
+
+
+def test_inventory_emits_projects_field_when_present(
+        tmp_path, monkeypatch, isolated_argv):
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(skills, "deploy-staging",
+                 "description: Iterate on the avatar\nprojects: [service]")
+    _write_skill(skills, "capability-loop",
+                 "description: Continuous improvement loop")
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    by_id = {h["id"]: h for h in hints}
+    assert by_id["deploy-staging"]["projects"] == ["service"]
+    # Untagged skill: empty list, not missing.
+    assert by_id["capability-loop"]["projects"] == []
+
+
+def test_inventory_skips_skill_without_description(
+        tmp_path, monkeypatch, isolated_argv):
+    """Pre-existing behavior: no description → skill dropped. Adding
+    `projects` support must not change the drop rule."""
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(skills, "mystery", "projects: [service]")   # no description
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    assert hints == []
+
+
+# --- _infer_projects (rolling-history scope inference) ---------------------
+
+def test_infer_projects_zero_history_returns_empty():
+    """Cold-start: no skill has been invoked anywhere yet. Inference
+    must return [] so the hook falls through to the untagged rules."""
+    assert si._infer_projects("deploy-staging", {}) == []
+
+
+def test_infer_projects_below_threshold_returns_empty():
+    """A single invocation in one project is noise — could be an
+    experiment from the wrong cwd. Don't tag until ≥2 hits prove
+    intent. Threshold default is INFER_THRESHOLD = 2."""
+    by_project = {"service": {"deploy-staging": 1}}
+    assert si._infer_projects("deploy-staging", by_project) == []
+
+
+def test_infer_projects_single_project_at_threshold_tags():
+    """≥2 invocations in exactly one project → tagged with that
+    project. This is the canonical inference success case."""
+    by_project = {"service": {"deploy-staging": 2}}
+    assert si._infer_projects("deploy-staging", by_project) == ["service"]
+
+
+def test_infer_projects_one_project_above_threshold_other_below_tags():
+    """The project with ≥2 hits counts as observed; the project with
+    1 hit doesn't. So the skill is still considered single-project
+    scoped — the noisy one-off doesn't graduate it to global."""
+    by_project = {
+        "service":    {"deploy-staging": 5},
+        "widget": {"deploy-staging": 1},   # below threshold; ignored
+    }
+    assert si._infer_projects("deploy-staging", by_project) == ["service"]
+
+
+def test_infer_projects_two_projects_above_threshold_graduates():
+    """Cross-cutting tool: invoked ≥2× in ≥2 projects → return [],
+    treating the skill as global. /design-style skills auto-graduate
+    once the user proves they're using the skill across projects."""
+    by_project = {
+        "service":    {"design": 3},
+        "widget": {"design": 4},
+    }
+    assert si._infer_projects("design", by_project) == []
+
+
+def test_infer_projects_only_other_skills_count():
+    """A project whose only history is a DIFFERENT skill must not
+    count toward this skill's observed set — guards the dict shape
+    against accidental cross-talk between skills."""
+    by_project = {
+        "service":    {"design": 5},                # not deploy-staging
+        "widget": {"deploy-staging": 3},
+    }
+    assert si._infer_projects("deploy-staging", by_project) == ["widget"]
+
+
+def test_infer_projects_tolerates_bad_shapes():
+    """The cron path can't crash on garbled history. Non-dict project
+    buckets, non-numeric counts → silently ignored."""
+    by_project = {
+        "service":    {"deploy-staging": "lots"},   # bad count
+        "broken": "not-a-dict",
+        "widget": {"deploy-staging": 3},
+    }
+    assert si._infer_projects("deploy-staging", by_project) == ["widget"]
+
+
+def test_infer_projects_threshold_param_actually_changes_behavior():
+    """Lock the threshold parameter against drift by using data where
+    different threshold values produce GENUINELY DIFFERENT outputs —
+    not the same `[]` for every value with a misleading comment.
+    A single project at count=1: invisible at threshold=2, observed
+    (and tagged) at threshold=1, still invisible at threshold=3."""
+    by_project = {"service": {"x": 1}}
+    assert si._infer_projects("x", by_project, threshold=2) == []   # below bar
+    assert si._infer_projects("x", by_project, threshold=1) == ["service"]  # ≥ bar
+    assert si._infer_projects("x", by_project, threshold=3) == []   # below bar
+
+
+# --- end-to-end: inventory consumes by_project, frontmatter wins -----------
+
+def test_inventory_uses_inference_when_frontmatter_missing(
+        tmp_path, monkeypatch, isolated_argv):
+    """Skills without frontmatter `projects:` should pick up scope
+    from invocation history, threaded through the --skills-by-project
+    CLI flag."""
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(skills, "deploy-staging",
+                 "description: Iterate on the avatar")   # no projects
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    sbp = tmp_path / "sbp.json"
+    sbp.write_text(json.dumps({"service": {"deploy-staging": 5}}))
+    monkeypatch.setattr(
+        "sys.argv",
+        ["skill_inventory.py", "--skills-by-project", str(sbp)])
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    by_id = {h["id"]: h for h in hints}
+    assert by_id["deploy-staging"]["projects"] == ["service"]
+
+
+def test_inventory_frontmatter_supersedes_inference(
+        tmp_path, monkeypatch, isolated_argv):
+    """Explicit frontmatter `projects:` is authoritative — even when
+    the rolling history would suggest a different (or graduated)
+    scope. Users get deterministic control when they ask for it."""
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(
+        skills, "deploy-staging",
+        "description: Iterate on the avatar\nprojects: [service]")
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    # History would normally graduate the skill to global (≥2 in ≥2
+    # projects), but the frontmatter must win.
+    sbp = tmp_path / "sbp.json"
+    sbp.write_text(json.dumps({
+        "service":    {"deploy-staging": 5},
+        "widget": {"deploy-staging": 5},
+    }))
+    monkeypatch.setattr(
+        "sys.argv",
+        ["skill_inventory.py", "--skills-by-project", str(sbp)])
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    by_id = {h["id"]: h for h in hints}
+    assert by_id["deploy-staging"]["projects"] == ["service"]
+
+
+def test_inventory_no_history_file_falls_back_to_frontmatter_only(
+        tmp_path, monkeypatch, isolated_argv):
+    """If --skills-by-project is omitted (e.g., first run before any
+    history exists), the inventory still works — inference returns
+    [] for everything and only frontmatter-tagged skills get scope."""
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(skills, "untagged", "description: A skill")
+    _write_skill(
+        skills, "tagged",
+        "description: A scoped skill\nprojects: [service]")
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    by_id = {h["id"]: h for h in hints}
+    assert by_id["untagged"]["projects"] == []
+    assert by_id["tagged"]["projects"] == ["service"]
+
+
+def test_inventory_explicit_empty_projects_blocks_inference(
+        tmp_path, monkeypatch, isolated_argv):
+    """A user writing `projects: []` in frontmatter is making a
+    deliberate "this skill is cross-project / global" declaration.
+    History inference must NOT silently re-tag it to a single project,
+    which would reverse the user's intent and quietly hard-block the
+    skill outside that wrongly-inferred scope.
+
+    Lock in the distinction: ``projects: []`` (key present, empty list)
+    is authoritative. Only ``projects:`` absent entirely falls through
+    to inference. Regression for review-finding #1 (2026-04-24)."""
+    skills = tmp_path / "skills"
+    skills.mkdir()
+    _write_skill(
+        skills, "global-by-declaration",
+        "description: A cross-project skill\nprojects: []")
+    monkeypatch.setattr(si, "SKILLS_DIR", skills)
+
+    # Set up a history that WOULD infer scope `[service]` if inference ran.
+    sbp = tmp_path / "sbp.json"
+    sbp.write_text(json.dumps(
+        {"service": {"global-by-declaration": 5}}))
+    monkeypatch.setattr(
+        "sys.argv",
+        ["skill_inventory.py", "--skills-by-project", str(sbp)])
+
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        si.main()
+    hints = json.loads(buf.getvalue())
+    by_id = {h["id"]: h for h in hints}
+    assert by_id["global-by-declaration"]["projects"] == [], (
+        "explicit `projects: []` in frontmatter must beat history "
+        "inference — otherwise a user declaration silently reverses "
+        "into a hard project-scoped filter"
+    )

package/coach/tests/test_stats_hybrid.py

@@ -0,0 +1,142 @@
+"""stats.py — hybrid ELO math.
+
+Regression guard for the 'ELO stopped moving' symptom: level index +
+level-up detection use integer `lifetime + session // 10` (no phantom
+level-ups), while the ELO within-level slide uses float
+`lifetime + session / 10` (rating nudges as raw XP accrues).
+"""
+from __future__ import annotations
+
+import pytest
+
+import stats
+from stats import _compute_hybrid, compute_for_render
+
+
+@pytest.fixture(autouse=True)
+def _hermetic_stats_globals(monkeypatch):
+    """Pin stats.py module globals to the canonical baseline (craft
+    ladder + 1000-2800 ELO range) for the duration of these tests.
+
+    `stats.LEVELS`, `stats.ELO_MIN`, `stats.ELO_MAX` are populated at
+    import time from `~/.claude/coach/.user_config.json` (see
+    `stats._load_runtime_config`). Without this fixture, a user who
+    has run `/config theme <other>` or `/config elo <m> <M>` would see
+    these baseline-pinning tests fail on the installed-copy test
+    workflow advertised in CLAUDE.md, because the level names + ELO
+    interpolation would be reading their live preferences. Tests
+    against `_compute_hybrid` are about the math, not the user's
+    chosen ladder — force defaults here."""
+    monkeypatch.setattr(stats, "LEVELS", stats._build_level_ladder())
+    monkeypatch.setattr(stats, "ELO_MIN", 1000)
+    monkeypatch.setattr(stats, "ELO_MAX", 2800)
+
+
+def test_level_stays_stable_under_session_xp():
+    """Lifetime=4 (L2 Iterator), session 0→15: level should NOT change."""
+    names = {_compute_hybrid(4, s)["name"] for s in range(0, 16)}
+    assert names == {"Iterator"}
+
+
+def test_elo_increases_monotonically_across_session():
+    """ELO must be non-decreasing as raw session XP accrues within a level."""
+    prev = -1
+    for raw in range(0, 16):
+        elo = _compute_hybrid(4, raw)["elo"]
+        assert elo >= prev, f"ELO regressed at raw={raw}: {elo} < {prev}"
+        prev = elo
+
+
+def test_elo_moves_with_every_raw_xp_in_a_level():
+    """The whole point of the hybrid: ELO should not be frozen at session=0
+    value. It must actually tick up between raw=0 and raw=15."""
+    at_zero = _compute_hybrid(4, 0)["elo"]
+    at_fifteen = _compute_hybrid(4, 15)["elo"]
+    assert at_fifteen > at_zero
+    assert at_fifteen - at_zero >= 5   # meaningful movement, not just rounding
+
+
+def test_level_up_fires_only_at_bank_boundary():
+    """Lifetime=7 (L2, threshold to L3 is 8). Raw session 0-9 should stay L2
+    (bank_gain=0). Raw 10+ should cross to L3 (bank_gain=1 → level_xp=8)."""
+    for raw in range(0, 10):
+        assert _compute_hybrid(7, raw)["name"] == "Iterator"
+    for raw in range(10, 16):
+        assert _compute_hybrid(7, raw)["name"] == "Builder"
+
+
+def test_no_phantom_level_up_at_sub_bank_session_xp():
+    """With lifetime=7 and raw=9, progress_xp=7.9 crosses L3 threshold (8)
+    as a float, but level_xp=7 does NOT. Level name must stay Iterator so
+    the user doesn't see a level they're about to fall back from."""
+    h = _compute_hybrid(7, 9)
+    assert h["name"] == "Iterator"
+    assert h["level_xp"] == 7
+    assert h["progress_xp"] == pytest.approx(7.9)
+
+
+def test_sigil_pct_glides_live_within_session():
+    """Sigil pct derives from progress_xp (float), not level_xp — so it
+    should change for sub-bank raw XP movements even when level_xp is fixed."""
+    a = _compute_hybrid(4, 2)["sigil_pct"]
+    b = _compute_hybrid(4, 8)["sigil_pct"]
+    assert b > a
+
+
+def test_zero_session_matches_pure_lifetime_baseline():
+    """Sanity: session=0 ⇒ level_xp == progress_xp == lifetime."""
+    h = _compute_hybrid(42, 0)
+    assert h["level_xp"] == 42
+    assert h["progress_xp"] == 42
+
+
+def test_hybrid_renders_expected_elo_for_user_baseline():
+    """Baseline lock: ◆ Ⅱ 1044 Iterator with session=0 should map to L2
+    Iterator at lifetime=4. Pins the formula so it doesn't drift."""
+    h = _compute_hybrid(4, 0)
+    assert h["name"] == "Iterator"
+    assert h["elo"] == 1044
+
+
+# -----------------------------------------------------------------------------
+# compute_for_render — public render-side helper consumed by the military
+# theme's rank line and any future banner that needs idx + name + elo + roman
+# + medal_count in one call. Medal count = min(5, idx // 4 + 1) — pins the
+# rank-ribbon scaling.
+
+@pytest.mark.parametrize(
+    "lifetime,expected_idx,expected_name,expected_roman,expected_medals,expected_next",
+    [
+        (   0,  0, "Drafter",   "Ⅰ",   1,   3),  # L1 — first rung
+        (  15,  3, "Shipper",   "Ⅳ",   1,  25),  # L4 — last 1-medal rank
+        (  25,  4, "Craftsman", "Ⅴ",   2,  40),  # L5 — first 2-medal rank
+        (  90,  7, "Sensei",    "Ⅷ",   2, 125),  # L8 — last 2-medal rank
+        ( 125,  8, "Luminary",  "Ⅸ",   3, 165),  # L9 — first 3-medal rank
+        ( 510, 15, "Prodigy",   "ⅩⅥ",  4, 585),  # L16 — last 4-medal rank
+        ( 585, 16, "Visionary", "ⅩⅦ",  5, 665),  # L17 — first 5-medal rank (cap)
+        ( 840, 19, "Paragon",   "ⅩⅩ",  5, 935),  # L20 — still capped at 5
+    ],
+)
+def test_compute_for_render_breakpoints(
+    lifetime, expected_idx, expected_name, expected_roman, expected_medals,
+    expected_next,
+):
+    out = compute_for_render(lifetime, 0)
+    assert out["idx"] == expected_idx
+    assert out["name"] == expected_name
+    assert out["roman"] == expected_roman
+    assert out["medal_count"] == expected_medals
+    assert out["next_xp"] == expected_next
+    # ELO must agree with _compute_hybrid for the same inputs (single source
+    # of truth — compute_for_render is just a wrapper).
+    assert out["elo"] == _compute_hybrid(lifetime, 0)["elo"]
+
+
+def test_compute_for_render_session_xp_affects_elo_not_medal():
+    """Within-level session XP slides ELO but never changes medal_count
+    (which is purely a function of level idx, not float progress_xp)."""
+    a = compute_for_render(4, 0)
+    b = compute_for_render(4, 15)
+    assert a["medal_count"] == b["medal_count"]  # same level
+    assert a["idx"] == b["idx"]
+    assert b["elo"] >= a["elo"]  # session XP nudges rating

package/coach/tests/test_status_accounting.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+
+import yaml
+
+import status
+
+
+def test_status_splits_lifetime_xp_buckets(tmp_path, monkeypatch, capsys):
+    profile = tmp_path / "profile.yaml"
+    ledger = tmp_path / "banked_sessions.json"
+    changelog = tmp_path / "changelog.md"
+    projects = tmp_path / "projects"
+    projects.mkdir()
+    ledger.write_text(json.dumps({"s1": {"xp": 12, "banked": 1}}))
+    changelog.write_text("")
+    profile.write_text(yaml.safe_dump({
+        "entries": [{"id": "w1", "direction": "negative", "clean_streak_runs": 2}],
+        "graduated": [{"id": "done"}],
+        "archived": [{"id": "aged-out", "direction": "negative"}],
+        "session_banked_xp": 4,
+        "milestone_xp": 3,
+        "manual_adjustments": 1,
+    }))
+    monkeypatch.setattr(status, "PROFILE", profile)
+    monkeypatch.setattr(status, "LEDGER", ledger)
+    monkeypatch.setattr(status, "CHANGELOG", changelog)
+    monkeypatch.setattr(status, "PROJECTS", projects)
+
+    status.main()
+
+    out = capsys.readouterr().out
+    assert "Lifetime (15 xp)" in out
+    assert "graduated patterns (1 × 5)" in out
+    assert "completed sessions (1 sessions at 10:1)" in out
+    assert "mid-streak milestones" in out
+    assert "manual adjustments" in out
+    assert "1 retired" in out
+    assert "1 archived" in out
+    assert "banked from past sessions" not in out

package/coach/tests/test_statusline_failsafe.py

@@ -0,0 +1,70 @@
+"""Statusline render path is fail-soft.
+
+CLAUDE.md treats hook fail-soft as non-negotiable; the statusline shares
+the same property pragmatically — it runs on every Claude Code render,
+and a traceback there both blanks the prefix and noises up the user's
+terminal. These tests pin both `default_statusline.main()` and
+`stats.main()` to swallow exceptions and exit 0, matching the hook
+fail-soft contract in `hooks/coach-session-start.py`.
+"""
+from __future__ import annotations
+
+import io
+import json
+import sys
+
+import pytest
+
+
+def test_default_statusline_main_failsafe_on_render_exception(monkeypatch, capsys):
+    """If render_segment raises, default_statusline.main returns 0 — no traceback."""
+    import default_statusline as ds
+
+    def boom(*_a, **_kw):
+        raise RuntimeError("simulated corrupt profile mid-write")
+
+    monkeypatch.setattr(ds, "render_segment", boom)
+
+    payload = json.dumps({
+        "model": {"display_name": "Claude Sonnet 4.6"},
+        "context_window": {"used_percentage": 42},
+    })
+    monkeypatch.setattr("sys.stdin", io.StringIO(payload))
+
+    rc = ds.main()
+    assert rc == 0
+    captured = capsys.readouterr()
+    # The prefix may or may not have been flushed before the exception;
+    # what matters is no traceback escaped to stderr.
+    assert "Traceback" not in captured.err
+    assert "RuntimeError" not in captured.err
+
+
+def test_stats_main_failsafe_on_render_exception(monkeypatch, capsys):
+    """If render_segment raises, stats.main returns 0 — no traceback."""
+    import stats
+
+    def boom(*_a, **_kw):
+        raise RuntimeError("simulated render failure")
+
+    monkeypatch.setattr(stats, "render_segment", boom)
+    monkeypatch.setattr("sys.stdin", io.StringIO("{}"))
+
+    rc = stats.main()
+    assert rc == 0
+    captured = capsys.readouterr()
+    assert "Traceback" not in captured.err
+    assert "RuntimeError" not in captured.err
+
+
+def test_default_statusline_main_failsafe_on_corrupt_stdin(monkeypatch, capsys):
+    """A non-JSON stdin payload still exits 0 — covered by _read_stdin_payload's
+    own try/except, but pinned here as the user-visible contract."""
+    import default_statusline as ds
+
+    monkeypatch.setattr("sys.stdin", io.StringIO("{ not valid json"))
+
+    rc = ds.main()
+    assert rc == 0
+    captured = capsys.readouterr()
+    assert "Traceback" not in captured.err