@misterhuydo/sentinel 1.5.63 → 1.6.0

package/python/tests/test_multi_repo_publish.py

@@ -0,0 +1,175 @@
+"""
+test_multi_repo_publish.py — Tests for publish_multi().
+
+publish_multi() takes the list of per-repo results from apply_and_commit_multi()
+and pushes / opens PRs per repo. PR bodies note the sibling repos in the same
+multi-repo fix, so reviewers can find them by branch name.
+
+Single-repo behavior must remain identical to today.
+"""
+from pathlib import Path
+from unittest.mock import patch
+from types import SimpleNamespace
+
+import pytest
+
+from sentinel import git_manager
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event(fp="deadbeef00000001"):
+    e = SimpleNamespace()
+    e.fingerprint = fp
+    e.source = "src"
+    e.message = "boom"
+    e.stack_trace = []
+    e.timestamp = "2026-04-24T10:00:00Z"
+    e.log_file = ""
+    e.short_summary = lambda: "boom in foo"
+    return e
+
+
+def _mk_repo(tmp_path: Path, name: str, auto_commit=False) -> RepoConfig:
+    p = tmp_path / "repos" / name
+    p.mkdir(parents=True, exist_ok=True)
+    return RepoConfig(
+        repo_name=name,
+        repo_url=f"git@github.com:org/{name}.git",
+        local_path=str(p),
+        branch="main",
+        auto_commit=auto_commit,
+    )
+
+
+def _mk_cfg():
+    cfg = SimpleNamespace()
+    cfg.project_name = "test-project"
+    cfg.github_token = "ghp_test"
+    cfg.slack_bot_token = ""
+    cfg.slack_channel = ""
+    cfg.auto_commit = False
+    cfg.auto_release = False
+    return cfg
+
+
+def _ok():
+    return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+
+# ── single-repo PR mode (unchanged behaviour) ────────────────────────────────
+
+def test_single_committed_repo_opens_one_pr(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    pr_url = "https://github.com/org/r1/pull/42"
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr", return_value=pr_url) as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    assert open_pr.call_count == 1
+    assert out[0]["pr_url"] == pr_url
+
+
+# ── multi-repo: each PR body lists sibling repos by name ──────────────────────
+
+def test_two_repos_each_pr_body_mentions_siblings(tmp_path):
+    cfg = _mk_cfg()
+    lib = _mk_repo(tmp_path, "lib")
+    consumer = _mk_repo(tmp_path, "consumer")
+    results = [
+        {"repo_name": "lib", "repo": lib, "status": "committed",
+         "commit_hash": "aaa1111", "branch": "main", "apply_order": 0,
+         "reason": "", "sub_patch_path": tmp_path / "lib.diff"},
+        {"repo_name": "consumer", "repo": consumer, "status": "committed",
+         "commit_hash": "bbb2222", "branch": "main", "apply_order": 1,
+         "reason": "", "sub_patch_path": tmp_path / "consumer.diff"},
+    ]
+
+    captured_extras: list[str] = []
+
+    def fake_open_pr(event, repo, cfg, branch, commit_hash, extra_body=""):
+        captured_extras.append(extra_body)
+        return f"https://github.com/org/{repo.repo_name}/pull/1"
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr", side_effect=fake_open_pr), \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    assert len(captured_extras) == 2
+    # lib's PR body mentions consumer; consumer's PR body mentions lib
+    assert "consumer" in captured_extras[0]
+    assert "lib"      in captured_extras[1]
+    # Both PRs are recorded back into results
+    assert all(r["pr_url"] for r in out if r["status"] == "committed")
+
+
+# ── failed entries are not pushed ─────────────────────────────────────────────
+
+def test_failed_entries_are_skipped_for_publish(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "failed",
+        "commit_hash": "", "branch": "", "apply_order": 0,
+        "reason": "tests failed", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()) as git_call, \
+         patch.object(git_manager, "_open_github_pr") as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=False):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    open_pr.assert_not_called()
+    git_call.assert_not_called()
+    assert out[0]["status"] == "failed"
+
+
+# ── auto_commit mode pushes directly to main, no PR ──────────────────────────
+
+def test_auto_commit_mode_pushes_no_pr(tmp_path):
+    cfg = _mk_cfg()
+    cfg.auto_commit = True   # global default
+    repo = _mk_repo(tmp_path, "r1", auto_commit=True)
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr") as open_pr:
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    open_pr.assert_not_called()
+    assert out[0]["pr_url"] == ""
+    # branch stays as repo.branch (main)
+    assert out[0]["branch"] == "main"
+
+
+# ── duplicate PR detection ───────────────────────────────────────────────────
+
+def test_existing_remote_branch_skips_push(tmp_path):
+    cfg = _mk_cfg()
+    repo = _mk_repo(tmp_path, "r1")
+    results = [{
+        "repo_name": "r1", "repo": repo, "status": "committed",
+        "commit_hash": "abc1234", "branch": "main", "apply_order": 0,
+        "reason": "", "sub_patch_path": tmp_path / "x.diff",
+    }]
+
+    with patch.object(git_manager, "_git", return_value=_ok()), \
+         patch.object(git_manager, "_open_github_pr") as open_pr, \
+         patch.object(git_manager, "remote_fix_exists", return_value=True):
+        out = git_manager.publish_multi(_mk_event(), results, cfg)
+
+    # remote branch already exists → don't open a duplicate PR
+    open_pr.assert_not_called()
+    assert out[0].get("pr_url", "") == ""

package/python/tests/test_patch_parser.py

@@ -0,0 +1,250 @@
+"""
+test_patch_parser.py — Unit tests for parse_multi_repo_patch().
+
+The parser splits a combined diff (paths prefixed `repos/<repo-name>/...`)
+into per-repo sub-patches with the prefix stripped. It is the linchpin of
+the multi-repo apply flow — these tests cover edge cases exhaustively.
+"""
+import pytest
+
+from sentinel.git_manager import parse_multi_repo_patch
+
+
+# ── happy path ────────────────────────────────────────────────────────────────
+
+def test_parse_single_repo_patch():
+    diff = (
+        "diff --git a/repos/repo-a/src/Foo.java b/repos/repo-a/src/Foo.java\n"
+        "index 1111..2222 100644\n"
+        "--- a/repos/repo-a/src/Foo.java\n"
+        "+++ b/repos/repo-a/src/Foo.java\n"
+        "@@ -1,3 +1,3 @@\n"
+        " line1\n"
+        "-old\n"
+        "+new\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert result["affected_repos"] == ["repo-a"]
+    assert "repo-a" in result["patches"]
+    sub = result["patches"]["repo-a"]
+    assert "diff --git a/src/Foo.java b/src/Foo.java" in sub
+    assert "--- a/src/Foo.java" in sub
+    assert "+++ b/src/Foo.java" in sub
+    assert "repos/repo-a" not in sub
+
+
+def test_parse_two_repo_patch_preserves_chunks():
+    diff = (
+        "diff --git a/repos/lib/src/A.java b/repos/lib/src/A.java\n"
+        "--- a/repos/lib/src/A.java\n"
+        "+++ b/repos/lib/src/A.java\n"
+        "@@ -1,1 +1,1 @@\n"
+        "-old-a\n"
+        "+new-a\n"
+        "diff --git a/repos/consumer/pom.xml b/repos/consumer/pom.xml\n"
+        "--- a/repos/consumer/pom.xml\n"
+        "+++ b/repos/consumer/pom.xml\n"
+        "@@ -1,1 +1,1 @@\n"
+        "-1.0\n"
+        "+1.1\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert set(result["affected_repos"]) == {"lib", "consumer"}
+    assert "new-a" in result["patches"]["lib"]
+    assert "+1.1" in result["patches"]["consumer"]
+    # No cross-contamination
+    assert "pom.xml" not in result["patches"]["lib"]
+    assert "A.java" not in result["patches"]["consumer"]
+
+
+def test_parse_multiple_files_same_repo():
+    diff = (
+        "diff --git a/repos/r1/a.txt b/repos/r1/a.txt\n"
+        "--- a/repos/r1/a.txt\n"
+        "+++ b/repos/r1/a.txt\n"
+        "@@ -1 +1 @@\n"
+        "-x\n+y\n"
+        "diff --git a/repos/r1/b.txt b/repos/r1/b.txt\n"
+        "--- a/repos/r1/b.txt\n"
+        "+++ b/repos/r1/b.txt\n"
+        "@@ -1 +1 @@\n"
+        "-p\n+q\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert result["affected_repos"] == ["r1"]
+    sub = result["patches"]["r1"]
+    # Both file diffs are in the same repo's patch
+    assert sub.count("diff --git") == 2
+    assert "a.txt" in sub
+    assert "b.txt" in sub
+
+
+# ── header parsing ────────────────────────────────────────────────────────────
+
+def test_affected_repos_header_sets_order():
+    diff = (
+        "# Affected repos: consumer, lib\n"
+        "\n"
+        "diff --git a/repos/lib/x b/repos/lib/x\n"
+        "--- a/repos/lib/x\n+++ b/repos/lib/x\n@@ -1 +1 @@\n-a\n+b\n"
+        "diff --git a/repos/consumer/y b/repos/consumer/y\n"
+        "--- a/repos/consumer/y\n+++ b/repos/consumer/y\n@@ -1 +1 @@\n-c\n+d\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    # Header defines order even though `lib` appears first in the diffs
+    assert result["affected_repos"] == ["consumer", "lib"]
+
+
+def test_affected_repos_header_case_insensitive():
+    diff = (
+        "# affected REPOS: r1\n"
+        "diff --git a/repos/r1/f b/repos/r1/f\n"
+        "--- a/repos/r1/f\n+++ b/repos/r1/f\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    assert parse_multi_repo_patch(diff)["affected_repos"] == ["r1"]
+
+
+def test_no_header_falls_back_to_diff_order():
+    diff = (
+        "diff --git a/repos/zebra/x b/repos/zebra/x\n"
+        "--- a/repos/zebra/x\n+++ b/repos/zebra/x\n@@ -1 +1 @@\n-a\n+b\n"
+        "diff --git a/repos/alpha/y b/repos/alpha/y\n"
+        "--- a/repos/alpha/y\n+++ b/repos/alpha/y\n@@ -1 +1 @@\n-c\n+d\n"
+    )
+    assert parse_multi_repo_patch(diff)["affected_repos"] == ["zebra", "alpha"]
+
+
+def test_header_with_repo_not_in_diffs_is_dropped():
+    """A header may overpromise; only repos with actual diffs end up in patches."""
+    diff = (
+        "# Affected repos: ghost, real\n"
+        "diff --git a/repos/real/f b/repos/real/f\n"
+        "--- a/repos/real/f\n+++ b/repos/real/f\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "ghost" not in result["patches"]
+    assert "real" in result["patches"]
+    # ghost is removed from affected_repos as well — patches dict is the source of truth
+    assert "ghost" not in result["affected_repos"]
+
+
+# ── special diff formats ──────────────────────────────────────────────────────
+
+def test_new_file_mode_strips_only_b_path():
+    """new-file diffs use /dev/null on the - side; only the +++ b/ path needs stripping."""
+    diff = (
+        "diff --git a/repos/r1/new.java b/repos/r1/new.java\n"
+        "new file mode 100644\n"
+        "index 0000000..abcd\n"
+        "--- /dev/null\n"
+        "+++ b/repos/r1/new.java\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+line one\n"
+        "+line two\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "new file mode 100644" in sub
+    assert "--- /dev/null" in sub
+    assert "+++ b/new.java" in sub
+    assert "diff --git a/new.java b/new.java" in sub
+    assert "repos/r1" not in sub
+
+
+def test_deleted_file_strips_only_a_path():
+    diff = (
+        "diff --git a/repos/r1/gone.java b/repos/r1/gone.java\n"
+        "deleted file mode 100644\n"
+        "index abcd..0000000\n"
+        "--- a/repos/r1/gone.java\n"
+        "+++ /dev/null\n"
+        "@@ -1,1 +0,0 @@\n"
+        "-bye\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "deleted file mode" in sub
+    assert "--- a/gone.java" in sub
+    assert "+++ /dev/null" in sub
+    assert "repos/r1" not in sub
+
+
+def test_rename_strips_both_paths():
+    diff = (
+        "diff --git a/repos/r1/old.java b/repos/r1/new.java\n"
+        "similarity index 100%\n"
+        "rename from repos/r1/old.java\n"
+        "rename to repos/r1/new.java\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    sub = result["patches"]["r1"]
+    assert "diff --git a/old.java b/new.java" in sub
+    assert "rename from old.java" in sub
+    assert "rename to new.java" in sub
+    assert "repos/r1" not in sub
+
+
+def test_nested_path_in_repo():
+    diff = (
+        "diff --git a/repos/r1/src/main/java/com/x/Foo.java b/repos/r1/src/main/java/com/x/Foo.java\n"
+        "--- a/repos/r1/src/main/java/com/x/Foo.java\n"
+        "+++ b/repos/r1/src/main/java/com/x/Foo.java\n"
+        "@@ -1 +1 @@\n-a\n+b\n"
+    )
+    sub = parse_multi_repo_patch(diff)["patches"]["r1"]
+    assert "diff --git a/src/main/java/com/x/Foo.java b/src/main/java/com/x/Foo.java" in sub
+    assert "--- a/src/main/java/com/x/Foo.java" in sub
+    assert "+++ b/src/main/java/com/x/Foo.java" in sub
+
+
+def test_repo_name_with_dashes_and_digits():
+    diff = (
+        "diff --git a/repos/1881-SSOLoginWebApp/src/F.java b/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "--- a/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "+++ b/repos/1881-SSOLoginWebApp/src/F.java\n"
+        "@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "1881-SSOLoginWebApp" in result["patches"]
+    assert "diff --git a/src/F.java" in result["patches"]["1881-SSOLoginWebApp"]
+
+
+# ── empty / malformed input ───────────────────────────────────────────────────
+
+def test_empty_patch_returns_empty():
+    result = parse_multi_repo_patch("")
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_only_header_no_diffs():
+    result = parse_multi_repo_patch("# Affected repos: r1\n")
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_diff_without_repos_prefix_is_rejected():
+    """A diff path that doesn't start with repos/<name>/ has no repo to route to."""
+    diff = (
+        "diff --git a/src/Loose.java b/src/Loose.java\n"
+        "--- a/src/Loose.java\n+++ b/src/Loose.java\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    # No repos identified → empty result
+    assert result["affected_repos"] == []
+    assert result["patches"] == {}
+
+
+def test_summary_lines_above_header_preserved():
+    diff = (
+        "Trim and broaden FirstName/LastName regex.\n"
+        "Reason: CRM names with diacritics were rejected.\n"
+        "\n"
+        "# Affected repos: r1\n"
+        "diff --git a/repos/r1/F.java b/repos/r1/F.java\n"
+        "--- a/repos/r1/F.java\n+++ b/repos/r1/F.java\n@@ -1 +1 @@\n-a\n+b\n"
+    )
+    result = parse_multi_repo_patch(diff)
+    assert "diacritics" in result["summary"]
+    assert "# Affected repos:" not in result["summary"]
+    assert "diff --git" not in result["summary"]

package/python/tests/test_project_lock.py

@@ -0,0 +1,85 @@
+"""
+test_project_lock.py — Tests for the per-project asyncio.Lock helper.
+
+The lock is what guarantees "one Claude session at a time per project" — a
+regression here means concurrent fix attempts can race on the working tree.
+"""
+import asyncio
+import pytest
+
+from sentinel.main import _project_lock, _project_locks
+
+
+@pytest.fixture(autouse=True)
+def _clear_locks():
+    """Each test starts with an empty lock registry."""
+    _project_locks.clear()
+    yield
+    _project_locks.clear()
+
+
+def test_same_project_returns_same_lock():
+    a = _project_lock("proj-1")
+    b = _project_lock("proj-1")
+    assert a is b
+
+
+def test_different_projects_get_different_locks():
+    a = _project_lock("proj-a")
+    b = _project_lock("proj-b")
+    assert a is not b
+
+
+def test_lock_is_an_asyncio_lock():
+    assert isinstance(_project_lock("p"), asyncio.Lock)
+
+
+def test_lock_is_lazily_created():
+    assert "lazy" not in _project_locks
+    _project_lock("lazy")
+    assert "lazy" in _project_locks
+
+
+def test_serializes_concurrent_async_tasks():
+    """Two coroutines acquiring the same project's lock must run sequentially."""
+    sequence: list[str] = []
+
+    async def worker(label: str):
+        async with _project_lock("p"):
+            sequence.append(f"{label}:start")
+            # yield control so the other task gets a chance to interleave (it shouldn't)
+            await asyncio.sleep(0)
+            sequence.append(f"{label}:end")
+
+    async def driver():
+        await asyncio.gather(worker("A"), worker("B"))
+
+    asyncio.run(driver())
+
+    # Whichever started first must finish before the other starts —
+    # no interleaving allowed.
+    assert sequence in [
+        ["A:start", "A:end", "B:start", "B:end"],
+        ["B:start", "B:end", "A:start", "A:end"],
+    ], f"unexpected interleave: {sequence}"
+
+
+def test_does_not_serialize_across_projects():
+    """Two coroutines acquiring DIFFERENT project locks may interleave."""
+    sequence: list[str] = []
+
+    async def worker(label: str, project: str):
+        async with _project_lock(project):
+            sequence.append(f"{label}:start")
+            await asyncio.sleep(0)  # let the other task run
+            sequence.append(f"{label}:end")
+
+    async def driver():
+        await asyncio.gather(worker("A", "proj-a"), worker("B", "proj-b"))
+
+    asyncio.run(driver())
+
+    # Different locks → tasks may interleave. We expect interleaving here
+    # because each task awaits asyncio.sleep(0) which yields control.
+    assert sequence == ["A:start", "B:start", "A:end", "B:end"] or \
+           sequence == ["B:start", "A:start", "B:end", "A:end"]

package/python/tests/test_state_store.py

@@ -126,3 +126,90 @@ def test_get_all_user_stats(store):
     assert len(stats) == 2
     ids = {s["user_id"] for s in stats}
     assert ids == {"U1", "U2"}
+
+
+# ── Multi-repo fix tracking (fix_repos table) ─────────────────────────────────
+
+def test_fix_repos_record_single(store):
+    store.record_fix_repo("fp1", "repo-a", branch="sentinel/fix-fp1",
+                          commit_hash="abc", pr_url="https://x/pr/1",
+                          pr_state="open", apply_order=0)
+    rows = store.get_fix_repos("fp1")
+    assert len(rows) == 1
+    assert rows[0]["repo_name"] == "repo-a"
+    assert rows[0]["pr_state"] == "open"
+    assert rows[0]["apply_order"] == 0
+
+
+def test_fix_repos_record_multiple_ordered(store):
+    store.record_fix_repo("fp1", "lib-typeib",  branch="b1", apply_order=0)
+    store.record_fix_repo("fp1", "consumer-svc", branch="b2", apply_order=1)
+    rows = store.get_fix_repos("fp1")
+    assert [r["repo_name"] for r in rows] == ["lib-typeib", "consumer-svc"]
+    assert [r["apply_order"] for r in rows] == [0, 1]
+
+
+def test_fix_repos_upsert_overwrites(store):
+    store.record_fix_repo("fp1", "repo-a", pr_state="open", apply_order=0)
+    store.record_fix_repo("fp1", "repo-a", pr_state="merged", apply_order=0,
+                          commit_hash="def")
+    rows = store.get_fix_repos("fp1")
+    assert len(rows) == 1
+    assert rows[0]["pr_state"] == "merged"
+    assert rows[0]["commit_hash"] == "def"
+
+
+def test_fix_repos_empty_for_unknown_fingerprint(store):
+    assert store.get_fix_repos("unknown-fp") == []
+
+
+def test_fix_repos_update_state(store):
+    store.record_fix_repo("fp1", "repo-a", pr_state="open", apply_order=0)
+    store.update_fix_repo_state("fp1", "repo-a", pr_state="merged",
+                                commit_hash="xyz")
+    rows = store.get_fix_repos("fp1")
+    assert rows[0]["pr_state"] == "merged"
+    assert rows[0]["commit_hash"] == "xyz"
+
+
+# ── Per-project Claude session tracking ───────────────────────────────────────
+
+def test_claude_session_unset_returns_none(store):
+    assert store.get_claude_session("proj-x") is None
+
+
+def test_claude_session_set_and_get(store):
+    store.set_claude_session("proj-x", "session-uuid-1", cost_delta=0.05)
+    s = store.get_claude_session("proj-x")
+    assert s["session_id"] == "session-uuid-1"
+    assert s["total_cost_usd"] == pytest.approx(0.05)
+    assert s["turn_count"] == 1
+
+
+def test_claude_session_accumulates_cost_and_turns(store):
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.10)
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.07)
+    s = store.get_claude_session("proj-x")
+    assert s["total_cost_usd"] == pytest.approx(0.17)
+    assert s["turn_count"] == 2
+
+
+def test_claude_session_replaces_session_id(store):
+    store.set_claude_session("proj-x", "session-1", cost_delta=0.10)
+    store.set_claude_session("proj-x", "session-2", cost_delta=0.05)
+    s = store.get_claude_session("proj-x")
+    assert s["session_id"] == "session-2"
+    assert s["total_cost_usd"] == pytest.approx(0.15)
+
+
+def test_claude_session_isolated_per_project(store):
+    store.set_claude_session("proj-a", "sess-a", cost_delta=0.10)
+    store.set_claude_session("proj-b", "sess-b", cost_delta=0.20)
+    assert store.get_claude_session("proj-a")["session_id"] == "sess-a"
+    assert store.get_claude_session("proj-b")["session_id"] == "sess-b"
+
+
+def test_claude_session_clear(store):
+    store.set_claude_session("proj-x", "sess-1", cost_delta=0.05)
+    store.clear_claude_session("proj-x")
+    assert store.get_claude_session("proj-x") is None