codna 0.2.26__tar.gz → 0.2.28__tar.gz

{codna-0.2.26 → codna-0.2.28}/PKG-INFO

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

{codna-0.2.26 → codna-0.2.28}/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.26"
+__version__ = "0.2.28"

{codna-0.2.26 → codna-0.2.28}/codna/packaged_git.py

@@ -92,7 +92,7 @@ def open_remote_pr(
     _apply_patch_to_index(repo_root, patch_diff)
     _run_git(
         repo_root,
-        ["-c", "user.email=codna@codna.ai", "-c", "user.name=codna", "commit", "-m", title],
+        [*_git_identity_args(), "commit", "-m", title],
     )
     try:
         _run_git(
@@ -398,6 +398,20 @@ def _git_auth_env(repository_url: str, token: str | None) -> dict[str, str] | No
     return env
 
 
+# The webhook worker sets these to the GitHub App's bot identity ("<slug>[bot]",
+# "<id>+<slug>[bot]@users.noreply.github.com") so fix commits resolve to a real GitHub account.
+# A CLA bot on thyn-ai/algenta-integrations#80 (2026-09-17) rejected "codna <codna@codna.ai>"
+# with "codna seems not to be a GitHub user"; the bot login is what CLA allowlists can name.
+DEFAULT_GIT_USER_NAME = "codna"
+DEFAULT_GIT_USER_EMAIL = "codna@codna.ai"
+
+
+def _git_identity_args() -> list[str]:
+    name = os.environ.get("CODNA_GIT_USER_NAME") or DEFAULT_GIT_USER_NAME
+    email = os.environ.get("CODNA_GIT_USER_EMAIL") or DEFAULT_GIT_USER_EMAIL
+    return ["-c", f"user.email={email}", "-c", f"user.name={name}"]
+
+
 def _run_git(
     cwd: Path | None,
     args: list[str],

{codna-0.2.26 → codna-0.2.28}/codna/packaged_repository_advanced.py

@@ -10,7 +10,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Mapping
 
-from .packaged_git import open_remote_pr
+from .packaged_git import _git_identity_args, open_remote_pr
 from .patch_text import GIT_APPLY_FLAG_SETS, normalize_unified_diff
 
 SCHEMA_VERSION = 1
@@ -710,10 +710,7 @@ def _commit_applied_patch(repo_root: Path, plan_id: str, changed_files: list[str
     _run_git(
         repo_root,
         [
-            "-c",
-            "user.name=Codna",
-            "-c",
-            "user.email=codna@example.invalid",
+            *_git_identity_args(),
             "commit",
             "--no-gpg-sign",
             "-m",
@@ -740,7 +737,7 @@ def _conflicting_untracked_files(repo_root: Path, patch_targets: set[str]) -> li
     return conflicts
 
 
-def _run_git(repo_root: Path, args: list[str]) -> subprocess.CompletedProcess:
+def _run_git(repo_root: Path, args: list[str], *, check: bool = True) -> subprocess.CompletedProcess:
     result = subprocess.run(
         ["git", "-C", str(repo_root), *args],
         capture_output=True,
@@ -748,7 +745,7 @@ def _run_git(repo_root: Path, args: list[str]) -> subprocess.CompletedProcess:
         check=False,
         timeout=60,
     )
-    if result.returncode != 0:
+    if check and result.returncode != 0:
         raise PackagedRepositoryAdvancedError(
             "git_command_failed",
             "Git command failed while applying the packaged local patch.",

{codna-0.2.26 → codna-0.2.28}/codna/review.py

@@ -9,6 +9,7 @@ triage (suspect files/symbols + context reduction).
 from __future__ import annotations
 
 import os
+import shutil
 import subprocess
 
 
@@ -166,6 +167,7 @@ def run_findings_review(args) -> dict:
     token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
              or os.environ.get("GITHUB_TOKEN"))
     pr = getattr(args, "pr", None)
+    materialized: str | None = None  # the clone this call made and must remove
 
     if _is_git_url(str(args.repo)):
         # Remote review (webhook / CI): needs a PR to materialize the diff. The repo slug ALWAYS comes
@@ -198,6 +200,7 @@ def run_findings_review(args) -> dict:
                 str(args.repo), pr_number, meta["base_ref"], token, incremental_base=incremental_base)
         except Exception as exc:  # noqa: BLE001
             _fail(f"could not materialize PR #{pr_number}: {exc}")
+        materialized = local
         base = None
     else:
         local = os.path.abspath(os.path.expanduser(args.repo))
@@ -209,36 +212,43 @@ def run_findings_review(args) -> dict:
                 _fail(f"--pr {pr!r}: could not resolve owner/repo#number (pass owner/repo#123 or a PR URL).")
 
     try:
-        cfg = _config_overrides(args, rf.load_review_config(local))
-    except Exception as exc:  # noqa: BLE001 — malformed config fails closed with a clear message
-        _fail(f"review config error: {exc}")
+        try:
+            cfg = _config_overrides(args, rf.load_review_config(local))
+        except Exception as exc:  # noqa: BLE001 — malformed config fails closed with a clear message
+            _fail(f"review config error: {exc}")
 
-    guidance = read_project_guidance(local)
-    try:
-        result = rf.run_diff_review(
-            local, repository=args.repo, diff_range=diff_range, base=base, config=cfg,
-            guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
-            model=getattr(args, "model", None) or None,
-        )
-    except Exception as exc:  # noqa: BLE001 - agent/runtime failures must not leak tracebacks.
-        # Carry the wrapped error's own fields through. Not leaking a traceback is the rule;
-        # discarding the structured detail alongside it was an accident, and it is what left
-        # every agent-core failure reported as one sentence and an empty object.
-        _fail(f"review agent failed: {exc}", _wrapped_details(exc))
-    out = result.to_dict()
-
-    if getattr(args, "post", False):
-        token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
-                 or os.environ.get("GITHUB_TOKEN"))
-        if not (repo_slug and pr_number):
-            _fail("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
-        if not token:
-            _fail("--post needs a write token: pass --github-token or set GITHUB_TOKEN.")
+        guidance = read_project_guidance(local)
         try:
-            out["posted"] = rg.post_review(result, repo_slug=repo_slug, pr_number=pr_number, token=token)
-        except Exception as exc:  # noqa: BLE001
-            _fail(f"posting the review failed: {exc}")
-    return out
+            result = rf.run_diff_review(
+                local, repository=args.repo, diff_range=diff_range, base=base, config=cfg,
+                guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
+                model=getattr(args, "model", None) or None,
+            )
+        except Exception as exc:  # noqa: BLE001 - agent/runtime failures must not leak tracebacks.
+            # Carry the wrapped error's own fields through. Not leaking a traceback is the rule;
+            # discarding the structured detail alongside it was an accident, and it is what left
+            # every agent-core failure reported as one sentence and an empty object.
+            _fail(f"review agent failed: {exc}", _wrapped_details(exc))
+        out = result.to_dict()
+
+        if getattr(args, "post", False):
+            token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
+                     or os.environ.get("GITHUB_TOKEN"))
+            if not (repo_slug and pr_number):
+                _fail("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
+            if not token:
+                _fail("--post needs a write token: pass --github-token or set GITHUB_TOKEN.")
+            try:
+                out["posted"] = rg.post_review(result, repo_slug=repo_slug, pr_number=pr_number, token=token)
+            except Exception as exc:  # noqa: BLE001
+                _fail(f"posting the review failed: {exc}")
+        return out
+    finally:
+        if materialized is not None:
+            # The clone lives in the process's temp dir, NOT in a per-call scratch dir. Without
+            # this, every remote review left a full checkout behind on the webhook machine until
+            # its root filesystem filled and reviews died with ENOSPC (thyn-ai/algenta#1023).
+            shutil.rmtree(materialized, ignore_errors=True)
 
 
 def dispatch(args, make_client) -> int:

{codna-0.2.26 → codna-0.2.28}/codna/webhook_github.py

@@ -261,6 +261,41 @@ def find_open_pr_by_marker(repo_full_name: str, token: str, marker: str, *, max_
     return None
 
 
+_BOT_IDENTITY: dict[str, tuple[str, str]] = {}
+
+
+def app_bot_identity(app_id: str | None, private_key_pem: str | None) -> tuple[str, str] | None:
+    """(git user.name, git user.email) for this App's bot account, e.g.
+    ("codna-ai[bot]", "293953567+codna-ai[bot]@users.noreply.github.com") -- the identity GitHub
+    links to the App, so its commits resolve to a real account and CLA bots can allowlist it.
+    Memoized per process; None when it cannot be resolved (caller keeps the default identity)."""
+    if not (app_id and private_key_pem):
+        return None
+    if str(app_id) in _BOT_IDENTITY:
+        return _BOT_IDENTITY[str(app_id)]
+    try:
+        import time as _time
+
+        import httpx
+
+        jwt = _app_jwt(str(app_id), private_key_pem, now=int(_time.time()))
+        app = httpx.get(f"{_API}/app", headers={"Authorization": f"Bearer {jwt}", "Accept": "application/vnd.github+json"},
+                        timeout=30.0, follow_redirects=True)
+        slug = (app.json() or {}).get("slug") if app.status_code < 300 else None
+        if not slug:
+            return None
+        user = httpx.get(f"{_API}/users/{slug}%5Bbot%5D", headers={"Accept": "application/vnd.github+json"},
+                         timeout=30.0, follow_redirects=True)
+        bot_id = (user.json() or {}).get("id") if user.status_code < 300 else None
+        if not bot_id:
+            return None
+    except Exception:  # noqa: BLE001 — identity is a nicety; never fail a job over it
+        return None
+    identity = (f"{slug}[bot]", f"{bot_id}+{slug}[bot]@users.noreply.github.com")
+    _BOT_IDENTITY[str(app_id)] = identity
+    return identity
+
+
 def installation_has_workflows(installation_id: int | str | None) -> bool | None:
     """What the last fix-token mint learned about the `workflows` permission on this installation:
     True / False, or None when no fix token has been minted in this process yet."""

codna-0.2.28/codna/webhook_procs.py

@@ -0,0 +1,168 @@
+"""Process control for webhook jobs: run the codna CLI under a hard bound, kill its whole process
+group on timeout, and tear down the detached runtime each job leaves behind. Split out of
+webhook_worker.py (modularity ceiling); the worker re-exports these names."""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# 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
+) -> 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 = 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)
+
+
+_PID_KEYS = frozenset({"pid", "listener_pid", "supervisor_pid"})
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def _pids_from_state_files(runtime_root: Path) -> set[int]:
+    """Every pid recorded in the runtime's own state files (local-stack.json, local-agent-core.json,
+    launcher state): the format is theirs, so walk any JSON under the root for pid-like keys."""
+    pids: set[int] = set()
+    if not runtime_root.is_dir():
+        return pids
+    for path in runtime_root.rglob("*"):
+        if not path.is_file() or path.suffix not in {".json", ".state"}:
+            continue
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:  # noqa: BLE001 — not JSON, or being written right now
+            continue
+        stack = [data]
+        while stack:
+            node = stack.pop()
+            if isinstance(node, dict):
+                for key, value in node.items():
+                    if key in _PID_KEYS and isinstance(value, int) and value > 1:
+                        pids.add(value)
+                    elif isinstance(value, (dict, list)):
+                        stack.append(value)
+            elif isinstance(node, list):
+                stack.extend(node)
+    return pids
+
+
+def _pids_with_runtime_root(runtime_root: Path) -> set[int]:
+    """Linux: every process whose environment carries this job's CODNA_RUNTIME_ROOT -- the
+    detached daemons inherit it, so this finds them even if a state file was never written."""
+    needle = f"CODNA_RUNTIME_ROOT={runtime_root}".encode()
+    pids: set[int] = set()
+    proc_dir = Path("/proc")
+    if not proc_dir.is_dir():
+        return pids
+    for entry in proc_dir.iterdir():
+        if not entry.name.isdigit():
+            continue
+        try:
+            environ = (entry / "environ").read_bytes()
+        except OSError:
+            continue
+        if needle in environ.split(b"\0"):
+            pids.add(int(entry.name))
+    return pids
+
+
+def _teardown_job_runtime(tmp: str) -> int:
+    """Stop every detached process a job's codna run left behind.
+
+    codna starts its agent-core sidecar, engine and local stack with start_new_session=True, so
+    killing the CLI's process group never reaches them, and nothing else stops them once the CLI
+    exits -- each job leaked a Bun sidecar plus engine on the 2 GB machine. Eight reviews in eight
+    minutes were enough on 2026-09-17: the ninth failed with "agent-core failed while waiting for
+    sidecar readiness" and the machine never recovered until a restart. Returns how many pids
+    were signalled. Never raises.
+    """
+    root = Path(tmp) / ".codna-runtime"
+    try:
+        pids = _pids_from_state_files(root) | _pids_with_runtime_root(root)
+    except Exception:  # noqa: BLE001
+        return 0
+    pids.discard(os.getpid())
+    for pid in pids:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except (ProcessLookupError, PermissionError):
+            pass
+    deadline = time.monotonic() + 5
+    while time.monotonic() < deadline and any(_pid_alive(p) for p in pids):
+        time.sleep(0.1)
+    for pid in pids:
+        if _pid_alive(pid):
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except (ProcessLookupError, PermissionError):
+                pass
+    if pids:
+        print(
+            json.dumps(
+                {
+                    "service": "codna-webhook-worker",
+                    "event": "runtime_teardown",
+                    "pids": sorted(pids),
+                },
+                sort_keys=True,
+            ),
+            file=sys.stderr,
+            flush=True,
+        )
+    return len(pids)

{codna-0.2.26 → codna-0.2.28}/codna/webhook_worker.py

@@ -20,16 +20,15 @@ fakes and no network.
 """
 from __future__ import annotations
 
+import json
 import os
 import re
 import socket
-import signal
 import subprocess
+import sys
 import tempfile
 import threading
 import time
-import sys
-import json
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable
@@ -37,146 +36,26 @@ from typing import Any, Callable
 from . import webhook_github, webhook_metering
 from .admission_control import get_admitter
 from .agent_core_runtime import PROVIDER_RUNTIME_ENV_KEYS
-from .webhook import _FIX_WRITE_ASSOCIATIONS, WebhookError, WebhookJob, codna_command, webhook_marker
+from .webhook import (
+    _FIX_WRITE_ASSOCIATIONS,
+    WebhookError,
+    WebhookJob,
+    codna_command,
+    webhook_marker,
+)
 from .webhook_queue import _MAX_ATTEMPTS, QueuedJob, WebhookQueue
+from .webhook_procs import (  # noqa: F401 -- re-exported: tests and callers address them via this module
+    _KILL_DRAIN_S,
+    _kill_process_group,
+    _pid_alive,
+    _pids_from_state_files,
+    _pids_with_runtime_root,
+    _run_job_process,
+    _teardown_job_runtime,
+)
 
 _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)
-
 
-_PID_KEYS = frozenset({"pid", "listener_pid", "supervisor_pid"})
-
-
-def _pid_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    return True
-
-
-def _pids_from_state_files(runtime_root: Path) -> set[int]:
-    """Every pid recorded in the runtime's own state files (local-stack.json, local-agent-core.json,
-    launcher state): the format is theirs, so walk any JSON under the root for pid-like keys."""
-    pids: set[int] = set()
-    if not runtime_root.is_dir():
-        return pids
-    for path in runtime_root.rglob("*"):
-        if not path.is_file() or path.suffix not in {".json", ".state"}:
-            continue
-        try:
-            data = json.loads(path.read_text(encoding="utf-8"))
-        except Exception:  # noqa: BLE001 — not JSON, or being written right now
-            continue
-        stack = [data]
-        while stack:
-            node = stack.pop()
-            if isinstance(node, dict):
-                for key, value in node.items():
-                    if key in _PID_KEYS and isinstance(value, int) and value > 1:
-                        pids.add(value)
-                    elif isinstance(value, (dict, list)):
-                        stack.append(value)
-            elif isinstance(node, list):
-                stack.extend(node)
-    return pids
-
-
-def _pids_with_runtime_root(runtime_root: Path) -> set[int]:
-    """Linux: every process whose environment carries this job's CODNA_RUNTIME_ROOT -- the
-    detached daemons inherit it, so this finds them even if a state file was never written."""
-    needle = f"CODNA_RUNTIME_ROOT={runtime_root}".encode()
-    pids: set[int] = set()
-    proc_dir = Path("/proc")
-    if not proc_dir.is_dir():
-        return pids
-    for entry in proc_dir.iterdir():
-        if not entry.name.isdigit():
-            continue
-        try:
-            environ = (entry / "environ").read_bytes()
-        except OSError:
-            continue
-        if needle in environ.split(b"\0"):
-            pids.add(int(entry.name))
-    return pids
-
-
-def _teardown_job_runtime(tmp: str) -> int:
-    """Stop every detached process a job's codna run left behind.
-
-    codna starts its agent-core sidecar, engine and local stack with start_new_session=True, so
-    killing the CLI's process group never reaches them, and nothing else stops them once the CLI
-    exits -- each job leaked a Bun sidecar plus engine on the 2 GB machine. Eight reviews in eight
-    minutes were enough on 2026-09-17: the ninth failed with "agent-core failed while waiting for
-    sidecar readiness" and the machine never recovered until a restart. Returns how many pids
-    were signalled. Never raises.
-    """
-    root = Path(tmp) / ".codna-runtime"
-    try:
-        pids = _pids_from_state_files(root) | _pids_with_runtime_root(root)
-    except Exception:  # noqa: BLE001
-        return 0
-    pids.discard(os.getpid())
-    for pid in pids:
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except (ProcessLookupError, PermissionError):
-            pass
-    deadline = time.monotonic() + 5
-    while time.monotonic() < deadline and any(_pid_alive(p) for p in pids):
-        time.sleep(0.1)
-    for pid in pids:
-        if _pid_alive(pid):
-            try:
-                os.kill(pid, signal.SIGKILL)
-            except (ProcessLookupError, PermissionError):
-                pass
-    if pids:
-        print(json.dumps({"service": "codna-webhook-worker", "event": "runtime_teardown",
-                          "pids": sorted(pids)}, sort_keys=True), file=sys.stderr, flush=True)
-    return len(pids)
 
 # 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
@@ -411,7 +290,7 @@ def _isolated_runtime_env(tmp: str) -> dict[str, str]:
 def _job_env(
     token: str | None, engine_key: str | None,
     provider: str | None = None, provider_key: str | None = None,
-    *, tmp: str | None = None,
+    *, tmp: str | None = None, git_identity: tuple[str, str] | None = None,
 ) -> dict[str, str]:
     """Minimal allowlisted env + the scoped GitHub token, per-org Codna key, and (when the
     linked org has configured one) their own BYOK provider key — set consistently regardless of
@@ -423,6 +302,11 @@ def _job_env(
         # two keys -- inheriting the host's shared values here would silently defeat the whole
         # point (every job would still resolve to the one shared runtime this exists to avoid).
         env.update(_isolated_runtime_env(tmp))
+        # Every scratch dir the job's tools create (the review clone, secure-pr checkouts, junit
+        # files, agent-core temp) lands INSIDE the job dir and is deleted with it. The review
+        # clone used to land in the machine's shared /tmp and was never removed -- a ~0.5 GB
+        # leak per algenta review that filled the root fs (ENOSPC, thyn-ai/algenta#1023).
+        env["TMPDIR"] = env["TMP"] = env["TEMP"] = tmp
     if token:
         env["GITHUB_TOKEN"] = token
     if engine_key:
@@ -434,6 +318,9 @@ def _job_env(
         # default (anthropic) in packaged_agent_runner.py -- without this, an org's OpenAI/Google
         # key would be present but never selected, and the sidecar would still look for Anthropic.
         env["ALGENTA_AGENT_PROVIDER"] = provider
+    if git_identity:
+        # the App's bot account -- fix commits then resolve to a real GitHub identity
+        env["CODNA_GIT_USER_NAME"], env["CODNA_GIT_USER_EMAIL"] = git_identity
     return env
 
 
@@ -500,7 +387,7 @@ def _error_json_summary(kind: str, *streams: str | None) -> str | 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:
+                  codna_bin: str = "codna", git_identity: tuple[str, str] | None = None) -> JobResult:
     """Default runner: run packaged codna for the job in an isolated, scrubbed workspace."""
     ctx = job.context or {}
     if job.kind == "fix" and ctx.get("routing_error"):
@@ -542,7 +429,8 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
         try:
             try:
                 proc = _run_job_process(
-                    argv, env=_job_env(token, engine_key, provider, provider_key, tmp=tmp), cwd=tmp,
+                    argv, env=_job_env(token, engine_key, provider, provider_key, tmp=tmp, git_identity=git_identity),
+                    cwd=tmp, timeout=_JOB_TIMEOUT_S,
                 )
             except subprocess.TimeoutExpired:
                 return JobResult(False, f"codna {job.kind} timed out after {_JOB_TIMEOUT_S}s")
@@ -760,7 +648,10 @@ def process_job(
         )
     _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)
+        identity_fn = getattr(github, "app_bot_identity", None)
+        git_identity = identity_fn(app_id, private_key) if callable(identity_fn) else None
+        result = runner(job, token=token, engine_key=engine_key, provider=provider, provider_key=provider_key,
+                        git_identity=git_identity)
     except Exception as exc:  # noqa: BLE001 — a check-run this function opened must always be
         # completed, even on a crash the runner itself didn't turn into a JobResult (run_codna_job
         # only catches subprocess.TimeoutExpired). Without this, check_id is created above but

{codna-0.2.26 → codna-0.2.28}/codna.egg-info/PKG-INFO

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

{codna-0.2.26 → codna-0.2.28}/codna.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ codna/webhook.py
 codna/webhook_cli.py
 codna/webhook_github.py
 codna/webhook_metering.py
+codna/webhook_procs.py
 codna/webhook_queue.py
 codna/webhook_worker.py
 codna/worker.py

{codna-0.2.26 → codna-0.2.28}/pyproject.toml

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