@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_configure.py

@@ -0,0 +1,258 @@
+"""configure.py — set / preview / wizard CLI for coach-claw config."""
+from __future__ import annotations
+
+import json
+import sys
+
+import pytest
+
+import configure
+
+
+@pytest.fixture
+def isolated_config(tmp_path, monkeypatch):
+    """Redirect config to a tmp dir via COACH_CONFIG_DIR — same pattern
+    as test_user_config.py."""
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(tmp_path))
+    return tmp_path / ".user_config.json"
+
+
+def _make_input_sequence(*answers):
+    """Build a fake `input()` that returns `answers` in order. Raises if
+    the wizard asks for more answers than provided — catches infinite-
+    loop bugs in the validation re-prompt path."""
+    it = iter(answers)
+
+    def fake_input(prompt: str = "") -> str:
+        try:
+            return next(it)
+        except StopIteration:
+            raise AssertionError(
+                "wizard asked for more input than the test provided "
+                f"(last prompt: {prompt!r})"
+            )
+
+    return fake_input
+
+
+# --- set ------------------------------------------------------------------
+
+def test_set_writes_all_three_keys(isolated_config, capsys):
+    rc = configure.main(["set", "--theme", "ocean",
+                         "--statusline", "pips",
+                         "--elo", "1200", "2600"])
+    assert rc == 0
+    payload = json.loads(isolated_config.read_text())
+    assert payload["theme"] == "ocean"
+    assert payload["statusline_variant"] == "pips"
+    assert payload["elo_min"] == 1200
+    assert payload["elo_max"] == 2600
+    out = capsys.readouterr().out
+    assert "saved" in out
+
+
+def test_set_partial_preserves_other_keys(isolated_config):
+    """Only the keys the user passes should change. Unspecified keys
+    must keep whatever was already in the config."""
+    # Seed with non-default values
+    import user_config
+    user_config.save({
+        "theme": "skyrim",
+        "statusline_variant": "forge",
+        "elo_min": 800,
+        "elo_max": 3000,
+    })
+
+    rc = configure.main(["set", "--theme", "ocean"])
+    assert rc == 0
+
+    payload = json.loads(isolated_config.read_text())
+    assert payload["theme"] == "ocean"             # changed
+    assert payload["statusline_variant"] == "forge"  # preserved
+    assert payload["elo_min"] == 800               # preserved
+    assert payload["elo_max"] == 3000              # preserved
+
+
+def test_set_rejects_unknown_theme(isolated_config, capsys):
+    rc = configure.main(["set", "--theme", "atlantis"])
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "theme" in err.lower()
+    # Existing config (none in this case) must not have been corrupted.
+    assert not isolated_config.exists()
+
+
+def test_set_rejects_unknown_variant(isolated_config, capsys):
+    rc = configure.main(["set", "--statusline", "rainbow"])
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "statusline_variant" in err.lower() or "statusline" in err.lower()
+
+
+def test_set_rejects_invalid_elo_range(isolated_config, capsys):
+    rc = configure.main(["set", "--elo", "2000", "1000"])
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "elo" in err.lower()
+
+
+def test_set_rejects_negative_elo(isolated_config):
+    """Negative ELO bounds fail at argparse parse time (before func runs)."""
+    with pytest.raises(SystemExit):
+        configure.main(["set", "--elo", "-100", "2800"])
+
+
+def test_set_with_no_flags_complains_and_exits_nonzero(isolated_config, capsys):
+    rc = configure.main(["set"])
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "nothing to do" in err.lower() or "preview" in err.lower()
+
+
+# --- preview --------------------------------------------------------------
+
+def test_preview_lists_every_variant(isolated_config, capsys):
+    rc = configure.main(["preview"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    # Every variant key must appear (bracket removed in v0.1.4).
+    for variant in ["crystal", "pips", "slash", "forge"]:
+        assert variant in out
+    # Regression guard: bracket was removed and must not reappear in
+    # the preview enumeration.
+    assert "bracket" not in out
+
+
+def test_preview_lists_every_theme(isolated_config, capsys):
+    rc = configure.main(["preview"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    for theme in ["craft", "ocean", "skyrim", "marvel", "hacker", "lotr"]:
+        assert theme in out
+
+
+def test_preview_marks_current_variant_and_theme(isolated_config, capsys):
+    import user_config
+    user_config.save({"theme": "ocean", "statusline_variant": "pips"})
+
+    rc = configure.main(["preview"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    # The "← current" marker should appear next to the active selections.
+    # Two markers total — one variant, one theme.
+    assert out.count("← current") == 2
+
+
+def test_preview_pads_theme_names_consistently(isolated_config, capsys):
+    """Theme-row format is `f'  {name:>13} → ...'`.
+
+    Pinned because the slash-command skill used to have its own copy
+    of this format string at width `:>7`, while configure.py used
+    `:>13` — outputs drifted apart and a teammate caught the false
+    'byte-equivalent' claim. After v1.0.5 the slash command delegates
+    to configure.py, so configure.py is the single point of truth for
+    the format width. Future intentional format changes require
+    updating this test deliberately.
+    """
+    rc = configure.main(["preview"])
+    assert rc == 0
+    out = capsys.readouterr().out
+
+    # finalfantasy is the longest theme name (12 chars). Padded to width
+    # 13, it gets exactly 1 leading space inside the field — combined
+    # with the 2-char literal indent, that's 3 spaces before the name.
+    assert "   finalfantasy →" in out, (
+        "expected theme name 'finalfantasy' right-padded to width 13; "
+        "format string at coach/bin/configure.py:68 may have changed."
+    )
+
+    # dc is the shortest theme name (2 chars). Padded to width 13 it
+    # gets 11 leading spaces inside the field — plus the 2-char indent
+    # is 13 spaces before the name.
+    assert "             dc →" in out, (
+        "expected theme name 'dc' right-padded to width 13; "
+        "format string at coach/bin/configure.py:68 may have changed."
+    )
+
+
+# --- wizard ---------------------------------------------------------------
+
+def test_wizard_skips_on_non_tty(isolated_config, capsys, monkeypatch):
+    """When stdin is not a TTY, wizard prints a pointer to `set` and
+    exits 0 without reading any input."""
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+    rc = configure.main(["wizard"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "interactive terminal" in out.lower()
+    assert "config set" in out
+    # And nothing was written.
+    assert not isolated_config.exists()
+
+
+def test_wizard_pick_by_number_writes_config(isolated_config, capsys, monkeypatch):
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    # 1) first prompt: variant. Pick "2" — second variant in VARIANTS dict
+    # 2) second prompt: theme. Pick "ocean" by name.
+    from statusline_variants import VARIANTS
+    from themes import list_themes
+    second_variant = list(VARIANTS.keys())[1]
+
+    monkeypatch.setattr("builtins.input", _make_input_sequence("2", "ocean"))
+    rc = configure.main(["wizard"])
+    assert rc == 0
+
+    payload = json.loads(isolated_config.read_text())
+    assert payload["statusline_variant"] == second_variant
+    assert payload["theme"] == "ocean"
+
+
+def test_wizard_enter_keeps_default(isolated_config, capsys, monkeypatch):
+    """Empty input on each prompt keeps the current value; the wizard
+    detects 'no changes' and skips the save call."""
+    import user_config
+    user_config.save({"theme": "ocean", "statusline_variant": "pips"})
+    pre = isolated_config.read_text()
+
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    monkeypatch.setattr("builtins.input", _make_input_sequence("", ""))
+    rc = configure.main(["wizard"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "no changes" in out.lower()
+
+    # File on disk byte-identical
+    assert isolated_config.read_text() == pre
+
+
+def test_wizard_keyboard_interrupt_does_not_save(isolated_config, capsys, monkeypatch):
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+
+    def cancel(_prompt=""):
+        raise KeyboardInterrupt
+
+    monkeypatch.setattr("builtins.input", cancel)
+    rc = configure.main(["wizard"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "cancelled" in out.lower()
+    assert not isolated_config.exists()
+
+
+def test_wizard_invalid_input_reprompts(isolated_config, monkeypatch):
+    """First answer is bogus; second is valid. Wizard must re-prompt
+    rather than crash."""
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    # Variant prompt: "rainbow" (invalid) → re-prompt → "1" (valid)
+    # Theme prompt: "ocean" (valid)
+    monkeypatch.setattr(
+        "builtins.input",
+        _make_input_sequence("rainbow", "1", "ocean"),
+    )
+    rc = configure.main(["wizard"])
+    assert rc == 0
+    payload = json.loads(isolated_config.read_text())
+    # First variant is the default; "1" picks it
+    from statusline_variants import VARIANTS
+    assert payload["statusline_variant"] == list(VARIANTS.keys())[0]
+    assert payload["theme"] == "ocean"

package/coach/tests/test_cron_check.py

@@ -0,0 +1,118 @@
+"""cron_check.is_cron_registered — best-effort detection of whether a
+Coach insights cron/launchd plist is loaded.
+
+Used by the plugin's UserPromptSubmit nudge block to decide whether to
+suggest `npx @rm0nroe/coach-claw launchd`. Detection failures default
+to True (assume registered) so users never get false-positive nudges.
+"""
+from __future__ import annotations
+
+import subprocess
+from unittest.mock import patch, MagicMock
+
+import cron_check
+
+
+# ---------------------------------------------------------------------------
+# macOS path (launchctl)
+# ---------------------------------------------------------------------------
+
+
+def _mock_run(returncode: int, stdout: bytes = b"", stderr: bytes = b""):
+    return MagicMock(returncode=returncode, stdout=stdout, stderr=stderr)
+
+
+def test_macos_returns_true_when_launchctl_finds_plist(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Darwin")
+    with patch.object(cron_check.subprocess, "run", return_value=_mock_run(0)):
+        assert cron_check.is_cron_registered() is True
+
+
+def test_macos_returns_false_when_launchctl_missing_plist(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Darwin")
+    with patch.object(cron_check.subprocess, "run", return_value=_mock_run(113)):
+        assert cron_check.is_cron_registered() is False
+
+
+def test_macos_returns_true_on_subprocess_error(monkeypatch):
+    """Fail-safe: launchctl missing or timing out → assume registered."""
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Darwin")
+    with patch.object(
+        cron_check.subprocess, "run",
+        side_effect=subprocess.TimeoutExpired(cmd="launchctl", timeout=5),
+    ):
+        assert cron_check.is_cron_registered() is True
+
+
+def test_macos_returns_true_when_launchctl_not_found(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Darwin")
+    with patch.object(cron_check.subprocess, "run", side_effect=FileNotFoundError):
+        assert cron_check.is_cron_registered() is True
+
+
+# ---------------------------------------------------------------------------
+# Linux path (crontab)
+# ---------------------------------------------------------------------------
+
+
+def test_linux_returns_false_when_crontab_empty(monkeypatch):
+    """`crontab -l` returns nonzero when user has no crontab. That's
+    the strongest signal Coach is not scheduled."""
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Linux")
+    with patch.object(cron_check.subprocess, "run", return_value=_mock_run(1)):
+        assert cron_check.is_cron_registered() is False
+
+
+def test_linux_returns_true_when_coach_marker_in_crontab(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Linux")
+    fake_crontab = b"0 4 * * * /home/u/.claude/coach/bin/insights.sh 1d\n"
+    with patch.object(
+        cron_check.subprocess, "run",
+        return_value=_mock_run(0, stdout=fake_crontab),
+    ):
+        assert cron_check.is_cron_registered() is True
+
+
+def test_linux_returns_false_when_crontab_has_only_other_jobs(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Linux")
+    fake_crontab = b"0 5 * * * /usr/bin/something-else\n"
+    with patch.object(
+        cron_check.subprocess, "run",
+        return_value=_mock_run(0, stdout=fake_crontab),
+    ):
+        assert cron_check.is_cron_registered() is False
+
+
+def test_linux_recognizes_claude_coach_label(monkeypatch):
+    """Alternate marker in case a future helper uses the `claude-coach`
+    label instead of the script path."""
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Linux")
+    fake_crontab = b"0 4 * * * /opt/claude-coach/run.sh\n"
+    with patch.object(
+        cron_check.subprocess, "run",
+        return_value=_mock_run(0, stdout=fake_crontab),
+    ):
+        assert cron_check.is_cron_registered() is True
+
+
+def test_linux_returns_true_on_subprocess_error(monkeypatch):
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Linux")
+    with patch.object(
+        cron_check.subprocess, "run",
+        side_effect=subprocess.TimeoutExpired(cmd="crontab", timeout=5),
+    ):
+        assert cron_check.is_cron_registered() is True
+
+
+# ---------------------------------------------------------------------------
+# Other platforms
+# ---------------------------------------------------------------------------
+
+
+def test_other_platforms_return_true(monkeypatch):
+    """Windows / unknown systems don't use the cron path. Returning
+    True suppresses the nudge."""
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "Windows")
+    assert cron_check.is_cron_registered() is True
+    monkeypatch.setattr(cron_check.platform, "system", lambda: "FreeBSD")
+    assert cron_check.is_cron_registered() is True

package/coach/tests/test_cron_nudge_hook.py

@@ -0,0 +1,134 @@
+"""coach-user-prompt.py: cron-nudge banner gating.
+
+The plugin distribution emits a one-time `<coach-cron-nudge>` block
+when (a) we're running under the plugin (CLAUDE_PLUGIN_ROOT set), and
+(b) no Coach cron/launchd plist is registered. Guarded by the
+`.cron-nudged` marker so it fires exactly once.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture(scope="module")
+def cup():
+    """Load coach-user-prompt.py as a module via importlib."""
+    repo_path = Path(__file__).resolve().parents[2] / "hooks" / "coach-user-prompt.py"
+    path = repo_path if repo_path.exists() else Path.home() / ".claude" / "hooks" / "coach-user-prompt.py"
+    if not path.exists():
+        pytest.skip(f"hook not installed at {path}")
+    spec = importlib.util.spec_from_file_location("cup_cron_under_test", str(path))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+@pytest.fixture
+def coach_dir(tmp_path, monkeypatch):
+    """Redirect COACH_DIR so the test doesn't touch the real
+    `~/.claude/coach/.cron-nudged` marker."""
+    d = tmp_path / "coach"
+    d.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(d))
+    return d
+
+
+def test_no_nudge_when_not_in_plugin_context(cup, coach_dir, monkeypatch):
+    """CLI distribution: CLAUDE_PLUGIN_ROOT unset → no nudge ever."""
+    monkeypatch.delenv("CLAUDE_PLUGIN_ROOT", raising=False)
+    # Even with cron absent (mocked False), we still skip — gate is
+    # CLAUDE_PLUGIN_ROOT, not cron presence.
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    block = cup._maybe_cron_nudge_block(env="terminal")
+    assert block is None
+    assert not (coach_dir / ".cron-nudged").exists()
+
+
+def test_no_nudge_when_marker_present(cup, coach_dir, monkeypatch):
+    """Marker present → already nudged → no re-nudge."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    (coach_dir / ".cron-nudged").write_text(json.dumps({"nudged_at": "2026-05-08T00:00:00Z"}))
+
+    # Even if cron is absent we should NOT re-nudge.
+    import cron_check
+    monkeypatch.setattr(cron_check, "is_cron_registered", lambda: False)
+
+    block = cup._maybe_cron_nudge_block(env="terminal")
+    assert block is None
+
+
+def test_no_nudge_when_cron_already_registered(cup, coach_dir, monkeypatch):
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    import cron_check
+    monkeypatch.setattr(cron_check, "is_cron_registered", lambda: True)
+
+    block = cup._maybe_cron_nudge_block(env="terminal")
+    assert block is None
+    # Marker NOT written (we didn't nudge, nothing to remember).
+    assert not (coach_dir / ".cron-nudged").exists()
+
+
+def test_nudge_fires_and_writes_marker(cup, coach_dir, monkeypatch):
+    """Plugin context + cron absent + no prior marker → emit + write."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    import cron_check
+    monkeypatch.setattr(cron_check, "is_cron_registered", lambda: False)
+
+    block = cup._maybe_cron_nudge_block(env="terminal")
+    assert block is not None
+    # Banner mentions the recommended remediation
+    assert "npx @rm0nroe/coach-claw launchd" in block
+    assert "crontab" in block
+    # Fires once: marker written
+    marker = coach_dir / ".cron-nudged"
+    assert marker.exists()
+    payload = json.loads(marker.read_text())
+    assert "nudged_at" in payload
+
+
+def test_nudge_is_idempotent_after_first_emit(cup, coach_dir, monkeypatch):
+    """First call emits + writes marker; second call sees marker and
+    returns None."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    import cron_check
+    monkeypatch.setattr(cron_check, "is_cron_registered", lambda: False)
+
+    first = cup._maybe_cron_nudge_block(env="terminal")
+    second = cup._maybe_cron_nudge_block(env="terminal")
+    assert first is not None
+    assert second is None
+
+
+def test_nudge_renders_ide_shape(cup, coach_dir, monkeypatch):
+    """IDE entrypoint gets the HR-framed shape (consistent with other
+    Coach blocks); terminal gets blockquote shape."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+    import cron_check
+    monkeypatch.setattr(cron_check, "is_cron_registered", lambda: False)
+
+    block_ide = cup._cron_nudge_block(env="ide")
+    block_term = cup._cron_nudge_block(env="terminal")
+    assert block_ide.startswith("---")
+    assert block_term.startswith(">")
+
+
+def test_failsafe_swallows_module_import_error(cup, coach_dir, monkeypatch):
+    """If cron_check is somehow unavailable, return None — never raise
+    out of a hook."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", "/some/plugin/root")
+    monkeypatch.setattr(cup, "COACH_DIR", coach_dir)
+
+    import sys
+    monkeypatch.setitem(sys.modules, "cron_check", None)
+
+    block = cup._maybe_cron_nudge_block(env="terminal")
+    assert block is None

package/coach/tests/test_detection_parity.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import analyze
+import scoring
+import stats
+
+
+def _load_hook_module():
+    repo_path = Path(__file__).resolve().parents[2] / "hooks" / "coach-user-prompt.py"
+    path = repo_path if repo_path.exists() else Path.home() / ".claude" / "hooks" / "coach-user-prompt.py"
+    spec = importlib.util.spec_from_file_location("coach_user_prompt_parity", str(path))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _tool_use(name: str, input_: dict) -> dict:
+    return {"type": "tool_use", "name": name, "input": input_}
+
+
+def _write_transcript(path: Path, tool_uses: list[dict]) -> None:
+    lines = []
+    for idx, tu in enumerate(tool_uses):
+        lines.append(json.dumps({
+            "type": "assistant",
+            "timestamp": f"2026-01-01T00:00:{idx:02d}+00:00",
+            "message": {
+                "role": "assistant",
+                "content": [tu],
+            },
+        }))
+    path.write_text("\n".join(lines) + "\n")
+
+
+def test_hook_completion_matcher_tracks_shared_scoring_actions(tmp_path: Path) -> None:
+    hook = _load_hook_module()
+    cases = [
+        (_tool_use("Bash", {"command": "pytest --collect-only tests/"}), "test_run", None, False),
+        (_tool_use("Bash", {"command": "mocha"}), "test_run", None, True),
+        (_tool_use("Bash", {"command": "yarn test"}), "test_run", None, True),
+        (_tool_use("Bash", {"command": "printf 'pytest in text only'"}), "test_run", None, False),
+        (_tool_use("Bash", {"command": "printf 'git commit in text only'"}), "commit", None, False),
+        (_tool_use("Skill", {"skill": "/update-docs"}), "skill_invoke", "update-docs", True),
+        (_tool_use("Edit", {"file_path": "README.md"}), "doc_write", None, True),
+    ]
+
+    for tool_use, action, skill_id, expected in cases:
+        assert scoring.matches_action(tool_use, action, skill_id=skill_id) is expected
+        assert hook._tool_use_matches_action(tool_use, action, skill_id=skill_id) is expected
+
+
+def test_stats_session_xp_delegates_to_shared_scoring(tmp_path: Path) -> None:
+    transcript = tmp_path / "session.jsonl"
+    _write_transcript(transcript, [
+        _tool_use("Bash", {"command": "pytest --collect-only tests/"}),
+        _tool_use("Bash", {"command": "mocha"}),
+        _tool_use("Bash", {"command": "yarn test"}),
+        _tool_use("Bash", {"command": "printf 'pytest and git commit are text'"}),
+        _tool_use("Bash", {"command": "git commit -m ok"}),
+        _tool_use("Skill", {"skill": "/update-docs"}),
+        _tool_use("Edit", {"file_path": "README.md"}),
+    ])
+    profile = {
+        "entries": [{
+            "id": "docs-drift",
+            "reward_hint": {"action": "doc_write", "xp": 1, "description": "doc update"},
+        }]
+    }
+
+    assert stats._session_xp_from_transcript(transcript, profile) == scoring.score_transcript(
+        transcript, profile
+    )
+    breakdown = scoring.score_transcript_with_breakdown(transcript, profile)
+    assert breakdown["tests"] == 2
+    assert breakdown["commits"] == 1
+    assert breakdown["skills_list"] == ["update-docs"]
+    assert breakdown["dynamic_actions"]["doc_write"]["count"] == 1
+
+
+def test_analyze_test_run_detection_tracks_shared_scoring(tmp_path: Path) -> None:
+    commands = [
+        "pytest --collect-only tests/",
+        "mocha",
+        "pnpm test",
+        "yarn test",
+        "printf 'pytest and git commit are just words'",
+    ]
+    transcript = tmp_path / "session.jsonl"
+    _write_transcript(
+        transcript,
+        [_tool_use("Bash", {"command": cmd}) for cmd in commands],
+    )
+
+    sig = analyze.analyze_session(transcript)
+    expected = sum(
+        1
+        for cmd in commands
+        if scoring.matches_action(_tool_use("Bash", {"command": cmd}), "test_run")
+    )
+    assert sig["test_run_count"] == expected
+    assert sig["has_any_test_run"] is True