@misterhuydo/sentinel 1.5.63 → 1.6.0

package/python/sentinel/state_store.py

@@ -87,6 +87,30 @@ class StateStore:
                     fingerprint   TEXT,            -- error/issue fingerprint that triggered it
                     committed_at  TEXT NOT NULL
                 );
+
+                -- One fingerprint can produce changes in multiple repos (cross-repo fix).
+                -- Each row tracks the per-repo branch / commit / PR for one such fingerprint.
+                CREATE TABLE IF NOT EXISTS fix_repos (
+                    fingerprint   TEXT NOT NULL,
+                    repo_name     TEXT NOT NULL,
+                    branch        TEXT,
+                    commit_hash   TEXT,
+                    pr_url        TEXT,
+                    pr_state      TEXT,            -- open|merged|closed|failed
+                    apply_order   INTEGER DEFAULT 0,
+                    timestamp     TEXT NOT NULL,
+                    PRIMARY KEY (fingerprint, repo_name)
+                );
+
+                -- Long-lived `claude --print --resume <id>` sessions, one per project.
+                -- Lets cross-task prompt cache hit and gives Claude continuous context.
+                CREATE TABLE IF NOT EXISTS claude_sessions (
+                    project_name    TEXT PRIMARY KEY,
+                    session_id      TEXT NOT NULL,
+                    last_used       TEXT NOT NULL,
+                    total_cost_usd  REAL NOT NULL DEFAULT 0,
+                    turn_count      INTEGER NOT NULL DEFAULT 0
+                );
             """)
         self._migrate()
         logger.debug("StateStore initialised at %s", self.db_path)
@@ -276,6 +300,103 @@ class StateStore:
             ).fetchone()
             return row is not None
 
+    # ── Multi-repo fix tracking (one fingerprint → many repos) ────────────────
+
+    def record_fix_repo(
+        self,
+        fingerprint: str,
+        repo_name: str,
+        branch: str = "",
+        commit_hash: str = "",
+        pr_url: str = "",
+        pr_state: str = "",
+        apply_order: int = 0,
+    ) -> None:
+        """Record (or replace) the per-repo branch/commit/PR for a multi-repo fix."""
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO fix_repos (fingerprint, repo_name, branch, commit_hash, "
+                "pr_url, pr_state, apply_order, timestamp) VALUES (?,?,?,?,?,?,?,?) "
+                "ON CONFLICT(fingerprint, repo_name) DO UPDATE SET "
+                "branch=excluded.branch, commit_hash=excluded.commit_hash, "
+                "pr_url=excluded.pr_url, pr_state=excluded.pr_state, "
+                "apply_order=excluded.apply_order, timestamp=excluded.timestamp",
+                (fingerprint, repo_name, branch, commit_hash,
+                 pr_url, pr_state, apply_order, _now()),
+            )
+
+    def update_fix_repo_state(
+        self,
+        fingerprint: str,
+        repo_name: str,
+        pr_state: str = "",
+        commit_hash: str = "",
+    ) -> None:
+        """Patch pr_state and/or commit_hash on an existing fix_repos row."""
+        sets, args = [], []
+        if pr_state:
+            sets.append("pr_state=?"); args.append(pr_state)
+        if commit_hash:
+            sets.append("commit_hash=?"); args.append(commit_hash)
+        if not sets:
+            return
+        args.extend([fingerprint, repo_name])
+        with self._conn() as conn:
+            conn.execute(
+                f"UPDATE fix_repos SET {', '.join(sets)} "
+                "WHERE fingerprint=? AND repo_name=?", args,
+            )
+
+    def get_fix_repos(self, fingerprint: str) -> list[dict]:
+        """Return all per-repo rows for a fingerprint, ordered by apply_order then repo_name."""
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM fix_repos WHERE fingerprint=? "
+                "ORDER BY apply_order, repo_name",
+                (fingerprint,),
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    # ── Per-project Claude session tracking (for `claude --resume <id>`) ──────
+
+    def get_claude_session(self, project_name: str) -> dict | None:
+        """Return the saved {session_id, last_used, total_cost_usd, turn_count} or None."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT session_id, last_used, total_cost_usd, turn_count "
+                "FROM claude_sessions WHERE project_name=?",
+                (project_name,),
+            ).fetchone()
+            return dict(row) if row else None
+
+    def set_claude_session(
+        self,
+        project_name: str,
+        session_id: str,
+        cost_delta: float = 0.0,
+    ) -> None:
+        """Upsert the session id; accumulates cost + turn count across calls."""
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO claude_sessions "
+                "(project_name, session_id, last_used, total_cost_usd, turn_count) "
+                "VALUES (?, ?, ?, ?, 1) "
+                "ON CONFLICT(project_name) DO UPDATE SET "
+                "session_id=excluded.session_id, "
+                "last_used=excluded.last_used, "
+                "total_cost_usd=total_cost_usd + excluded.total_cost_usd, "
+                "turn_count=turn_count + 1",
+                (project_name, session_id, _now(), cost_delta),
+            )
+
+    def clear_claude_session(self, project_name: str) -> None:
+        """Drop the saved session id for a project (forces a fresh session next call)."""
+        with self._conn() as conn:
+            conn.execute(
+                "DELETE FROM claude_sessions WHERE project_name=?",
+                (project_name,),
+            )
+
     def mark_marker_seen(self, marker: str) -> dict | None:
         """Record that a SENTINEL marker appeared in production logs."""
         with self._conn() as conn:

package/python/tests/test_cairn_client.py

@@ -0,0 +1,72 @@
+"""
+test_cairn_client.py — Unit tests for cairn federation init.
+"""
+from unittest.mock import patch, MagicMock
+import pytest
+
+from sentinel.cairn_client import init_project_root, index_repo
+from sentinel.config_loader import RepoConfig
+
+
+def _fake_completed(rc=0, stdout="", stderr=""):
+    m = MagicMock()
+    m.returncode = rc
+    m.stdout = stdout
+    m.stderr = stderr
+    return m
+
+
+# ── init_project_root ─────────────────────────────────────────────────────────
+
+def test_init_project_root_skips_when_marker_exists(tmp_path):
+    (tmp_path / ".cairn").mkdir()
+    (tmp_path / ".cairn" / ".cairn-project").touch()
+    with patch("sentinel.cairn_client.subprocess.run") as run:
+        ok = init_project_root(str(tmp_path))
+    assert ok is True
+    run.assert_not_called()
+
+
+def test_init_project_root_runs_cairn_install_when_missing(tmp_path):
+    with patch("sentinel.cairn_client.subprocess.run",
+               return_value=_fake_completed(rc=0)) as run:
+        ok = init_project_root(str(tmp_path))
+    assert ok is True
+    run.assert_called_once()
+    args, kwargs = run.call_args
+    assert args[0] == ["cairn", "install"]
+    assert kwargs["cwd"] == str(tmp_path)
+
+
+def test_init_project_root_returns_false_on_install_failure(tmp_path):
+    with patch("sentinel.cairn_client.subprocess.run",
+               return_value=_fake_completed(rc=1, stderr="boom")):
+        ok = init_project_root(str(tmp_path))
+    assert ok is False
+
+
+def test_init_project_root_returns_false_on_subprocess_exception(tmp_path):
+    with patch("sentinel.cairn_client.subprocess.run",
+               side_effect=FileNotFoundError("cairn not on PATH")):
+        ok = init_project_root(str(tmp_path))
+    assert ok is False
+
+
+def test_init_project_root_creates_nothing_when_dir_missing(tmp_path):
+    missing = tmp_path / "does-not-exist"
+    with patch("sentinel.cairn_client.subprocess.run") as run:
+        ok = init_project_root(str(missing))
+    assert ok is False
+    run.assert_not_called()
+
+
+# ── index_repo (existing behaviour — guard against regression) ────────────────
+
+def test_index_repo_skips_when_marker_exists(tmp_path):
+    (tmp_path / ".cairn").mkdir()
+    (tmp_path / ".cairn" / ".cairn-project").touch()
+    repo = RepoConfig(repo_name="r", local_path=str(tmp_path), branch="main")
+    with patch("sentinel.cairn_client.subprocess.run") as run:
+        ok = index_repo(repo)
+    assert ok is True
+    run.assert_not_called()

package/python/tests/test_fix_engine_json.py

@@ -0,0 +1,95 @@
+"""
+test_fix_engine_json.py — Unit tests for _parse_claude_json().
+
+Parses the single-object JSON emitted by `claude --print --output-format json`.
+Critical: must extract session_id (for resume), cost (for budget tracking),
+and the result text (which contains the patch).
+"""
+import json
+import pytest
+
+from sentinel.fix_engine import _parse_claude_json
+
+
+def _wrap(result_text: str, session_id: str = "abc-123",
+          cost: float = 0.05, is_error: bool = False) -> str:
+    return json.dumps({
+        "type": "result",
+        "subtype": "success" if not is_error else "error",
+        "is_error": is_error,
+        "result": result_text,
+        "session_id": session_id,
+        "total_cost_usd": cost,
+        "duration_ms": 1234,
+        "stop_reason": "end_turn",
+    })
+
+
+# ── happy path ────────────────────────────────────────────────────────────────
+
+def test_extracts_result_session_cost():
+    raw = _wrap("Here is the patch:\n```diff\n...```", "sess-1", 0.07)
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "sess-1"
+    assert parsed["total_cost_usd"] == pytest.approx(0.07)
+    assert "patch" in parsed["result"]
+    assert parsed["is_error"] is False
+
+
+def test_handles_zero_cost():
+    raw = _wrap("ok", "sess", 0.0)
+    parsed = _parse_claude_json(raw)
+    assert parsed["total_cost_usd"] == 0.0
+
+
+def test_carries_is_error_flag():
+    raw = _wrap("err msg", "sess", 0.01, is_error=True)
+    parsed = _parse_claude_json(raw)
+    assert parsed["is_error"] is True
+
+
+# ── tolerant inputs ───────────────────────────────────────────────────────────
+
+def test_strips_leading_trailing_whitespace():
+    raw = "   \n" + _wrap("ok", "s", 0.0) + "\n  "
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "ok"
+
+
+def test_finds_json_after_stderr_garbage():
+    """Claude sometimes prints debug lines before the JSON object."""
+    raw = (
+        "Some stderr line\n"
+        "Another warning\n"
+        + _wrap("payload", "s", 0.0)
+    )
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "payload"
+
+
+def test_returns_empty_on_unparseable():
+    parsed = _parse_claude_json("not json at all")
+    assert parsed["session_id"] == ""
+    assert parsed["result"] == ""
+    assert parsed["total_cost_usd"] == 0.0
+    # When unparseable, surface as an error so caller doesn't silently swallow it
+    assert parsed["is_error"] is True
+
+
+def test_returns_empty_on_empty_string():
+    parsed = _parse_claude_json("")
+    assert parsed["session_id"] == ""
+    assert parsed["result"] == ""
+    assert parsed["is_error"] is True
+
+
+def test_handles_missing_fields_gracefully():
+    """If claude omits some fields, extract what's there and default the rest."""
+    raw = json.dumps({"type": "result", "result": "x", "session_id": "s"})
+    parsed = _parse_claude_json(raw)
+    assert parsed["session_id"] == "s"
+    assert parsed["result"] == "x"
+    assert parsed["total_cost_usd"] == 0.0
+    assert parsed["is_error"] is False

package/python/tests/test_fix_engine_prompt.py

@@ -0,0 +1,93 @@
+"""
+test_fix_engine_prompt.py — Spot-checks for the multi-repo prompt builder.
+
+The prompt is mostly free text — these tests assert *presence* of key
+instructions, not exact wording, so they tolerate cosmetic edits.
+"""
+from sentinel.fix_engine import _build_prompt
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event():
+    """Minimal ErrorEvent-like duck for the prompt builder."""
+    class E:
+        source = "MyService"
+        severity = "ERROR"
+        message = "NullPointerException in Foo.bar()"
+        body = ""
+        stack_trace = []
+        def full_text(self):
+            return f"{self.message}\n  at Foo.bar"
+    return E()
+
+
+def _mk_repo(name: str) -> RepoConfig:
+    return RepoConfig(
+        repo_name=name,
+        local_path=f"/proj/repos/{name}",
+        branch="main",
+    )
+
+
+def test_prompt_lists_all_repos_in_project():
+    repos = [_mk_repo("repo-a"), _mk_repo("repo-b"), _mk_repo("repo-c")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="sentinel-deadbeef",
+                           all_repos=repos, project_root="/proj")
+    assert "repo-a" in prompt
+    assert "repo-b" in prompt
+    assert "repo-c" in prompt
+
+
+def test_prompt_names_primary_repo_as_origin():
+    repos = [_mk_repo("primary"), _mk_repo("other")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    # Primary repo must be clearly identified as where the error originated
+    assert "primary" in prompt
+    # Sanity: project root is referenced, not the per-repo path
+    assert "/p" in prompt
+
+
+def test_prompt_explains_repos_prefix_path_format():
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    # Must instruct claude to use the repos/<name>/ path prefix
+    assert "repos/" in prompt
+    # And explain the multi-repo header
+    assert "Affected repos" in prompt
+
+
+def test_prompt_instructs_cairn_checkpoint_call():
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    assert "cairn_checkpoint" in prompt
+
+
+def test_prompt_keeps_marker_instruction():
+    """Sentinel marker injection is still required for verification flow."""
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="sentinel-abc12345",
+                           all_repos=repos, project_root="/p")
+    assert "sentinel-abc12345" in prompt
+
+
+def test_prompt_keeps_escalation_keywords():
+    """NEEDS_HUMAN / BOSS_ESCALATE keywords must remain — main.py keys off them."""
+    repos = [_mk_repo("r1")]
+    prompt = _build_prompt(_mk_event(), repos[0], log_file=None,
+                           marker="m", all_repos=repos, project_root="/p")
+    assert "NEEDS_HUMAN:" in prompt
+    assert "BOSS_ESCALATE:" in prompt
+
+
+def test_prompt_works_with_single_repo_project():
+    """Single-repo projects should still get a sensible prompt — no list weirdness."""
+    repo = _mk_repo("only-repo")
+    prompt = _build_prompt(_mk_event(), repo, log_file=None, marker="m",
+                           all_repos=[repo], project_root="/p")
+    assert "only-repo" in prompt
+    assert "repos/" in prompt  # prefix instruction still present

package/python/tests/test_multi_repo_apply.py

@@ -0,0 +1,254 @@
+"""
+test_multi_repo_apply.py — Tests for apply_and_commit_multi().
+
+The flow under test:
+  Phase 1 (atomic) — every affected repo's sub-patch is dry-run.
+                     If any fails, ALL are marked "aborted" with no mutations.
+  Phase 2 (per-repo)— apply + test + commit, serially. Per-repo failures
+                     don't abort the others (partial-success allowed at this point).
+
+Tests mock _git and _run_tests so they're fast and deterministic.
+"""
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from types import SimpleNamespace
+
+import pytest
+
+from sentinel import git_manager
+from sentinel.config_loader import RepoConfig
+
+
+def _mk_event(fingerprint="deadbeef00000001", source="src"):
+    e = SimpleNamespace()
+    e.fingerprint = fingerprint
+    e.source = source
+    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) -> RepoConfig:
+    p = tmp_path / "repos" / name
+    p.mkdir(parents=True, exist_ok=True)
+    return RepoConfig(repo_name=name, local_path=str(p), branch="main")
+
+
+def _mk_cfg(tmp_path: Path):
+    cfg = SimpleNamespace()
+    cfg.workspace_dir = str(tmp_path / "workspace")
+    Path(cfg.workspace_dir).mkdir(exist_ok=True)
+    cfg.project_name = "test-project"
+    cfg.github_token = ""
+    cfg.slack_bot_token = ""
+    cfg.slack_channel = ""
+    return cfg
+
+
+def _ok():
+    """Mock _git result indicating success."""
+    return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+
+def _fail(err="bad"):
+    return SimpleNamespace(returncode=1, stdout="", stderr=err)
+
+
+def _git_dispatch(returns_per_cmd: dict):
+    """Build a fake _git that returns based on the command verb (args[0]).
+
+    `returns_per_cmd` maps verb → list of CompletedProcess results (one per call).
+    Falls back to _ok() if a verb isn't listed.
+    """
+    counters = {k: 0 for k in returns_per_cmd}
+    def fake_git(args, cwd, env=None, timeout=git_manager.GIT_TIMEOUT):
+        verb = args[0]
+        if verb in returns_per_cmd:
+            results = returns_per_cmd[verb]
+            i = counters[verb]
+            counters[verb] = min(i + 1, len(results) - 1) if results else 0
+            return results[i] if i < len(results) else results[-1]
+        if verb == "rev-parse":
+            return SimpleNamespace(returncode=0, stdout="abc1234567890def\n", stderr="")
+        return _ok()
+    return fake_git
+
+
+# ── helpers to build patches ──────────────────────────────────────────────────
+
+def _patch_one_repo(repo_name="r1") -> str:
+    return (
+        f"diff --git a/repos/{repo_name}/src/F.java b/repos/{repo_name}/src/F.java\n"
+        f"--- a/repos/{repo_name}/src/F.java\n"
+        f"+++ b/repos/{repo_name}/src/F.java\n"
+        f"@@ -1 +1 @@\n-old\n+new\n"
+    )
+
+
+def _patch_two_repos(lib="lib", consumer="consumer") -> str:
+    return (
+        f"# Affected repos: {lib}, {consumer}\n"
+        f"diff --git a/repos/{lib}/src/A.java b/repos/{lib}/src/A.java\n"
+        f"--- a/repos/{lib}/src/A.java\n+++ b/repos/{lib}/src/A.java\n"
+        f"@@ -1 +1 @@\n-a\n+b\n"
+        f"diff --git a/repos/{consumer}/pom.xml b/repos/{consumer}/pom.xml\n"
+        f"--- a/repos/{consumer}/pom.xml\n+++ b/repos/{consumer}/pom.xml\n"
+        f"@@ -1 +1 @@\n-1.0\n+1.1\n"
+    )
+
+
+# ── empty / unknown ───────────────────────────────────────────────────────────
+
+def test_empty_patch_returns_empty(tmp_path):
+    patch_file = tmp_path / "empty.diff"
+    patch_file.write_text("")
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+    result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+    assert result == []
+
+
+def test_patch_with_unknown_repo_returns_empty(tmp_path):
+    patch_file = tmp_path / "x.diff"
+    patch_file.write_text(_patch_one_repo("ghost-repo"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "real-repo")]
+    result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+    # ghost-repo is unknown → nothing applied
+    assert result == []
+
+
+# ── single-repo happy path ────────────────────────────────────────────────────
+
+def test_single_repo_happy_path(tmp_path):
+    patch_file = tmp_path / "s.diff"
+    patch_file.write_text(_patch_one_repo("r1"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert len(result) == 1
+    r = result[0]
+    assert r["repo_name"] == "r1"
+    assert r["status"] == "committed"
+    assert r["commit_hash"].startswith("abc")
+    assert r["apply_order"] == 0
+
+
+# ── two-repo happy path with header order ─────────────────────────────────────
+
+def test_two_repos_happy_path_preserves_apply_order(tmp_path):
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert [r["repo_name"] for r in result] == ["lib", "consumer"]
+    assert [r["apply_order"] for r in result] == [0, 1]
+    assert all(r["status"] == "committed" for r in result)
+
+
+# ── atomic abort — one dry-run failure aborts ALL ─────────────────────────────
+
+def test_dry_run_failure_aborts_all_repos(tmp_path):
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    # dry-run is `git apply --check ...`. We make the FIRST `apply --check` fail
+    # by making the apply verb fail on the second call (consumer's dry-run).
+    apply_results = [_ok(), _fail("conflict in consumer")]
+
+    with patch.object(git_manager, "_git",
+                      side_effect=_git_dispatch({"apply": apply_results})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    # Both repos must be marked aborted (atomic invariant)
+    assert len(result) == 2
+    assert all(r["status"] == "aborted" for r in result)
+    # No commits anywhere
+    assert all(r["commit_hash"] == "" for r in result)
+    # Reason should mention which repo's dry-run failed
+    assert any("consumer" in r["reason"] for r in result)
+
+
+def test_protected_paths_aborts_immediately(tmp_path):
+    patch_file = tmp_path / "x.diff"
+    patch_file.write_text(_patch_one_repo("r1"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "r1")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=True):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    assert len(result) == 1
+    assert result[0]["status"] == "aborted"
+    assert "protected" in result[0]["reason"].lower()
+
+
+# ── per-repo failure in phase 2 ──────────────────────────────────────────────
+
+def test_phase2_test_failure_marks_only_that_repo(tmp_path):
+    """If tests fail for one repo in phase 2, the other repos still get committed."""
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    # _run_tests returns True for lib, False for consumer
+    test_results = [True, False]
+    test_iter = iter(test_results)
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", side_effect=lambda *a, **kw: next(test_iter)), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    by_name = {r["repo_name"]: r for r in result}
+    assert by_name["lib"]["status"] == "committed"
+    assert by_name["consumer"]["status"] == "failed"
+    assert "test" in by_name["consumer"]["reason"].lower()
+
+
+# ── sub-patch files written to disk ──────────────────────────────────────────
+
+def test_sub_patch_files_are_written(tmp_path):
+    """Each affected repo gets its own per-repo .diff file for traceability."""
+    patch_file = tmp_path / "m.diff"
+    patch_file.write_text(_patch_two_repos("lib", "consumer"))
+    cfg = _mk_cfg(tmp_path)
+    repos = [_mk_repo(tmp_path, "lib"), _mk_repo(tmp_path, "consumer")]
+
+    with patch.object(git_manager, "_git", side_effect=_git_dispatch({})), \
+         patch.object(git_manager, "_run_tests", return_value=True), \
+         patch.object(git_manager, "_check_protected_paths", return_value=False), \
+         patch.object(git_manager, "_append_changelog"):
+        result = git_manager.apply_and_commit_multi(_mk_event(), patch_file, repos, cfg)
+
+    for r in result:
+        sub_path = r["sub_patch_path"]
+        assert Path(sub_path).exists(), f"sub-patch missing for {r['repo_name']}"
+        contents = Path(sub_path).read_text()
+        # Path prefix was stripped — repos/<name>/ should NOT appear
+        assert f"repos/{r['repo_name']}" not in contents