@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_switch_to_plugin.py

@@ -0,0 +1,360 @@
+"""switch_to_plugin.py — flip Coach control from npm CLI to plugin.
+
+Pairs with /coach-claw:switch skill. Removes CLI-installed hook entries
+from settings.json, optionally clears the CLI's statusLine, writes a
+marker so /coach-claw:doctor knows the user explicitly switched.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+import switch_to_plugin as sp
+
+
+def _settings_with_cli_hooks_and_statusline() -> dict:
+    return {
+        "permissions": {"allow": ["read"]},
+        "hooks": {
+            "SessionStart": [{"hooks": [{
+                "type": "command",
+                "command": "/usr/bin/python3 /Users/foo/.claude/hooks/coach-session-start.py",
+                "timeout": 3,
+            }]}],
+            "UserPromptSubmit": [{"hooks": [{
+                "type": "command",
+                "command": "/usr/bin/python3 /Users/foo/.claude/hooks/coach-user-prompt.py",
+                "timeout": 2,
+            }]}],
+        },
+        "statusLine": {
+            "type": "command",
+            "command": "bash /Users/foo/.claude/coach/default-statusline-command.sh",
+        },
+    }
+
+
+def _settings_with_plugin_hooks(plugin_root: str) -> dict:
+    cmd = f"{plugin_root}/bin/bootstrap.sh {plugin_root}/hooks/coach-session-start.py"
+    return {
+        "hooks": {
+            "SessionStart": [{"hooks": [{"type": "command", "command": cmd}]}],
+        }
+    }
+
+
+@pytest.fixture
+def env_under_plugin(tmp_path, monkeypatch):
+    """Set up CLAUDE_PLUGIN_ROOT and a coach state dir."""
+    plugin_root = tmp_path / "plugin"
+    plugin_root.mkdir()
+    coach_dir = tmp_path / "coach"
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+    return plugin_root, coach_dir
+
+
+def test_strips_cli_hooks_and_statusline(tmp_path, env_under_plugin, capsys):
+    plugin_root, coach_dir = env_under_plugin
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps(_settings_with_cli_hooks_and_statusline()))
+
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+
+    after = json.loads(settings.read_text())
+    # Hook entries gone
+    assert "SessionStart" not in after.get("hooks", {})
+    assert "UserPromptSubmit" not in after.get("hooks", {})
+    # statusLine removed
+    assert "statusLine" not in after
+    # Unrelated keys preserved
+    assert after["permissions"] == {"allow": ["read"]}
+    # Marker written
+    assert (coach_dir / ".cli-uninstalled-by-plugin").exists()
+
+    out = capsys.readouterr().out
+    assert "Removed 2 CLI hook entries" in out
+    assert "Removed CLI statusLine" in out
+
+
+def test_preserves_plugin_hooks(tmp_path, env_under_plugin):
+    """Plugin's own hook entries (which include plugin_root in command)
+    must survive the strip."""
+    plugin_root, coach_dir = env_under_plugin
+    base = _settings_with_cli_hooks_and_statusline()
+    plugin_cmd = f"{plugin_root}/bin/bootstrap.sh {plugin_root}/hooks/coach-session-start.py"
+    base["hooks"]["SessionStart"][0]["hooks"].append({
+        "type": "command",
+        "command": plugin_cmd,
+    })
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps(base))
+
+    sp.main(["--settings", str(settings)])
+    after = json.loads(settings.read_text())
+    sessions = after["hooks"]["SessionStart"][0]["hooks"]
+    # Only plugin command remains
+    assert len(sessions) == 1
+    assert plugin_cmd in sessions[0]["command"]
+
+
+def test_preserves_user_custom_statusline(tmp_path, env_under_plugin):
+    """If the user has a non-Coach statusLine, leave it alone."""
+    plugin_root, _ = env_under_plugin
+    settings_data = _settings_with_cli_hooks_and_statusline()
+    settings_data["statusLine"] = {
+        "type": "command",
+        "command": "bash /opt/my-custom-statusline.sh",
+    }
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps(settings_data))
+
+    sp.main(["--settings", str(settings)])
+    after = json.loads(settings.read_text())
+    assert after["statusLine"]["command"] == "bash /opt/my-custom-statusline.sh"
+
+
+def test_noop_when_nothing_to_remove(tmp_path, env_under_plugin, capsys):
+    plugin_root, coach_dir = env_under_plugin
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps(_settings_with_plugin_hooks(str(plugin_root))))
+
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "nothing to do" in out.lower()
+    # No marker written when nothing changed
+    assert not (coach_dir / ".cli-uninstalled-by-plugin").exists()
+
+
+def test_dry_run_does_not_write(tmp_path, env_under_plugin, capsys):
+    plugin_root, coach_dir = env_under_plugin
+    settings = tmp_path / "settings.json"
+    raw = json.dumps(_settings_with_cli_hooks_and_statusline())
+    settings.write_text(raw)
+    mtime_before = settings.stat().st_mtime_ns
+
+    rc = sp.main(["--settings", str(settings), "--dry-run"])
+    assert rc == 0
+    assert settings.stat().st_mtime_ns == mtime_before
+    assert settings.read_text() == raw
+    out = capsys.readouterr().out
+    assert "Would remove" in out
+    # Marker NOT written on dry-run
+    assert not (coach_dir / ".cli-uninstalled-by-plugin").exists()
+
+
+def test_clears_stale_defer_marker(tmp_path, env_under_plugin):
+    """When the user explicitly switches, any prior .plugin-deferred
+    marker should be cleared (CLI hooks are gone, plugin is now in
+    charge — no reason for the deferred state to linger)."""
+    plugin_root, coach_dir = env_under_plugin
+    coach_dir.mkdir()
+    (coach_dir / ".plugin-deferred").write_text(json.dumps({"reason": "stale"}))
+
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps(_settings_with_cli_hooks_and_statusline()))
+
+    sp.main(["--settings", str(settings)])
+    assert not (coach_dir / ".plugin-deferred").exists()
+    assert (coach_dir / ".cli-uninstalled-by-plugin").exists()
+
+
+def test_settings_missing_returns_1(tmp_path, env_under_plugin, capsys):
+    """No settings.json → exit 1 + clear error. Don't create one."""
+    rc = sp.main(["--settings", str(tmp_path / "no-such.json")])
+    assert rc == 1
+    err = capsys.readouterr().err
+    assert "not found" in err.lower()
+
+
+def test_malformed_settings_returns_2(tmp_path, env_under_plugin, capsys):
+    settings = tmp_path / "settings.json"
+    settings.write_text("{ not valid json")
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 2
+    err = capsys.readouterr().err
+    assert "not valid json" in err.lower() or "json" in err.lower()
+
+
+def test_atomic_no_partial_write_on_failure(tmp_path, env_under_plugin, monkeypatch):
+    """If os.replace raises mid-write, settings.json must not be
+    truncated."""
+    settings = tmp_path / "settings.json"
+    raw = json.dumps(_settings_with_cli_hooks_and_statusline())
+    settings.write_text(raw)
+    original = json.loads(raw)
+
+    def boom(*args, **kwargs):
+        raise OSError("simulated disk failure")
+
+    monkeypatch.setattr(sp.os, "replace", boom)
+
+    with pytest.raises(OSError):
+        sp.main(["--settings", str(settings)])
+
+    # Original file content preserved (atomic semantics).
+    after = json.loads(settings.read_text())
+    assert after == original
+
+
+# ---------------------------------------------------------------------------
+# Wrap-shape policy (v0.1.4)
+# ---------------------------------------------------------------------------
+
+
+def test_rewrites_cli_wrap_to_plugin_shape(tmp_path, env_under_plugin):
+    """ours-wrapped pointing at the CLI trampoline → switch rewrites it
+    to point at the plugin's bootstrap.sh + statusline_wrap.py. Saved
+    original (`.statusline-wrap.json`) is untouched — coach state is
+    shared between distributions."""
+    plugin_root, _ = env_under_plugin
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /Users/foo/.claude/coach/default-statusline-wrap-command.sh",
+        },
+    }))
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+
+    new_cmd = json.loads(settings.read_text())["statusLine"]["command"]
+    assert str(plugin_root) in new_cmd
+    assert "bootstrap.sh" in new_cmd
+    assert "statusline_wrap.py" in new_cmd
+    assert "default-statusline-wrap-command.sh" not in new_cmd
+
+
+def test_noop_when_already_plugin_wrap_shape(tmp_path, env_under_plugin):
+    """If the wrap shape already points at the plugin, switch is a no-op
+    (no double-rewrite, no churn)."""
+    plugin_root, _ = env_under_plugin
+    plugin_cmd = (
+        f"{plugin_root}/bin/bootstrap.sh {plugin_root}/bin/statusline_wrap.py"
+    )
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": plugin_cmd},
+    }))
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+
+    after = json.loads(settings.read_text())["statusLine"]["command"]
+    assert after == plugin_cmd  # exact byte match — no rewrite
+
+
+def test_leaves_integrated_externally_alone(tmp_path, env_under_plugin):
+    """When statusLine is a custom user command and the opt-out marker
+    says `already-integrated`, switch must NOT install a default plugin
+    statusline — the user already integrates Coach themselves."""
+    _, coach_dir = env_under_plugin
+    coach_dir.mkdir(parents=True, exist_ok=True)
+    (coach_dir / ".statusline-wrap-disabled").write_text(json.dumps({
+        "reason": "already-integrated",
+        "detected_in": "/Users/foo/.claude/statusline-command.sh",
+    }))
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /Users/foo/.claude/statusline-command.sh",
+        },
+    }))
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+
+    after = json.loads(settings.read_text())
+    # statusLine preserved exactly
+    assert after["statusLine"]["command"] == "bash /Users/foo/.claude/statusline-command.sh"
+
+
+# ---------------------------------------------------------------------------
+# Shell-safety of the plugin-shape rewrite (v0.1.6 fix)
+# ---------------------------------------------------------------------------
+
+
+def test_rewrite_quotes_plugin_paths_with_spaces(tmp_path, monkeypatch):
+    """Same defect class as v0.1.5's _build_wrapper_command +
+    _desired_entry: a CLAUDE_PLUGIN_ROOT containing spaces must produce
+    a settings.json command string that bash parses as exactly two
+    tokens. Pre-v0.1.6 the unquoted f-string interpolation generated
+    `/tmp/.../Plugin Dir/bin/bootstrap.sh /tmp/.../Plugin Dir/bin/...`
+    which shlex.split breaks into 4+ tokens, ENOENT'ing under bash."""
+    plugin_root = tmp_path / "Plugin Dir With Spaces"
+    (plugin_root / "bin").mkdir(parents=True)
+    coach_dir = tmp_path / "coach"
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /Users/foo/.claude/coach/default-statusline-wrap-command.sh",
+        },
+    }))
+    rc = sp.main(["--settings", str(settings)])
+    assert rc == 0
+
+    new_cmd = json.loads(settings.read_text())["statusLine"]["command"]
+    tokens = shlex.split(new_cmd)
+    assert len(tokens) == 2, (
+        f"plugin_root paths split by bash; tokens={tokens!r} cmd={new_cmd!r}"
+    )
+    assert tokens[0] == str(plugin_root / "bin" / "bootstrap.sh")
+    assert tokens[1] == str(plugin_root / "bin" / "statusline_wrap.py")
+
+
+def test_rewrite_command_executes_under_bash_with_spaces(tmp_path, monkeypatch):
+    """End-to-end: the rewritten command must actually run under
+    `bash -c` without ENOENT when CLAUDE_PLUGIN_ROOT has a space.
+    Mirrors test_install_auto_wraps_claimed_statusline's exec guard
+    from v0.1.5."""
+    plugin_root = tmp_path / "Plugin Dir With Spaces"
+    plugin_bin = plugin_root / "bin"
+    plugin_bin.mkdir(parents=True)
+    # Stand-in scripts so bash actually has something to exec on the
+    # generated command path. Doesn't matter what they print — just
+    # has to be findable + executable.
+    (plugin_bin / "bootstrap.sh").write_text("#!/bin/bash\nexec \"$@\"\n")
+    (plugin_bin / "statusline_wrap.py").write_text(
+        "#!/usr/bin/env python3\nprint('ok')\n"
+    )
+    (plugin_bin / "bootstrap.sh").chmod(0o755)
+    (plugin_bin / "statusline_wrap.py").chmod(0o755)
+
+    coach_dir = tmp_path / "coach"
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /tmp/cli/coach/default-statusline-wrap-command.sh",
+        },
+    }))
+    sp.main(["--settings", str(settings)])
+
+    new_cmd = json.loads(settings.read_text())["statusLine"]["command"]
+    bash_path = shutil.which("bash")
+    assert bash_path
+    proc = subprocess.run(
+        [bash_path, "-c", new_cmd],
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+    assert proc.returncode == 0, (
+        f"rewritten command failed under bash -c — likely unquoted "
+        f"path with spaces.\ncommand={new_cmd!r}\nstderr={proc.stderr!r}"
+    )
+    assert "No such file or directory" not in proc.stderr, proc.stderr

package/coach/tests/test_themes.py

@@ -0,0 +1,104 @@
+"""themes.py — every theme is exactly 50 unique single-word entries."""
+from __future__ import annotations
+
+import re
+
+import themes
+
+
+def test_all_themes_have_exactly_50_entries():
+    for name, ladder in themes.THEMES.items():
+        assert len(ladder) == 50, f"{name} has {len(ladder)} entries, expected 50"
+
+
+def test_no_duplicate_names_within_a_theme():
+    for name, ladder in themes.THEMES.items():
+        assert len(set(ladder)) == 50, f"{name} has duplicate level names"
+
+
+def test_default_theme_preserves_v0_2_0_lader():
+    """Backwards-compat: existing installs without .user_config.json read
+    the default theme (`craft`), which must match the v0.2.0 ladder so
+    no level-name drift on upgrade."""
+    expected_first_eight = [
+        "Drafter", "Iterator", "Builder", "Shipper",
+        "Craftsman", "Architect", "Virtuoso", "Sensei",
+    ]
+    assert themes.THEME_CRAFT[:8] == expected_first_eight
+    assert themes.THEME_CRAFT[-1] == "Origin"
+
+
+def test_get_ladder_falls_back_to_default_on_unknown():
+    assert themes.get_ladder("does-not-exist") == themes.THEMES[themes.DEFAULT_THEME]
+
+
+def test_list_themes_puts_default_first():
+    keys = themes.list_themes()
+    assert keys[0] == themes.DEFAULT_THEME
+    assert sorted(keys) == sorted(themes.THEMES.keys())
+
+
+def test_theme_names_are_valid_identifiers():
+    """Each level name should be a single word (no spaces, no leading
+    digits) so it composes cleanly inside the statusline variants."""
+    pattern = re.compile(r"^[A-Za-z][A-Za-z\-]*$")
+    for name, ladder in themes.THEMES.items():
+        for entry in ladder:
+            assert pattern.match(entry), (
+                f"{name} contains invalid name {entry!r}"
+            )
+
+
+def test_full_theme_lineup_is_present():
+    """Pin the v0.3.0 expanded theme set: 4 abstract + 8 pop-culture = 12.
+    Drop / rename / add to this assertion when the set genuinely changes."""
+    expected = {
+        # abstract (mythic intentionally dropped vs early v0.3.0 draft)
+        "craft", "forge", "cosmic", "ocean",
+        # pop-culture
+        "skyrim", "marvel", "dc", "finalfantasy",
+        "military", "lotr", "starwars", "hacker",
+    }
+    assert set(themes.THEMES.keys()) == expected, (
+        f"theme set drifted from expected: "
+        f"missing={expected - themes.THEMES.keys()}, "
+        f"extra={themes.THEMES.keys() - expected}"
+    )
+
+
+def test_pop_culture_themes_exclude_franchise_coined_words():
+    """Brand-safety pin. None of the franchise-coined neologisms or named
+    characters listed below should appear in any pop-culture ladder. This
+    is a regression guard, not exhaustive — see themes.py docstring for
+    the full policy."""
+    forbidden = {
+        # Bethesda / Skyrim coinages
+        "Dovahkiin", "Daedra", "Aedra", "Daedric", "Aedric", "Talos",
+        "Alduin", "Paarthurnax", "Akatosh", "Tamriel",
+        # Marvel character / trademarked group names
+        "SpiderMan", "IronMan", "Wolverine", "Avengers", "Vibranium",
+        "Adamantium", "OneAboveAll",
+        # DC character / trademarked group names
+        "Batman", "Superman", "GreenLantern", "JusticeLeague",
+        "Krypton", "Kryptonian",
+        # Final Fantasy specific (broader summons left in — public-domain
+        # mythology — but franchise-coined character/job terms excluded)
+        "OnionKnight", "Cetra", "Sephiroth", "Cloud", "Tidus",
+        "Cidolfus", "BlackMage", "WhiteMage", "RedMage",
+        # Tolkien coinages
+        "Hobbit", "Maiar", "Valar", "Eru", "Numenor", "Mordor",
+        "Shire", "Gondor", "Rohan", "Frodo", "Aragorn", "Gandalf",
+        "Istari",
+        # Star Wars coinages
+        "Jedi", "Sith", "Padawan", "Mandalorian", "Yoda", "Vader",
+        "Skywalker",  # Skywalker is a SW character; "Skywarden" is fine
+        # Trademarked product names in the dev-culture theme
+        "Linux", "Unix", "Microsoft", "Google", "Apple",
+        "BellLabs", "Knuth", "Torvalds", "Stallman",
+    }
+    for theme_name, ladder in themes.THEMES.items():
+        for entry in ladder:
+            assert entry not in forbidden, (
+                f"theme {theme_name!r} contains forbidden franchise-coined "
+                f"name {entry!r} — see themes.py docstring 'Brand safety'"
+            )

package/coach/tests/test_user_config.py

@@ -0,0 +1,160 @@
+"""user_config.py — defaults, validation, atomic writes."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+import user_config
+
+
+@pytest.fixture
+def isolated_config(tmp_path, monkeypatch):
+    """Redirect config to a tmp dir via COACH_CONFIG_DIR so tests don't
+    touch the real user config. Uses the public env-var contract that
+    the npm wrapper / configure.py also rely on."""
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(tmp_path))
+    return tmp_path / ".user_config.json"
+
+
+def test_load_returns_defaults_when_file_missing(isolated_config):
+    cfg = user_config.load()
+    assert cfg["statusline_variant"] == "crystal"
+    assert cfg["theme"] == "craft"
+    assert cfg["elo_min"] == 1000
+    assert cfg["elo_max"] == 2800
+
+
+def test_load_corrupt_file_falls_back_to_defaults(isolated_config):
+    isolated_config.write_text("{not valid json")
+    cfg = user_config.load()
+    assert cfg["statusline_variant"] == "crystal"
+
+
+def test_load_partial_file_fills_in_defaults(isolated_config):
+    isolated_config.write_text(json.dumps({"theme": "ocean"}))
+    cfg = user_config.load()
+    assert cfg["theme"] == "ocean"
+    assert cfg["statusline_variant"] == "crystal"  # default
+    assert cfg["elo_min"] == 1000
+
+
+def test_save_writes_atomically(isolated_config):
+    user_config.save({"statusline_variant": "pips", "theme": "ocean"})
+    raw = json.loads(isolated_config.read_text())
+    assert raw["statusline_variant"] == "pips"
+    assert raw["theme"] == "ocean"
+    # atomic — no leftover .tmp files
+    leftovers = list(isolated_config.parent.glob(".user_config.json.*.tmp"))
+    assert leftovers == [], leftovers
+
+
+def test_save_rejects_unknown_variant(isolated_config):
+    with pytest.raises(ValueError, match="statusline_variant"):
+        user_config.save({"statusline_variant": "rainbow"})
+
+
+def test_save_rejects_unknown_theme(isolated_config):
+    with pytest.raises(ValueError, match="theme"):
+        user_config.save({"theme": "scifi"})
+
+
+def test_save_rejects_invalid_elo_range(isolated_config):
+    with pytest.raises(ValueError, match="elo"):
+        user_config.save({"elo_min": 2000, "elo_max": 1000})
+
+
+def test_update_persists_and_returns_full_config(isolated_config):
+    cfg = user_config.update(theme="forge")
+    assert cfg["theme"] == "forge"
+    assert cfg["statusline_variant"] == "crystal"
+    # round-trip
+    again = user_config.load()
+    assert again["theme"] == "forge"
+
+
+def test_load_ignores_invalid_field_values(isolated_config):
+    """File on disk contains a typo'd theme — load should silently fall
+    back to the default for that field rather than crash."""
+    isolated_config.write_text(json.dumps({
+        "schema_version": 1,
+        "statusline_variant": "crystal",
+        "theme": "rainbow",  # invalid
+        "elo_min": 1000,
+        "elo_max": 2800,
+    }))
+    cfg = user_config.load()
+    assert cfg["theme"] == "craft"  # default applied silently
+
+
+def test_get_variant_get_theme_get_elo_range_helpers(isolated_config):
+    user_config.save({
+        "statusline_variant": "pips",
+        "theme": "skyrim",
+        "elo_min": 800,
+        "elo_max": 3000,
+    })
+    assert user_config.get_variant() == "pips"
+    assert user_config.get_theme() == "skyrim"
+    assert user_config.get_elo_range() == (800, 3000)
+
+
+def test_config_path_respects_coach_config_dir_env(tmp_path, monkeypatch):
+    """COACH_CONFIG_DIR env var redirects writes to a custom directory.
+
+    This is the contract that lets `npx coach-claw config` work against a
+    custom CLAUDE_DIR install — the npm wrapper exports COACH_CONFIG_DIR
+    so the Python entrypoint resolves the right path. Without this, a
+    user with `CLAUDE_DIR=/srv/foo ./install.sh` then `coach-claw config
+    set --theme ocean` would write to ~/.claude/coach/.user_config.json
+    instead of /srv/foo/coach/.user_config.json.
+    """
+    custom_dir = tmp_path / "custom-coach-dir"
+    custom_dir.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(custom_dir))
+
+    user_config.save({"theme": "ocean", "statusline_variant": "pips"})
+
+    expected = custom_dir / ".user_config.json"
+    assert expected.exists(), (
+        f"save() should have written to {expected} when COACH_CONFIG_DIR "
+        f"is set, but the file is missing. Files in dir: "
+        f"{list(custom_dir.iterdir())}"
+    )
+    payload = json.loads(expected.read_text())
+    assert payload["theme"] == "ocean"
+    assert payload["statusline_variant"] == "pips"
+
+    # And the default path must NOT have been written.
+    default_path = Path.home() / ".claude" / "coach" / ".user_config.json"
+    if default_path.exists():
+        # If the user actually has a config file in their real home, this
+        # check is moot — but we can at least verify the default path
+        # wasn't *just* written by this test (mtime comparison).
+        # Skip the negative assertion in that case.
+        pass
+
+
+def test_config_path_resolves_per_call(tmp_path, monkeypatch):
+    """Path resolution happens at every read/write, not at import time —
+    so tests / wrappers can change COACH_CONFIG_DIR mid-process and
+    subsequent calls honor the new path."""
+    dir_a = tmp_path / "a"
+    dir_a.mkdir()
+    dir_b = tmp_path / "b"
+    dir_b.mkdir()
+
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(dir_a))
+    user_config.save({"theme": "ocean"})
+    assert (dir_a / ".user_config.json").exists()
+
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(dir_b))
+    user_config.save({"theme": "skyrim"})
+    assert (dir_b / ".user_config.json").exists()
+    payload = json.loads((dir_b / ".user_config.json").read_text())
+    assert payload["theme"] == "skyrim"
+
+    # The first dir's file is untouched
+    payload_a = json.loads((dir_a / ".user_config.json").read_text())
+    assert payload_a["theme"] == "ocean"