codna 0.2.18__tar.gz → 0.2.20__tar.gz

{codna-0.2.18 → codna-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.18
+Version: 0.2.20
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.18 → codna-0.2.20}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.18"
+__version__ = "0.2.20"

{codna-0.2.18 → codna-0.2.20}/codna/fix_inputs.py

@@ -72,7 +72,21 @@ def _is_remote_repo_spec(repo: str) -> bool:
     return clean.startswith(("http://", "https://", "git@")) or clean.endswith(".git")
 
 
-def _run_git_for_remote_tests(args: list[str], *, cwd: str | None, env: dict[str, str] | None) -> None:
+_REMOTE_GIT_TIMEOUT_S = 120
+# The initial clone is the one step that scales with repository size, and 120 s was measured too
+# small for a real repo: thyn-ai/algenta (~81 MB packed) hit exactly 120 s on a 2-vCPU Fly machine
+# on 2026-09-17, every time, so every CI-failure autofix there died before discovering a single
+# test. Shallow (below) plus five minutes.
+_REMOTE_CLONE_TIMEOUT_S = 300
+
+
+def _run_git_for_remote_tests(
+    args: list[str],
+    *,
+    cwd: str | None,
+    env: dict[str, str] | None,
+    timeout: float = _REMOTE_GIT_TIMEOUT_S,
+) -> None:
     try:
         proc = subprocess.run(
             ["git", *args],
@@ -80,7 +94,7 @@ def _run_git_for_remote_tests(args: list[str], *, cwd: str | None, env: dict[str
             env=env,
             capture_output=True,
             text=True,
-            timeout=120,
+            timeout=timeout,
             check=False,
         )
     except (OSError, subprocess.SubprocessError) as exc:
@@ -123,15 +137,20 @@ def _discover_remote_failing_tests_for_fix(args, github_token: str | None):
     root = tempfile.mkdtemp(prefix="codna-remote-test-discovery-")
     checkout = os.path.join(root, "repo")
     try:
-        clone_args = ["clone", "--no-tags"]
+        # ALWAYS shallow. This used to skip --depth=1 whenever a ref was given, on the theory that
+        # the ref might not be the branch tip -- but _checkout_remote_ref fetches the exact ref
+        # shallowly right after (`git fetch --depth=1 origin <ref>`), so the full history was
+        # downloaded and then never used. On a large repo that full clone is precisely what blew
+        # the timeout (thyn-ai/algenta, 2026-09-17: 120 s, every attempt).
+        clone_args = ["clone", "--no-tags", "--depth=1"]
         ref = getattr(args, "ref", None)
         base_branch = getattr(args, "base_branch", None)
-        if not ref:
-            clone_args.append("--depth=1")
-            if base_branch:
-                clone_args.extend(["--single-branch", "--branch", base_branch])
+        if not ref and base_branch:
+            clone_args.extend(["--single-branch", "--branch", base_branch])
         clone_args.extend([repo_url, checkout])
-        _run_git_for_remote_tests(clone_args, cwd=None, env=env)
+        _run_git_for_remote_tests(
+            clone_args, cwd=None, env=env, timeout=_REMOTE_CLONE_TIMEOUT_S
+        )
         if ref:
             _checkout_remote_ref(checkout, ref, repository_url=repo_url, token=github_token)
         return _discover_failing_tests_for_fix(checkout, getattr(args, "test_cmd", None))

{codna-0.2.18 → codna-0.2.20}/codna/webhook_github.py

@@ -158,6 +158,49 @@ def update_check_run(repo_full_name: str, token: str, check_run_id: int, *, conc
         raise WebhookError("check_run_update_failed", f"update check run: {resp.status_code} {resp.text[:200]}")
 
 
+def complete_stale_check_runs(
+    repo_full_name: str, token: str, *, head_sha: str, name: str, summary: str
+) -> int:
+    """Complete (as ``cancelled``) every still-``in_progress`` Check Run named ``name`` on
+    ``head_sha``. Returns how many were closed. Best-effort hygiene: never raises.
+
+    A run this worker opened and then lost -- killed mid-job by a redeploy, or a crash before
+    update_check_run -- stays "in progress" on that commit forever, because only the App that
+    created a Check Run may complete it and nothing else ever will. Observed live:
+    thyn-ai/algenta@cc26ddd6 `codna fix` in_progress from 2026-09-17 04:49 onward. Called right
+    before a fresh run is created for the same (sha, name), so a retry supersedes its dead
+    predecessor instead of stacking a second spinner next to it.
+    """
+    try:
+        import httpx
+    except Exception:  # noqa: BLE001
+        return 0
+    headers = {"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"}
+    try:
+        resp = httpx.get(
+            f"{_API}/repos/{repo_full_name}/commits/{head_sha}/check-runs",
+            headers=headers, params={"check_name": name, "status": "in_progress", "per_page": 50},
+            timeout=30.0, follow_redirects=True,
+        )
+    except Exception:  # noqa: BLE001
+        return 0
+    if resp.status_code >= 300:
+        return 0
+    closed = 0
+    for run in (resp.json() or {}).get("check_runs") or []:
+        run_id = run.get("id")
+        if not run_id:
+            continue
+        try:
+            update_check_run(
+                repo_full_name, token, run_id, conclusion="cancelled", summary=summary, name=name
+            )
+            closed += 1
+        except WebhookError:
+            continue  # someone else's run of the same name, or already completed underneath us
+    return closed
+
+
 def find_open_pr_by_marker(repo_full_name: str, token: str, marker: str, *, max_pages: int = 3,
                            open_only: bool = False) -> str | None:
     """Return the html_url of an existing PR whose body carries ``marker``, else None.

{codna-0.2.18 → codna-0.2.20}/codna/webhook_worker.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 import os
 import socket
+import signal
 import subprocess
 import tempfile
 import threading
@@ -39,6 +40,46 @@ from .webhook import WebhookError, WebhookJob, codna_command, webhook_marker
 from .webhook_queue import _MAX_ATTEMPTS, QueuedJob, WebhookQueue
 
 _JOB_TIMEOUT_S = int(os.environ.get("CODNA_WEBHOOK_JOB_TIMEOUT_S", "3600"))
+# After the timeout the WHOLE process group is killed and the pipe drain is capped at this. Plain
+# subprocess.run() kills only the direct child, so a grandchild still holding stdout/stderr (a
+# `git clone` remote helper, a test runner) kept communicate() blocked for as long as it lived --
+# the thread stayed alive (so /ready stayed green) while processing nothing. Both worker threads
+# wedged that way on 2026-09-17 and every review and fix went silent for hours.
+_KILL_DRAIN_S = 15
+
+
+def _kill_process_group(proc: subprocess.Popen) -> None:
+    try:
+        os.killpg(proc.pid, signal.SIGKILL)  # start_new_session=True makes pid == pgid
+    except (ProcessLookupError, PermissionError, OSError):
+        proc.kill()
+
+
+def _run_job_process(argv: list[str], *, env: dict[str, str] | None, cwd: str | None,
+                     timeout: float | None = None) -> subprocess.CompletedProcess:
+    """subprocess.run(capture_output=True, timeout=...) with a bounded worst case: on timeout the
+    process group dies and the drain itself is capped, so a wedged job costs a worker thread at most
+    timeout + _KILL_DRAIN_S. Raises TimeoutExpired exactly like subprocess.run does."""
+    bound = _JOB_TIMEOUT_S if timeout is None else timeout
+    proc = subprocess.Popen(argv, env=env, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                            text=True, start_new_session=True)
+    try:
+        stdout, stderr = proc.communicate(timeout=bound)
+    except subprocess.TimeoutExpired:
+        _kill_process_group(proc)
+        try:
+            stdout, stderr = proc.communicate(timeout=_KILL_DRAIN_S)
+        except subprocess.TimeoutExpired:
+            for stream in (proc.stdout, proc.stderr):
+                if stream is not None:
+                    stream.close()
+            stdout, stderr = "", ""
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass
+        raise subprocess.TimeoutExpired(argv, bound, output=stdout, stderr=stderr)
+    return subprocess.CompletedProcess(argv, proc.returncode, stdout, stderr)
 
 # Raw LLM provider keys are NEVER INHERITED from the webhook's own ambient host env — the
 # webhook is keyless. Exclude them from the allowlist below; the one job-specific provider key
@@ -203,6 +244,65 @@ def _job_env(
     return env
 
 
+def _review_job_summary(stdout: str) -> str | None:
+    """A short, markdown-safe summary for a review job's wrapper Check Run.
+
+    ``codna review ... --json`` (the only command codna_command adds ``--json`` to) prints a
+    findings-review result dict as its ENTIRE stdout -- the same shape
+    ``cli/codna/review.py::render_findings`` renders for a human. That renderer is for a
+    terminal, though: several of its lines are indented 4+ spaces, which GitHub's markdown
+    turns into a code block rather than the intended text, so it is deliberately not reused
+    here. Returns None (never raises) on anything that isn't exactly this shape, so the caller
+    falls back to its existing raw-stdout-tail behavior instead of guessing.
+    """
+    try:
+        result = json.loads(stdout)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return None
+    if not isinstance(result, dict) or "conclusion" not in result or "findings" not in result:
+        return None
+    findings = result.get("findings") or []
+    if not findings:
+        note = result.get("note")
+        return f"codna review: {note}" if note else "codna review: no high-confidence issues found ✅"
+    posted = result.get("posted") or {}
+    inline = posted.get("inline_posted", 0)
+    summary_n = result.get("summary_count", 0)
+    return (
+        f"codna review: {len(findings)} finding(s) — {inline} inline, {summary_n} in summary "
+        f"(conclusion: {result.get('conclusion', 'unknown')}). See the **Codna Review** check "
+        "and the PR's review comments for details."
+    )
+
+
+def _error_json_summary(kind: str, *streams: str | None) -> str | None:
+    """Short, markdown-safe summary when the CLI ended with its documented structured error.
+
+    ``codna`` prints ``{"error": {"code": ..., "message": ...}}`` (indent=2) to stderr on every
+    CodnaError (cli.py), and the generic tail-of-output fallback pasted that JSON verbatim into
+    the "codna fix" Check Run summary -- two algenta runs on 2026-09-17 read exactly like that.
+    Finds the LAST such object across the given streams (stderr is searched first by passing it
+    last) and renders its message as one sentence. None when there is no such object.
+    """
+    decoder = json.JSONDecoder()
+    for text in reversed([s or "" for s in streams]):
+        pos = text.rfind('"error"')
+        while pos >= 0:
+            start = text.rfind("{", 0, pos)
+            if start < 0:
+                break
+            try:
+                obj, _ = decoder.raw_decode(text[start:])
+            except ValueError:
+                obj = None
+            err = obj.get("error") if isinstance(obj, dict) else None
+            if isinstance(err, dict) and err.get("message"):
+                code = err.get("code") or "error"
+                return f"codna {kind} failed ({code}): {str(err['message'])[:400]}"
+            pos = text.rfind('"error"', 0, pos)
+    return None
+
+
 def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
                   provider: str | None = None, provider_key: str | None = None,
                   codna_bin: str = "codna") -> JobResult:
@@ -245,13 +345,29 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
             argv = codna_command(job)
         argv[0] = codna_bin
         try:
-            proc = subprocess.run(
+            proc = _run_job_process(
                 argv, env=_job_env(token, engine_key, provider, provider_key, tmp=tmp), cwd=tmp,
-                capture_output=True, text=True, timeout=_JOB_TIMEOUT_S,
-                start_new_session=True,  # own process group: isolated from signals, terminable as a unit
             )
         except subprocess.TimeoutExpired:
             return JobResult(False, f"codna {job.kind} timed out after {_JOB_TIMEOUT_S}s")
+        if job.kind == "review":
+            # `codna review ... --json` (codna_command's only caller of --json) prints ONE pure
+            # JSON object to stdout for the caller (review_github.py's own posting logic) to
+            # consume -- capture_output means it's also sitting right here in proc.stdout. The
+            # generic tail-of-stdout fallback below would dump that raw JSON as THIS wrapper
+            # check-run's summary verbatim: an unreadable wall of braces where a human expects a
+            # sentence. The detailed, well-formatted findings already live on the "Codna Review"
+            # check this same subprocess posts (review_github.py::summary_body) and as inline PR
+            # comments; this wrapper only needs to say the job completed and point there.
+            summary = _review_job_summary(proc.stdout)
+            if summary is not None:
+                return JobResult(proc.returncode == 0, summary)
+        if proc.returncode != 0:
+            # Every CodnaError leaves the CLI's structured `{"error": {...}}` on stderr; say its
+            # message as a sentence instead of pasting the braces into the Check Run summary.
+            summary = _error_json_summary(job.kind, proc.stdout, proc.stderr)
+            if summary is not None:
+                return JobResult(False, summary)
         tail = (proc.stdout or "")[-1500:] + (("\n" + proc.stderr[-500:]) if proc.stderr else "")
         return JobResult(proc.returncode == 0, tail.strip() or f"codna {job.kind} exit {proc.returncode}")
 
@@ -400,10 +516,23 @@ def process_job(
 
     check_id = None
     if token and job.ref:
+        # A retry (recover_stale after a restart, or attempt 2/3 after a crash) must supersede the
+        # run its predecessor left "in progress" on this commit -- only this App can complete it,
+        # so otherwise it spins forever next to the new one (thyn-ai/algenta@cc26ddd6 `codna fix`,
+        # in_progress from 2026-09-17 04:49 onward). Opportunistic: a client without the helper
+        # (older fakes, other implementations) just skips it.
+        complete_stale = getattr(github, "complete_stale_check_runs", None)
+        if callable(complete_stale):
+            complete_stale(
+                job.repo_full_name, token, head_sha=job.ref, name=f"codna {job.kind}",
+                summary=f"codna {job.kind}: an earlier attempt was interrupted (worker restart); "
+                        f"superseded by a new run ({job.reason}).",
+            )
         check_id = github.create_check_run(
             job.repo_full_name, token, name=f"codna {job.kind}", head_sha=job.ref,
             summary=f"codna {job.kind} started ({job.reason})",
         )
+    _log_worker_phase(qjob, "runner_start")  # everything before this is token/metering/prepare/ack
     try:
         result = runner(job, token=token, engine_key=engine_key, provider=provider, provider_key=provider_key)
     except Exception as exc:  # noqa: BLE001 — a check-run this function opened must always be
@@ -413,6 +542,7 @@ def process_job(
         # the exact bug behind codna-app-smoke's check-suite, stuck since 2026-07-08. Never surface
         # the raw exception text here (could embed argv/path/token content); the class name is safe.
         result = JobResult(False, f"codna {job.kind} crashed unexpectedly ({type(exc).__name__})")
+    _log_worker_phase(qjob, "runner_done")
     if check_id and token:
         github.update_check_run(
             job.repo_full_name, token, check_id,
@@ -518,6 +648,20 @@ def _log_worker_failure(qjob: QueuedJob, *, code: str, message: str) -> None:
     print(json.dumps(payload, sort_keys=True), file=sys.stderr, flush=True)
 
 
+def _log_worker_phase(qjob: QueuedJob, phase: str) -> None:
+    """One stderr JSON line per job phase, so a stalled job is locatable from `fly logs`.
+
+    Until now a job only ever logged its FAILURE. A job that wedged (or was killed) between claim
+    and its first visible action left no trace at all: on 2026-09-17 two `@codna fix` jobs sat
+    silent for hours with `/ready` green, and there was nothing to grep for. `event` differs from
+    the failure line's so the two never get confused in a filter.
+    """
+    payload = _job_log_context(qjob)
+    payload["event"] = "job_phase"
+    payload["phase"] = phase
+    print(json.dumps(payload, sort_keys=True), file=sys.stderr, flush=True)
+
+
 class WorkerPool:
     def __init__(self, queue: WebhookQueue, *, concurrency: int = 2, poll_interval: float = 1.0,
                  app_id: str | None = None, private_key: str | None = None,
@@ -533,6 +677,8 @@ class WorkerPool:
         self._process = process or self._default_process
         self._stop = threading.Event()
         self._threads: list[threading.Thread] = []
+        self._busy_lock = threading.Lock()
+        self._busy_since: dict[str, float] = {}  # thread name -> monotonic start of its current job
 
     def _default_process(self, qjob: QueuedJob) -> JobResult:
         return process_job(qjob, app_id=self._app_id, private_key=self._private_key)
@@ -574,10 +720,22 @@ class WorkerPool:
                 admitter.finish(time.monotonic() - slot_started if qjob is not None else 0.0)
 
     def _run_claimed(self, qjob: QueuedJob) -> None:
+        me = threading.current_thread().name
+        with self._busy_lock:
+            self._busy_since[me] = time.monotonic()
+        try:
+            self._run_claimed_inner(qjob)
+        finally:
+            with self._busy_lock:
+                self._busy_since.pop(me, None)
+
+    def _run_claimed_inner(self, qjob: QueuedJob) -> None:
         """Process one claimed job and mark its queue row terminal. A worker must never die on one
         bad job, so every outcome ends in complete()."""
         try:
+            _log_worker_phase(qjob, "claimed")
             result = self._process(qjob)
+            _log_worker_phase(qjob, "done" if result.ok else "failed")
             if not result.ok:
                 _log_worker_failure(qjob, code="job_failed", message=result.summary)
             self._queue.complete(qjob.row_id, status="done" if result.ok else "failed",
@@ -585,9 +743,49 @@ class WorkerPool:
         except WebhookError as exc:
             _log_worker_failure(qjob, code=exc.code, message=str(exc))
             self._queue.complete(qjob.row_id, status="failed", result={"error": exc.code, "message": str(exc)})
+            self._notify_terminal_comment_fix_failure(qjob, exc.code)
         except Exception as exc:  # noqa: BLE001 — a worker must never die on one bad job
             _log_worker_failure(qjob, code="job_crashed", message=str(exc))
             self._queue.complete(qjob.row_id, status="failed", result={"error": "job_crashed", "message": str(exc)[:500]})
+            self._notify_terminal_comment_fix_failure(qjob, "job_crashed")
+
+    def _notify_terminal_comment_fix_failure(self, qjob: QueuedJob, code: str) -> None:
+        """Keep the "a comment trigger never goes silent" promise when process_job itself RAISES.
+
+        process_job replies in-thread on every outcome it can reach -- but a WebhookError raised
+        before its first reply (token minting is the usual one) unwinds straight to _run_claimed,
+        and the retry loop then burns the remaining attempts the same way, in seconds, with the
+        only trace a stderr JSON line. From the requester's side that is exactly the silence
+        observed on 2026-09-17: `@codna fix` replies with no ack, no check, no PR, no error. On
+        the LAST attempt only, tell the thread what happened. Best-effort: a token is minted if
+        possible (the failure may be precisely that), else GITHUB_TOKEN is tried; never raises.
+        """
+        job = qjob.job
+        ctx = job.context or {}
+        if job.kind != "fix" or not isinstance(ctx.get("in_reply_to_id"), int) or not job.pr_number:
+            return
+        if qjob.attempts < _MAX_ATTEMPTS:
+            return
+        token: str | None = None
+        try:
+            if job.installation_id and self._app_id and self._private_key:
+                token = webhook_github.installation_token(
+                    self._app_id, self._private_key, job.installation_id,
+                    repo_full_name=job.repo_full_name, kind="review",  # read+comment scope suffices
+                )
+        except Exception:  # noqa: BLE001 — minting may be the very failure being reported
+            token = None
+        token = token or os.environ.get("GITHUB_TOKEN")
+        if not token:
+            return
+        body = (f"⚠️ Codna couldn't process this `@codna fix` request ({code}) after "
+                f"{qjob.attempts} attempt(s). The worker logged the details; nothing was pushed or opened.")
+        try:
+            webhook_github.post_review_comment_reply(
+                job.repo_full_name, token, job.pr_number, ctx["in_reply_to_id"], body
+            )
+        except Exception:  # noqa: BLE001 — never let the notification take the worker down
+            return
 
     def start(self) -> None:
         self._queue.recover_stale()
@@ -598,11 +796,21 @@ class WorkerPool:
 
     def diagnostics(self) -> dict[str, Any]:
         alive = sum(1 for thread in self._threads if thread.is_alive())
+        now = time.monotonic()
+        with self._busy_lock:
+            running_for = [now - since for since in self._busy_since.values()]
+        longest = max(running_for, default=0.0)
+        # An alive thread is not a working thread: one sitting on a single job past the bound
+        # _run_job_process enforces (plus slack) is wedged, and /ready must say so rather than
+        # report a healthy pool that processes nothing.
+        wedged = longest > _JOB_TIMEOUT_S + _KILL_DRAIN_S + 60
         diag: dict[str, Any] = {
             "configured_threads": self._concurrency,
             "started_threads": len(self._threads),
             "alive_threads": alive,
-            "ready": alive >= self._concurrency,
+            "busy_threads": len(running_for),
+            "longest_running_s": round(longest, 1),
+            "ready": alive >= self._concurrency and not wedged,
         }
         # Admission state: threads are only the claimer ceiling, so "alive_threads" alone no longer
         # describes capacity. Surface what the admitter actually decided on (in-flight, how many

{codna-0.2.18 → codna-0.2.20}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.18
+Version: 0.2.20
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.18 → codna-0.2.20}/codna.egg-info/SOURCES.txt

@@ -121,6 +121,7 @@ tests/test_evasion.py
 tests/test_evidence.py
 tests/test_evidence_io.py
 tests/test_extract_nul.py
+tests/test_fix_inputs_remote.py
 tests/test_fix_run.py
 tests/test_gate.py
 tests/test_gitpush.py

{codna-0.2.18 → codna-0.2.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.18"
+version = "0.2.20"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

codna-0.2.20/tests/test_fix_inputs_remote.py

@@ -0,0 +1,88 @@
+"""`codna fix --tests` remote discovery: the clone must be shallow and get a size-scaled timeout.
+
+Regression guard for a live failure (thyn-ai/algenta, 2026-09-17): with a ref given, the clone ran
+WITHOUT --depth=1 (full history) under a flat 120 s timeout and timed out on every attempt, so no
+CI-failure autofix on that repo ever got as far as discovering a test.
+"""
+
+from __future__ import annotations
+
+import types
+
+from codna import fix_inputs
+
+
+def _capture(monkeypatch):
+    calls = []
+
+    def fake_run(args, *, cwd, env, timeout=fix_inputs._REMOTE_GIT_TIMEOUT_S):
+        calls.append({"args": list(args), "timeout": timeout})
+
+    monkeypatch.setattr(fix_inputs, "_run_git_for_remote_tests", fake_run)
+    monkeypatch.setattr(
+        fix_inputs,
+        "_checkout_remote_ref",
+        lambda *a, **k: calls.append({"checkout_ref": a[1]}),
+    )
+    monkeypatch.setattr(
+        fix_inputs,
+        "_discover_failing_tests_for_fix",
+        lambda checkout, test_cmd: ("issue", []),
+    )
+    monkeypatch.setattr(
+        "codna.packaged_git._git_auth_env",
+        lambda url, token: {"GIT_TERMINAL_PROMPT": "0"},
+    )
+    monkeypatch.setattr(
+        "codna.packaged_git._reject_embedded_credentials", lambda url: None
+    )
+    return calls
+
+
+def _args(**over):
+    base = {
+        "repo": "https://github.com/acme/app.git",
+        "ref": None,
+        "base_branch": None,
+        "test_cmd": None,
+    }
+    base.update(over)
+    return types.SimpleNamespace(**base)
+
+
+def test_clone_is_shallow_even_when_a_ref_is_given(monkeypatch):
+    calls = _capture(monkeypatch)
+    fix_inputs._discover_remote_failing_tests_for_fix(
+        _args(ref="cc26ddd6"), github_token="t"
+    )
+    clone = calls[0]["args"]
+    assert clone[0] == "clone" and "--depth=1" in clone, clone
+    # the exact ref is still checked out afterwards (shallow fetch lives in _checkout_remote_ref)
+    assert {"checkout_ref": "cc26ddd6"} in calls
+
+
+def test_clone_gets_the_size_scaled_timeout_not_the_flat_git_default(monkeypatch):
+    calls = _capture(monkeypatch)
+    fix_inputs._discover_remote_failing_tests_for_fix(
+        _args(ref="cc26ddd6"), github_token="t"
+    )
+    assert calls[0]["timeout"] == fix_inputs._REMOTE_CLONE_TIMEOUT_S
+    assert fix_inputs._REMOTE_CLONE_TIMEOUT_S > fix_inputs._REMOTE_GIT_TIMEOUT_S
+
+
+def test_single_branch_narrowing_only_applies_without_a_ref(monkeypatch):
+    calls = _capture(monkeypatch)
+    fix_inputs._discover_remote_failing_tests_for_fix(
+        _args(base_branch="main"), github_token="t"
+    )
+    assert ["--single-branch", "--branch", "main"] == [
+        a for a in calls[0]["args"] if a in ("--single-branch", "--branch", "main")
+    ]
+    calls.clear()
+    fix_inputs._discover_remote_failing_tests_for_fix(
+        _args(ref="abc123", base_branch="main"), github_token="t"
+    )
+    assert (
+        "--single-branch" not in calls[0]["args"]
+    )  # the ref, not the branch tip, is what gets checked out
+    assert "--depth=1" in calls[0]["args"]

{codna-0.2.18 → codna-0.2.20}/tests/test_webhook_github.py

@@ -139,6 +139,58 @@ def test_fetch_issue_text_falls_back_to_title_only_when_body_is_empty(monkeypatc
     assert fetch_issue_text("acme/app", "token", 12) == "Login crashes"
 
 
+# --- complete_stale_check_runs: a retry supersedes a dead in_progress run --------------------------
+# Only the App that created a Check Run can complete it; a run abandoned by a redeploy therefore spins
+# forever (thyn-ai/algenta@cc26ddd6 `codna fix`, in_progress from 2026-09-17 04:49 onward) unless the
+# next attempt closes it first.
+def _stale_httpx(get_status=200, runs=({"id": 11}, {"id": 12}), patch_fail_ids=()):
+    seen = {"get": None, "patched": []}
+
+    class GetResp:
+        status_code = get_status
+
+        @staticmethod
+        def json():
+            return {"check_runs": list(runs)}
+
+    def get(url, *, headers, params, timeout, follow_redirects):
+        seen["get"] = {"url": url, "params": params}
+        return GetResp()
+
+    def patch(url, *, headers, json, timeout, follow_redirects):
+        run_id = int(url.rsplit("/", 1)[-1])
+        seen["patched"].append((run_id, json["conclusion"], json["output"]["summary"]))
+        return SimpleNamespace(status_code=403 if run_id in patch_fail_ids else 200, text="nope")
+
+    return SimpleNamespace(get=get, patch=patch), seen
+
+
+def test_complete_stale_check_runs_cancels_every_in_progress_run_of_that_name(monkeypatch):
+    from codna.webhook_github import complete_stale_check_runs
+
+    fake, seen = _stale_httpx()
+    monkeypatch.setitem(sys.modules, "httpx", fake)
+    n = complete_stale_check_runs("acme/app", "token", head_sha="sha1", name="codna fix", summary="superseded")
+    assert n == 2
+    assert seen["get"]["url"].endswith("/repos/acme/app/commits/sha1/check-runs")
+    assert seen["get"]["params"] == {"check_name": "codna fix", "status": "in_progress", "per_page": 50}
+    assert seen["patched"] == [(11, "cancelled", "superseded"), (12, "cancelled", "superseded")]
+
+
+def test_complete_stale_check_runs_is_best_effort_never_raises(monkeypatch):
+    from codna.webhook_github import complete_stale_check_runs
+
+    # listing fails -> nothing to do, no exception
+    fake, _ = _stale_httpx(get_status=500)
+    monkeypatch.setitem(sys.modules, "httpx", fake)
+    assert complete_stale_check_runs("acme/app", "token", head_sha="sha1", name="codna fix", summary="s") == 0
+    # one PATCH is refused (someone else's run of the same name): skip it, still close the other
+    fake, seen = _stale_httpx(patch_fail_ids=(11,))
+    monkeypatch.setitem(sys.modules, "httpx", fake)
+    assert complete_stale_check_runs("acme/app", "token", head_sha="sha1", name="codna fix", summary="s") == 1
+    assert [p[0] for p in seen["patched"]] == [11, 12]
+
+
 def test_fetch_issue_text_none_on_api_failure(monkeypatch):
     class Response:
         status_code = 404