@misterhuydo/sentinel 1.6.11 → 1.6.13

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-04-27T13:09:20.340Z
+2026-04-27T17:46:15.506Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-04-27T12:15:40.415Z",
-  "checkpoint_at": "2026-04-27T12:15:40.417Z",
+  "message": "Auto-checkpoint at 2026-04-27T17:47:43.806Z",
+  "checkpoint_at": "2026-04-27T17:47:43.808Z",
   "active_files": [
     "J:\\Projects\\Sentinel\\cli\\bin\\sentinel.js",
     "J:\\Projects\\Sentinel\\cli\\lib\\test.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/sentinel",
-  "version": "1.6.11",
+  "version": "1.6.13",
   "description": "Sentinel — Autonomous DevOps Agent installer and manager",
   "bin": {
     "sentinel": "./bin/sentinel.js"

package/python/sentinel/__init__.py

@@ -1 +1 @@
-__version__ = "1.6.11"
+__version__ = "1.6.13"

package/python/sentinel/fix_engine.py

@@ -206,6 +206,16 @@ def _build_prompt(
         "   AFTER. Sentinel will merge in this order.",
         "7. Do not explain. Output only the patch (and the header if multi-repo).",
         "",
+        "HUNK CONTEXT — do NOT extend context to EOF",
+        "    End each hunk's context immediately after your last `+`/`-` change.",
+        "    Specifically: do NOT include the class-closing `}` (or any trailing",
+        "    blank/whitespace-only lines that lead to it) as context. Many files",
+        "    have stray blank lines or trailing tabs between the last method's",
+        "    closing brace and the file's final brace; if you anchor context on",
+        "    those, your line counts won't match and `git apply` will reject the",
+        "    patch. Keep hunks tight: 3 lines of context before/after the change",
+        "    is plenty.",
+        "",
         "ESCALATION SIGNALS",
         "8. Only if you truly cannot produce a safe fix — e.g. the root cause requires a",
         "   DB schema change, infrastructure update, business logic decision, or is inside",

package/python/sentinel/git_manager.py

@@ -104,6 +104,215 @@ def parse_multi_repo_patch(combined_patch: str) -> dict:
     return {"affected_repos": ordered, "patches": patches, "summary": summary}
 
 
+# ── Patch rewriter: splice missing intermediate context back in ───────────────
+#
+# LLM-generated diffs sometimes drop blank or whitespace-only lines from a
+# hunk's context — most often the trailing whitespace between a method's
+# closing brace and the file's class-closing brace. `git apply` requires
+# context to match the file *contiguously*, so a missing line breaks the
+# whole hunk. `--ignore-whitespace` ignores whitespace within a line; it does
+# NOT let context skip an entire line. The rewriter reads the actual file
+# and splices the skipped lines back as ' ' context.
+
+_HUNK_HEADER_RE = re.compile(
+    r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@"
+)
+_PATCH_FILE_HEADER_RE = re.compile(r"^\+\+\+ b/(.+?)\s*$", re.MULTILINE)
+
+
+def _line_match(file_line: str, patch_body: str) -> bool:
+    """Compare ignoring trailing whitespace and CR (LF mismatch tolerant)."""
+    return file_line.rstrip() == patch_body.rstrip()
+
+
+def _strip_eol(s: str) -> str:
+    if s.endswith("\r\n"):
+        return s[:-2]
+    if s.endswith("\n") or s.endswith("\r"):
+        return s[:-1]
+    return s
+
+
+def _repair_hunk_body(
+    file_lines: list[str],
+    anchor: int,
+    body_lines: list[str],
+    window: int = 8,
+) -> tuple[list[str], int]:
+    """Walk the hunk body against the actual file and splice missing context.
+
+    `body_lines` are full patch lines (with leading op char + newline).
+    `anchor` is the 1-based line number from `@@ -N`. Returns
+    (repaired_body_lines, repaired_anchor). Lines for which no match is
+    found within `window` are left alone — git apply will surface those.
+    """
+    # Detect the EOL style used by the body so spliced context lines match.
+    eol = "\n"
+    for ln in body_lines:
+        if ln.endswith("\r\n"):
+            eol = "\r\n"; break
+        if ln.endswith("\n"):
+            eol = "\n"; break
+
+    # Calibrate the anchor: search for the first ' '/'-' line within +/- window
+    # of the declared start. Most LLMs get the line number close-but-not-exact.
+    first_body: str | None = None
+    for ln in body_lines:
+        if not ln or ln in ("\n", "\r\n"):
+            first_body = ""; break
+        op = ln[0]
+        if op in (" ", "-"):
+            first_body = _strip_eol(ln[1:])
+            break
+        if op == "+":
+            continue
+    pos = max(0, anchor - 1)
+    if first_body is not None:
+        candidates: list[int] = []
+        for offset in range(-window, window + 1):
+            p = (anchor - 1) + offset
+            if 0 <= p < len(file_lines) and _line_match(file_lines[p], first_body):
+                candidates.append(p)
+        if candidates:
+            pos = min(candidates, key=lambda p: abs(p - (anchor - 1)))
+
+    new_anchor = pos + 1
+
+    out: list[str] = []
+    for ln in body_lines:
+        if not ln:
+            continue
+        if ln in ("\n", "\r\n"):
+            # Bare newline = blank context (treat as " ")
+            op, body = " ", ""
+        else:
+            op = ln[0]
+            body = _strip_eol(ln[1:])
+        if op == "+":
+            out.append(ln)
+            continue
+        if op == "\\":  # ""
+            out.append(ln)
+            continue
+        # ' ' or '-': must match the next file line.
+        if pos < len(file_lines) and _line_match(file_lines[pos], body):
+            out.append(ln)
+            pos += 1
+            continue
+        # Look ahead — if the patch's context line shows up within `window`
+        # lines, splice the skipped file lines in as ' ' context.
+        found = -1
+        for k in range(1, window + 1):
+            if pos + k < len(file_lines) and _line_match(file_lines[pos + k], body):
+                found = pos + k
+                break
+        if found >= 0:
+            for k in range(pos, found):
+                out.append(" " + file_lines[k] + eol)
+            out.append(ln)
+            pos = found + 1
+        else:
+            out.append(ln)
+    return out, new_anchor
+
+
+def _rewrite_hunk_header(header_line: str, new_anchor: int) -> str:
+    """Replace the old_start in `@@ -N,M +X,Y @@ ...` with new_anchor.
+
+    Preserves the optional `,M` count and everything after the second `@@`.
+    """
+    return re.sub(
+        r"^(@@ -)\d+(,?\d*)( \+\d+,?\d* @@.*)$",
+        lambda m: f"{m.group(1)}{new_anchor}{m.group(2)}{m.group(3)}",
+        header_line,
+        count=1,
+    )
+
+
+def repair_patch_against_files(patch_text: str, repo_root) -> str:
+    """Rewrite a patch in place against actual file content.
+
+    Reads each `+++ b/<path>` target from `repo_root` and walks every hunk's
+    context, splicing in any intermediate file lines the LLM dropped. Works
+    on patches whose paths are already stripped of any `repos/<name>/`
+    prefix (i.e. the per-repo sub-patch).
+
+    If a target file is missing or unreadable, the chunk is passed through
+    untouched. If a hunk's context can't be matched even with lookahead,
+    that hunk is also passed through — git apply will produce its normal
+    error. The rewriter is best-effort: it never makes a patch worse.
+    """
+    if not patch_text:
+        return patch_text
+    repo_root = Path(repo_root)
+
+    chunks = re.split(r"^(?=diff --git )", patch_text, flags=re.MULTILINE)
+    out_parts: list[str] = []
+    for chunk in chunks:
+        if not chunk.startswith("diff --git "):
+            out_parts.append(chunk)
+            continue
+        m = _PATCH_FILE_HEADER_RE.search(chunk)
+        if not m:
+            out_parts.append(chunk)
+            continue
+        relpath = m.group(1).strip()
+        # Strip a/ b/ prefix tolerance: git uses a/b but some tools strip them
+        if relpath.startswith("b/"):
+            relpath = relpath[2:]
+        fpath = repo_root / relpath
+        if not fpath.is_file():
+            out_parts.append(chunk)
+            continue
+        try:
+            text = fpath.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            out_parts.append(chunk)
+            continue
+        file_lines = text.splitlines()  # Strips line endings; matching is rstrip-tolerant
+        out_parts.append(_rewrite_chunk_hunks(chunk, file_lines))
+    return "".join(out_parts)
+
+
+def _rewrite_chunk_hunks(chunk: str, file_lines: list[str]) -> str:
+    """Walk hunks within a single-file chunk and repair each body."""
+    lines = chunk.splitlines(keepends=True)
+    out: list[str] = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        bare = _strip_eol(line)
+        m = _HUNK_HEADER_RE.match(bare)
+        if not m:
+            out.append(line)
+            i += 1
+            continue
+        anchor = int(m.group("old_start"))
+        # Collect the body until the next hunk header or section break.
+        body: list[str] = []
+        j = i + 1
+        while j < len(lines):
+            nxt = lines[j]
+            nxt_bare = _strip_eol(nxt)
+            if _HUNK_HEADER_RE.match(nxt_bare):
+                break
+            if nxt_bare.startswith(("diff --git ", "--- ", "+++ ", "index ", "Binary ")):
+                break
+            body.append(nxt)
+            j += 1
+        new_body, new_anchor = _repair_hunk_body(file_lines, anchor, body)
+        new_header = _rewrite_hunk_header(bare, new_anchor)
+        # Preserve trailing newline of the original header line.
+        if line.endswith("\r\n"):
+            new_header += "\r\n"
+        elif line.endswith("\n"):
+            new_header += "\n"
+        out.append(new_header)
+        out.extend(new_body)
+        i = j
+    return "".join(out)
+
+
 class MissingToolError(Exception):
     """Raised when a required build tool (e.g. mvn, gradle) is not installed."""
     def __init__(self, tool: str):
@@ -268,12 +477,22 @@ def apply_and_commit(
         logger.error("git pull failed for %s:\n%s", repo.repo_name, r.stderr)
         return "failed", ""
 
-    r = _git(["apply", "--check", "--recount", "--ignore-whitespace", str(patch_path)], cwd=local_path, env=env)
+    r = _git(["apply", "--check", "--recount", "--ignore-whitespace", "-C1", str(patch_path)], cwd=local_path, env=env)
     if r.returncode != 0:
-        logger.error("Patch dry-run failed for %s:\n%s", event.fingerprint, r.stderr)
-        return "failed", ""
+        try:
+            original = patch_path.read_text(encoding="utf-8", errors="replace")
+            repaired = repair_patch_against_files(original, local_path)
+        except Exception as _re:
+            logger.warning("patch repair failed for %s: %s", repo.repo_name, _re)
+            repaired = None
+        if repaired and repaired != original:
+            patch_path.write_text(repaired, encoding="utf-8")
+            r = _git(["apply", "--check", "--recount", "--ignore-whitespace", "-C1", str(patch_path)], cwd=local_path, env=env)
+        if r.returncode != 0:
+            logger.error("Patch dry-run failed for %s:\n%s", event.fingerprint, r.stderr)
+            return "failed", ""
 
-    r = _git(["apply", "--recount", "--ignore-whitespace", str(patch_path)], cwd=local_path, env=env)
+    r = _git(["apply", "--recount", "--ignore-whitespace", "-C1", str(patch_path)], cwd=local_path, env=env)
     if r.returncode != 0:
         logger.error("git apply failed for %s:\n%s", event.fingerprint, r.stderr)
         return "failed", ""
@@ -382,10 +601,30 @@ def apply_and_commit_multi(
             dry_run_failures.append(f"{name}: git pull failed: {r.stderr.strip()[:200]}")
             continue
         # Dry-run
-        r = _git(["apply", "--check", "--recount", "--ignore-whitespace", str(sub_path)],
+        r = _git(["apply", "--check", "--recount", "--ignore-whitespace", "-C1", str(sub_path)],
                  cwd=repo.local_path, env=env)
         if r.returncode != 0:
-            dry_run_failures.append(f"{name}: dry-run failed: {r.stderr.strip()[:200]}")
+            # Try repairing the patch by splicing in any intermediate file lines
+            # the LLM dropped from hunk context. Only retry if the rewrite
+            # actually changed the patch — otherwise we'd be looping.
+            try:
+                original = sub_path.read_text(encoding="utf-8", errors="replace")
+                repaired = repair_patch_against_files(original, repo.local_path)
+            except Exception as _re:
+                logger.warning("patch repair failed for %s: %s", name, _re)
+                repaired = None
+            if repaired and repaired != original:
+                sub_path.write_text(repaired, encoding="utf-8")
+                r = _git(
+                    ["apply", "--check", "--recount", "--ignore-whitespace", "-C1", str(sub_path)],
+                    cwd=repo.local_path, env=env,
+                )
+                if r.returncode == 0:
+                    logger.info("Patch repair succeeded for %s — spliced missing context", name)
+                else:
+                    dry_run_failures.append(f"{name}: dry-run failed: {r.stderr.strip()[:200]}")
+            else:
+                dry_run_failures.append(f"{name}: dry-run failed: {r.stderr.strip()[:200]}")
 
     if dry_run_failures:
         reason = "; ".join(dry_run_failures)
@@ -414,7 +653,7 @@ def apply_and_commit_multi(
             "reason": "", "sub_patch_path": sub_path,
         }
 
-        r = _git(["apply", "--recount", "--ignore-whitespace", str(sub_path)],
+        r = _git(["apply", "--recount", "--ignore-whitespace", "-C1", str(sub_path)],
                  cwd=repo.local_path, env=env)
         if r.returncode != 0:
             entry["reason"] = f"apply failed: {r.stderr.strip()[:200]}"

package/python/sentinel/main.py

@@ -563,7 +563,11 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
         return
 
     if store.fix_attempted_recently(event.fingerprint, hours=24):
-        logger.debug("Issue already processed recently: %s", event.source)
+        logger.info(
+            "Issue %s skipped — fingerprint %s attempted in last 24h "
+            "(use Boss `retry_issue` to clear the prior row and re-attempt)",
+            event.source, event.fingerprint,
+        )
         mark_done(event.issue_file)
         return
 

package/python/sentinel/sentinel_boss.py

@@ -2632,6 +2632,27 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             except Exception as _e:
                 logger.debug("retry_issue: state_store guard failed (non-fatal): %s", _e)
 
+            # Clear the 24h dedupe so _handle_issue actually re-runs the fix.
+            # fix_attempted_recently() ignores status='skipped', so flipping any
+            # recent 'failed' row for this fingerprint is enough.
+            try:
+                with store._conn() as _c:
+                    _n = _c.execute(
+                        "UPDATE fixes SET status='skipped' "
+                        "WHERE fingerprint=? AND status='failed' "
+                        "AND timestamp >= datetime('now', '-24 hours')",
+                        (_fp,),
+                    ).rowcount
+                    _c.commit()
+                if _n:
+                    logger.info(
+                        "Boss retry_issue: cleared %d prior failed row(s) for fingerprint %s "
+                        "so the retry won't be deduped",
+                        _n, _fp,
+                    )
+            except Exception as _e:
+                logger.debug("retry_issue: clearing prior failed rows failed (non-fatal): %s", _e)
+
         # Re-submit as a fresh issue file
         issues_dir = project_dir / "issues"
         issues_dir.mkdir(exist_ok=True)

package/python/tests/test_patch_repair.py

@@ -0,0 +1,240 @@
+"""
+test_patch_repair.py — Unit tests for repair_patch_against_files().
+
+LLM-generated diffs sometimes drop blank/whitespace-only lines from a hunk's
+trailing context — the most common case is a Java/Kotlin source file where
+`send()`'s closing `}` is on line N, and the class-closing `}` is on line N+4
+because there are stray blank lines between them. Claude's patch jumps from
+`	}` (1-tab method close) directly to `}` (column-0 class close), without
+the intermediate blanks. `git apply --check --recount --ignore-whitespace`
+rejects that because context must match the file contiguously.
+
+The rewriter reads the actual file from disk, finds the missing intermediate
+lines, and splices them in as ' ' context. After repair, `git apply --check
+--recount` succeeds.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from sentinel.git_manager import (
+    _line_match,
+    _repair_hunk_body,
+    _strip_eol,
+    repair_patch_against_files,
+)
+
+
+# ── pure-function tests for the low-level helpers ────────────────────────────
+
+
+def test_line_match_strips_cr_and_trailing_whitespace():
+    assert _line_match("hello", "hello")
+    assert _line_match("hello   ", "hello")
+    assert _line_match("hello\r", "hello")
+    assert _line_match("\t}\r", "\t}")
+    assert not _line_match("hello", "world")
+
+
+def test_strip_eol_handles_crlf_lf_cr_and_none():
+    assert _strip_eol("foo\r\n") == "foo"
+    assert _strip_eol("foo\n") == "foo"
+    assert _strip_eol("foo\r") == "foo"
+    assert _strip_eol("foo") == "foo"
+
+
+def test_repair_hunk_body_splices_missing_blank_lines():
+    """The d59ac840 case: hunk goes from method-close to class-close, skipping
+    3 blank/whitespace lines that exist in the file."""
+    file_lines = [
+        "public class Foo {",      # 1
+        "\tvoid send() {",         # 2
+        "\t\tdoStuff();",          # 3
+        "\t}",                     # 4  ← method close
+        "\t",                      # 5  ← stray tab
+        "",                        # 6  ← blank
+        "",                        # 7  ← blank
+        "}",                       # 8  ← class close
+    ]
+    body = [
+        " \tvoid send() {\n",
+        " \t\tdoStuff();\n",
+        " \t}\n",
+        " }\n",          # ← context jumps from L4 method-close to L8 class-close
+    ]
+    new_body, new_anchor = _repair_hunk_body(file_lines, anchor=2, body_lines=body)
+    assert new_anchor == 2
+    # The trailing context " }" must be preceded by 3 spliced ' ' context lines
+    bodies = [ln for ln in new_body]
+    assert bodies[-1] == " }\n"
+    assert bodies[-2] == " \n"
+    assert bodies[-3] == " \n"
+    assert bodies[-4] == " \t\n"
+    # Earlier context unchanged
+    assert " \tvoid send() {\n" in bodies
+    assert " \t}\n" in bodies
+
+
+def test_repair_hunk_body_preserves_crlf_eol_when_splicing():
+    file_lines = ["a", "", "", "b"]
+    body = [
+        " a\r\n",
+        " b\r\n",   # ← skips the 2 blank lines
+    ]
+    new_body, _ = _repair_hunk_body(file_lines, anchor=1, body_lines=body)
+    # Spliced lines should also use CRLF
+    assert new_body[1] == " \r\n"
+    assert new_body[2] == " \r\n"
+    assert new_body[3] == " b\r\n"
+
+
+def test_repair_hunk_body_calibrates_offset_anchor():
+    """If the LLM gets the hunk's start line number wrong by a few lines,
+    the calibration step finds the real start within the search window."""
+    file_lines = [
+        "header",                  # 1
+        "",                        # 2
+        "",                        # 3
+        "void send() {",           # 4  ← real start
+        "  body();",               # 5
+        "}",                       # 6
+    ]
+    body = [
+        " void send() {\n",
+        " }\n",  # skips body() — different test case
+    ]
+    # LLM said the hunk starts at line 1 (off by 3)
+    new_body, new_anchor = _repair_hunk_body(file_lines, anchor=1, body_lines=body)
+    assert new_anchor == 4  # calibrated to the real start
+
+
+def test_repair_hunk_body_leaves_unmatchable_lines_alone():
+    """If a context line genuinely doesn't appear in the file, the rewriter
+    passes it through and lets git apply produce its real error."""
+    file_lines = ["a", "b", "c"]
+    body = [
+        " a\n",
+        " ZZZ-NOT-IN-FILE\n",
+        " c\n",
+    ]
+    new_body, _ = _repair_hunk_body(file_lines, anchor=1, body_lines=body)
+    # The unmatchable line is preserved, no infinite splicing
+    assert " ZZZ-NOT-IN-FILE\n" in new_body
+
+
+# ── integration tests against real `git apply --check` ───────────────────────
+
+
+def _git_available() -> bool:
+    return shutil.which("git") is not None
+
+
+@pytest.mark.skipif(not _git_available(), reason="git binary not available")
+def test_repair_makes_d59ac840_patch_apply(tmp_path: Path):
+    """Reproduce the production failure: a Java file with stray blank lines
+    between method-close and class-close, plus a Claude-style patch that
+    drops them. After repair, `git apply --check` must succeed."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.email", "test@test"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.name", "test"], cwd=repo, check=True)
+
+    src = repo / "src" / "Foo.java"
+    src.parent.mkdir(parents=True)
+    # Real-world layout: tab + 3 blank lines before class close
+    src.write_text(
+        "public class Foo {\n"
+        "\tvoid send() {\n"
+        "\t\tlog.warn(\"old\");\n"
+        "\t}\n"
+        "\t\n"
+        "\n"
+        "\n"
+        "}\n",
+        encoding="utf-8",
+    )
+    subprocess.run(["git", "add", "."], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-qm", "init"], cwd=repo, check=True)
+
+    # Claude-style patch: trailing context skips the 3 intermediate lines.
+    patch = (
+        "diff --git a/src/Foo.java b/src/Foo.java\n"
+        "--- a/src/Foo.java\n"
+        "+++ b/src/Foo.java\n"
+        "@@ -2,4 +2,5 @@\n"
+        " \tvoid send() {\n"
+        "-\t\tlog.warn(\"old\");\n"
+        "+\t\tlog.error(\"new\");\n"
+        "+\t\tnotify();\n"
+        " \t}\n"
+        " }\n"
+    )
+    patch_path = tmp_path / "claude.diff"
+    patch_path.write_text(patch, encoding="utf-8")
+
+    # Sanity: vanilla git apply --check should fail
+    r = subprocess.run(
+        ["git", "apply", "--check", "--recount", "--ignore-whitespace", str(patch_path)],
+        cwd=repo, capture_output=True, text=True,
+    )
+    assert r.returncode != 0, "test setup wrong — patch was supposed to fail vanilla apply"
+
+    # Repair and retry
+    repaired = repair_patch_against_files(patch, repo)
+    assert repaired != patch
+    repaired_path = tmp_path / "repaired.diff"
+    repaired_path.write_text(repaired, encoding="utf-8")
+    r = subprocess.run(
+        ["git", "apply", "--check", "--recount", "--ignore-whitespace", str(repaired_path)],
+        cwd=repo, capture_output=True, text=True,
+    )
+    assert r.returncode == 0, f"repaired patch should apply but got: {r.stderr}"
+
+
+@pytest.mark.skipif(not _git_available(), reason="git binary not available")
+def test_repair_is_noop_when_patch_already_matches(tmp_path: Path):
+    """If a patch has the right context, the rewriter must return it
+    unchanged. We don't want to introduce gratuitous diffs."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    src = repo / "Foo.java"
+    src.write_text("a\nb\nc\n", encoding="utf-8")
+
+    patch = (
+        "diff --git a/Foo.java b/Foo.java\n"
+        "--- a/Foo.java\n"
+        "+++ b/Foo.java\n"
+        "@@ -1,3 +1,3 @@\n"
+        " a\n"
+        "-b\n"
+        "+B\n"
+        " c\n"
+    )
+    repaired = repair_patch_against_files(patch, repo)
+    # Anchor recalibration may rewrite the header but body should be identical
+    assert " a\n-b\n+B\n c\n" in repaired
+
+
+def test_repair_passes_through_when_target_file_missing(tmp_path: Path):
+    """If `+++ b/<path>` points to a file that doesn't exist, the rewriter
+    must leave the chunk alone — git apply will produce its own error."""
+    patch = (
+        "diff --git a/missing.java b/missing.java\n"
+        "--- a/missing.java\n"
+        "+++ b/missing.java\n"
+        "@@ -1,1 +1,1 @@\n"
+        "-x\n"
+        "+y\n"
+    )
+    repaired = repair_patch_against_files(patch, tmp_path)
+    assert repaired == patch
+
+
+def test_repair_handles_empty_input():
+    assert repair_patch_against_files("", "/anywhere") == ""
+    assert repair_patch_against_files(None, "/anywhere") in (None, "")  # type: ignore[arg-type]