@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_analyze_strengths.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import json
+
+import analyze
+
+
+def _session(
+    *,
+    session_hash: str = "abcd1234",
+    edits: int = 0,
+    writes: int = 0,
+    tests: int = 0,
+    commits: int = 0,
+    reads: int = 0,
+    grep: int = 0,
+    glob: int = 0,
+    skills: int = 0,
+    rm_rf: int = 0,
+    plan_before_edit: bool = False,
+    first_plan_idx=None,
+    first_edit_idx=None,
+    last_edit_idx=None,
+    first_test_idx=None,
+    last_test_idx=None,
+    first_commit_idx=None,
+    last_commit_idx=None,
+    first_read_idx=None,
+    first_search_idx=None,
+) -> dict:
+    return {
+        "project": "-Users-r-Desktop-dev-coach",
+        "session_hash": session_hash,
+        "tool_counts": {},
+        "user_turns": 1,
+        "assistant_turns": 5,
+        "first_ts": None,
+        "last_ts": None,
+        "first_user_ts": None,
+        "first_edit_ts": None,
+        "first_plan_ts": None,
+        "task_create_count": 0,
+        "exit_plan_count": 0,
+        "edit_count": edits,
+        "write_count": writes,
+        "bash_count": tests + commits,
+        "commit_count": commits,
+        "test_run_count": tests,
+        "has_any_commit": commits > 0,
+        "has_any_test_run": tests > 0,
+        "bash_rm_rf_count": rm_rf,
+        "read_count": reads,
+        "grep_count": grep,
+        "glob_count": glob,
+        "agent_count": 0,
+        "skill_count": skills,
+        "skills_invoked": {},
+        "sec_first_user_to_first_edit": None,
+        "plan_before_edit": plan_before_edit,
+        "first_plan_idx": first_plan_idx,
+        "first_edit_idx": first_edit_idx,
+        "last_edit_idx": last_edit_idx,
+        "first_test_idx": first_test_idx,
+        "last_test_idx": last_test_idx,
+        "first_commit_idx": first_commit_idx,
+        "last_commit_idx": last_commit_idx,
+        "first_read_idx": first_read_idx,
+        "first_search_idx": first_search_idx,
+    }
+
+
+def _strong_session(i: int) -> dict:
+    return _session(
+        session_hash=f"good{i}",
+        edits=3,
+        tests=1,
+        commits=1,
+        reads=2,
+        grep=1,
+        skills=1,
+        plan_before_edit=True,
+        first_plan_idx=0,
+        first_search_idx=1,
+        first_read_idx=2,
+        first_edit_idx=3,
+        last_edit_idx=3,
+        first_test_idx=4,
+        last_test_idx=4,
+        first_commit_idx=5,
+        last_commit_idx=5,
+    )
+
+
+def test_aggregate_emits_positive_strength_detections():
+    detections, _summary = analyze.aggregate([_strong_session(i) for i in range(3)])
+
+    by_id = {d["id"]: d for d in detections}
+    expected = {
+        "tests-after-edits",
+        "plans-before-edits",
+        "commits-gated-by-tests",
+        "search-before-reading",
+        "small-batch-verify",
+        "safe-git-hygiene",
+        "effective-skill-use",
+    }
+
+    assert expected <= set(by_id)
+    assert all(by_id[eid]["direction"] == "positive" for eid in expected)
+    assert by_id["tests-after-edits"]["reward_hint"]["action"] == "test_run"
+    assert by_id["effective-skill-use"]["reward_hint"]["action"] == "skill_invoke"
+
+
+def test_positive_strengths_require_repeated_majority_evidence():
+    sessions = [
+        _session(
+            session_hash=f"good{i}",
+            edits=2,
+            tests=1,
+            first_edit_idx=1,
+            last_edit_idx=1,
+            first_test_idx=2,
+            last_test_idx=2,
+        )
+        for i in range(2)
+    ]
+    sessions += [
+        _session(session_hash=f"bad{i}", edits=2, first_edit_idx=1, last_edit_idx=1)
+        for i in range(3)
+    ]
+
+    detections, _summary = analyze.aggregate(sessions)
+
+    assert "tests-after-edits" not in {d["id"] for d in detections}
+
+
+def test_analyze_session_records_tool_order_for_strength_detectors(tmp_path):
+    transcript = tmp_path / "session.jsonl"
+    record = {
+        "type": "assistant",
+        "message": {
+            "role": "assistant",
+            "content": [
+                {"type": "tool_use", "name": "Plan", "input": {}},
+                {"type": "tool_use", "name": "Grep", "input": {"pattern": "x"}},
+                {"type": "tool_use", "name": "Read", "input": {"file_path": "a.py"}},
+                {"type": "tool_use", "name": "Edit", "input": {"file_path": "a.py"}},
+                {"type": "tool_use", "name": "Bash", "input": {"command": "pytest"}},
+                {"type": "tool_use", "name": "Bash", "input": {"command": "git commit -m ok"}},
+                {"type": "tool_use", "name": "Skill", "input": {"skill": "design"}},
+            ],
+        },
+    }
+    transcript.write_text(json.dumps(record) + "\n")
+
+    sig = analyze.analyze_session(transcript)
+
+    assert sig is not None
+    assert sig["first_plan_idx"] == 0
+    assert sig["first_search_idx"] == 1
+    assert sig["first_read_idx"] == 2
+    assert sig["first_edit_idx"] == 3
+    assert sig["last_test_idx"] == 4
+    assert sig["last_commit_idx"] == 5
+    assert sig["plan_before_edit"] is True

package/coach/tests/test_bank_atomic_write.py

@@ -0,0 +1,61 @@
+"""bank.py — atomic write unlinks tmp on os.replace failure.
+
+Pinned regression for the unlink-on-failure path in
+`bank._atomic_write_yaml`. Before the fix, a rare cross-device or
+filesystem-quirk failure of `os.replace` would leak a stale
+`.profile.<rand>.tmp` into `~/.claude/coach/`, eventually accumulating
+visible junk. This test forces the failure path and asserts the temp
+is cleaned up. Mirrors the cleanup pattern in
+`merge.atomic_write_yaml` and `marker_io._atomic_write_under_lock`.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+import bank
+
+
+def test_atomic_write_unlinks_temp_on_replace_failure(tmp_path, monkeypatch):
+    """If os.replace raises, _atomic_write_yaml must unlink the .tmp and re-raise."""
+    target = tmp_path / "profile.yaml"
+    target.write_text("schema_version: 1\nentries: []\n")
+
+    captured: list[str] = []
+
+    def failing_replace(src, _dst):
+        captured.append(src)
+        raise OSError("simulated cross-device rename failure")
+
+    monkeypatch.setattr(bank.os, "replace", failing_replace)
+
+    with pytest.raises(OSError, match="simulated cross-device rename failure"):
+        bank._atomic_write_yaml(target, {"schema_version": 1, "entries": []})
+
+    # The exception must propagate (caller decides what to do).
+    assert captured, "os.replace was never called — test setup wrong"
+    leftover = captured[0]
+    assert not Path(leftover).exists(), (
+        f"tmp file {leftover} was not unlinked after os.replace failure — "
+        "matches the bug class merge.atomic_write_yaml fixed; ensure "
+        "bank._atomic_write_yaml mirrors that pattern."
+    )
+
+    # No stray .profile.*.tmp in the directory either.
+    stragglers = sorted(p.name for p in tmp_path.glob(".profile.*.tmp"))
+    assert stragglers == [], f"leftover tmp files: {stragglers}"
+
+
+def test_atomic_write_happy_path_still_works(tmp_path):
+    """Round-trip on the happy path — confirm the unlink-on-failure
+    addition didn't break the normal write."""
+    target = tmp_path / "profile.yaml"
+    bank._atomic_write_yaml(target, {"schema_version": 1, "entries": []})
+    assert target.exists()
+    content = target.read_text()
+    assert "schema_version: 1" in content
+    assert "entries: []" in content
+    # No stray tmp files.
+    assert sorted(p.name for p in tmp_path.glob(".profile.*.tmp")) == []

package/coach/tests/test_bank_concurrency.py

@@ -0,0 +1,126 @@
+"""bank.py concurrency — bounded-wait lock acquire.
+
+Regression guard for the race where /coach-insights holds the profile lock at
+the moment SessionStart spawns bank.py. Before this fix, bank.py would
+non-blocking-fail immediately and silently drop the session's XP banking
+until the NEXT SessionStart. Now bank.py waits up to LOCK_WAIT_SECONDS
+for the lock to free up.
+"""
+from __future__ import annotations
+
+import fcntl
+import json
+import os
+import threading
+import time
+from pathlib import Path
+
+import pytest
+import yaml
+
+import bank
+
+
+def _hold_lock_for(path: Path, seconds: float, released: threading.Event) -> None:
+    """Acquire the lock, hold it for `seconds`, release, signal."""
+    with path.open("a+") as fh:
+        fcntl.flock(fh, fcntl.LOCK_EX)
+        time.sleep(seconds)
+        fcntl.flock(fh, fcntl.LOCK_UN)
+    released.set()
+
+
+def test_lock_acquired_immediately_when_free(tmp_path, monkeypatch):
+    """When nothing holds the lock, bank.py acquires essentially instantly."""
+    monkeypatch.setattr(bank, "LOCK_WAIT_SECONDS", 5)
+    monkeypatch.setattr(bank, "LOCK_RETRY_INTERVAL", 0.05)
+    lockfile_path = tmp_path / ".lock"
+
+    start = time.monotonic()
+    with lockfile_path.open("a+") as fh:
+        assert bank._acquire_lock_bounded(fh) is True
+    elapsed = time.monotonic() - start
+    assert elapsed < 0.2   # essentially immediate
+
+
+def test_lock_waits_then_succeeds_when_released(tmp_path, monkeypatch):
+    """If the lock frees up before the bounded-wait timeout, bank.py
+    acquires it and proceeds — the case that fixes the race."""
+    monkeypatch.setattr(bank, "LOCK_WAIT_SECONDS", 3)
+    monkeypatch.setattr(bank, "LOCK_RETRY_INTERVAL", 0.05)
+    lockfile_path = tmp_path / ".lock"
+    released = threading.Event()
+
+    # Hold the lock for 0.4s from a background thread.
+    holder = threading.Thread(
+        target=_hold_lock_for, args=(lockfile_path, 0.4, released), daemon=True,
+    )
+    holder.start()
+    time.sleep(0.05)   # ensure holder grabbed the lock first
+
+    start = time.monotonic()
+    with lockfile_path.open("a+") as fh:
+        acquired = bank._acquire_lock_bounded(fh)
+    elapsed = time.monotonic() - start
+
+    holder.join(timeout=2)
+    assert acquired is True
+    assert elapsed >= 0.3            # did wait for the holder
+    assert elapsed < 2.0             # but came back well before the timeout
+    assert released.is_set()
+
+
+def test_lock_gives_up_after_timeout(tmp_path, monkeypatch):
+    """If the holder never releases, bank.py returns False after the
+    bounded-wait deadline passes — safe fallback so a stuck lock never
+    hangs the process indefinitely."""
+    monkeypatch.setattr(bank, "LOCK_WAIT_SECONDS", 0.3)
+    monkeypatch.setattr(bank, "LOCK_RETRY_INTERVAL", 0.05)
+    lockfile_path = tmp_path / ".lock"
+    released = threading.Event()
+
+    # Hold the lock longer than LOCK_WAIT_SECONDS.
+    holder = threading.Thread(
+        target=_hold_lock_for, args=(lockfile_path, 1.0, released), daemon=True,
+    )
+    holder.start()
+    time.sleep(0.05)
+
+    start = time.monotonic()
+    with lockfile_path.open("a+") as fh:
+        acquired = bank._acquire_lock_bounded(fh)
+    elapsed = time.monotonic() - start
+
+    holder.join(timeout=3)
+    assert acquired is False
+    assert 0.2 <= elapsed < 0.8      # gave up around the timeout, not much later
+
+
+def test_bank_writes_session_banked_xp_not_milestones(tmp_path, monkeypatch):
+    profile_path = tmp_path / "profile.yaml"
+    ledger_path = tmp_path / "banked_sessions.json"
+    projects = tmp_path / "projects"
+    projects.mkdir()
+    transcript = projects / "session-1.jsonl"
+    transcript.write_text("{}\n")
+    old = time.time() - 3600
+    os.utime(transcript, (old, old))
+    profile_path.write_text(yaml.safe_dump({
+        "entries": [],
+        "graduated": [],
+        "milestone_xp": 3,
+    }))
+    monkeypatch.setattr(bank, "PROFILE", profile_path)
+    monkeypatch.setattr(bank, "LEDGER", ledger_path)
+    monkeypatch.setattr(bank, "PROJECTS", projects)
+    monkeypatch.setattr(bank, "_score_transcript", lambda _path, _profile: 12)
+
+    summary = bank._bank()
+
+    written = yaml.safe_load(profile_path.read_text())
+    ledger = json.loads(ledger_path.read_text())
+    assert summary["xp_added"] == 1
+    assert written["session_banked_xp"] == 1
+    assert written["banked_session_xp"] == 1
+    assert written["milestone_xp"] == 3
+    assert ledger["session-1"]["banked"] == 1