codna 0.2.51__tar.gz → 0.2.53__tar.gz

{codna-0.2.51 → codna-0.2.53}/PKG-INFO

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

{codna-0.2.51 → codna-0.2.53}/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.51"
+__version__ = "0.2.53"

{codna-0.2.51 → codna-0.2.53}/codna/admission_control.py

@@ -158,12 +158,22 @@ def make_mojo_breach_fn(client: object | None = None, *, fallback: BreachFn = _n
 
     The fallback is logged ONCE per process. It used to be silent, which made the headline claim
     ("the compiled kernel decides") unfalsifiable: the kernel path was broken on every local call and
-    nothing said so — a green test suite proved only that *some* number came back."""
+    nothing said so — a green test suite proved only that *some* number came back.
+
+    Which branch answered is OBSERVABLE, not only logged. The returned callable carries
+    ``probe(durations, contention, sla, n) -> (probability, "mojo" | "numpy")`` — the branch name
+    travels with the value, so a caller sees per call what answered without a race; ``fallback``, the
+    predictor the fallback branch runs, so a caller that saw one fallback can stay on it instead of
+    paying for the kernel to fail again (review_budget's bisection makes the fallback sticky for the
+    rest of its decision); and ``last_predictor``, the branch the most recent plain call took
+    (informational: one attribute shared by every thread). This matters where the fallback is the
+    norm — the webhook image ships no ``apps`` package, so there EVERY call answers from numpy, and a
+    log line that said ``mojo`` because that was the CONFIGURED predictor described nothing real."""
     warned = [False]
 
-    def _fn(durations: list[float], contention: float, sla: float, n: int) -> float:
+    def probe(durations: list[float], contention: float, sla: float, n: int) -> tuple[float, str]:
         try:
-            return mojo_breach_probability(durations, contention, sla, n, client=client)
+            return mojo_breach_probability(durations, contention, sla, n, client=client), "mojo"
         except Exception as exc:  # noqa: BLE001 — never let the predictor block the gate
             if not warned[0]:
                 warned[0] = True
@@ -173,8 +183,15 @@ def make_mojo_breach_fn(client: object | None = None, *, fallback: BreachFn = _n
                     "compiled kernel",
                     file=_sys.stderr,
                 )
-            return fallback(durations, contention, sla, n)
+            return fallback(durations, contention, sla, n), "numpy"
+
+    def _fn(durations: list[float], contention: float, sla: float, n: int) -> float:
+        probability, _fn.last_predictor = probe(durations, contention, sla, n)
+        return probability
 
+    _fn.probe = probe
+    _fn.fallback = fallback
+    _fn.last_predictor = None
     return _fn
 
 
@@ -344,6 +361,19 @@ class MCAdmissionDecider:
             self.finish(time.monotonic() - started)
 
 
+def duration_to_learn(kind: str | None, duration_s: float) -> float:
+    """What the FIX admitter's duration window should learn from a finished webhook job.
+
+    ``MCAdmissionDecider.finish`` records every positive duration it is handed, and the webhook worker
+    hands it each claimed job's wall-clock — reviews included, whose ten-minute turns (review_budget)
+    would stretch the distribution the gate forecasts FIX admission against. Only a fix's wall-clock
+    is a sample of the series this gate models (its SLA is ``CODNA_FIX_SLA_S``); for every other kind
+    this returns 0.0, which ``finish`` treats as "release the slot, record nothing". Reviews already
+    have their own series: ``review_budget.observe_review_turn`` records the review TURN inside the
+    job, which is the duration the review budget actually learns from."""
+    return float(duration_s) if kind == "fix" and duration_s > 0 else 0.0
+
+
 _ADMITTER: MCAdmissionDecider | None = None
 _ADMITTER_LOCK = threading.Lock()
 

{codna-0.2.51 → codna-0.2.53}/codna/cline_agent.py

@@ -36,6 +36,19 @@ class UnparseableFindingsError(ClineAgentError):
     code = "review_unparseable_output"
 
 
+class ReviewTurnTimeout(ClineAgentError):
+    """The review turn outran the budget it was granted (review_budget.review_turn_budget).
+
+    Its own class and code so ``codna review`` reports it as ``review_timeout`` -- naming the diff's
+    size, the budget granted and how to proceed -- instead of the generic ``review_error`` sentence
+    that thyn-ai/algenta-sdk#71 got (``turn exceeded timeout budget of 240000ms`` buried in the
+    details). ``details`` carries the numbers: changed_lines, changed_files, prompt_tokens,
+    budget_ms, elapsed_s, plus the agent-core fields (cause_code, terminal_state, error).
+    """
+
+    code = "review_timeout"
+
+
 _RAW_EXCERPT_CHARS = 400
 
 

{codna-0.2.51 → codna-0.2.53}/codna/fix_inputs.py

@@ -10,6 +10,8 @@ import shutil
 import subprocess
 import tempfile
 
+from .testrun import TestEnvironmentUnavailable
+
 
 class FixInputError(Exception):
     """Bad/unusable fix input, surfaced to the user (the CLI maps it to a clean error)."""
@@ -181,6 +183,10 @@ def resolve_issue(args, github_token: str | None = None):
             else:
                 repo_dir = os.path.abspath(os.path.expanduser(repo))
                 issue, failing = _discover_failing_tests_for_fix(repo_dir, getattr(args, "test_cmd", None))
+        except TestEnvironmentUnavailable:
+            # Keeps its own error code: the CLI prints it structured and the GitHub App ends the
+            # check neutral -- flattening it into a cli_error made the check red (mojo-kernels#1).
+            raise
         except Exception as exc:  # noqa: BLE001 - surface any discovery failure as a clean CLI error
             raise FixInputError(str(exc)) from exc
         merged = list(dict.fromkeys([*explicit_failing, *failing]))

{codna-0.2.51 → codna-0.2.53}/codna/packaged_agent_runner.py

@@ -17,6 +17,7 @@ from .packaged_repository_advanced import (
     PackagedAgentRunResult,
     PackagedRepositoryAdvancedError,
 )
+from .review_budget import review_turn_budget_ms, size_budget_ms
 from .runtime.config import ConfigValue, RuntimeConfig
 
 _VERIFIED_AGENTIC_MODEL = "repository.verified_agentic_v1"
@@ -198,10 +199,23 @@ def _tool_profile_for_task(task_kind: str) -> str | None:
 
 
 def _timeout_ms_for_request(request: PackagedAgentRunRequest) -> int:
-    value = request.signals.get("review_timeout_s") if request.task_kind == "review" else None
+    """The per-turn budget the sidecar enforces (``limits.timeoutMs``).
+
+    A fix gets the size-derived ``_dynamic_timeout_ms``. A review used to get one fixed number
+    instead -- ``review_timeout_s`` (240 s, cline_agent.run_cline_review's default) -- which is
+    what failed thyn-ai/algenta-sdk#71 (+1008/-15, 5 files) with ``turn exceeded timeout budget of
+    240000ms`` while the fix path next to it would have granted minutes more. A review now gets
+    ``review_budget.review_turn_budget_ms``: the same size formula fed with the diff's own lines,
+    files and prompt tokens, raised by the admission gate's Monte-Carlo forecast over observed review
+    turns, bounded by [240 s, 20 min], ``ALGENTA_AGENT_TURN_TIMEOUT_MS`` winning as for fixes. An
+    explicit ``review_timeout_s`` signal remains a caller's pin (tests, an embedder), never a default.
+    """
+    if request.task_kind != "review":
+        return _dynamic_timeout_ms(request.snapshot)
+    value = request.signals.get("review_timeout_s")
     if isinstance(value, (int, float)) and not isinstance(value, bool):
         return _env_int_value(str(int(value * 1000)), minimum=30_000, maximum=3_600_000)
-    return _dynamic_timeout_ms(request.snapshot)
+    return review_turn_budget_ms(request.signals, request.snapshot)
 
 
 def _max_turns_for_request(request: PackagedAgentRunRequest) -> int:
@@ -352,15 +366,19 @@ def _is_test_path(path: str) -> bool:
 
 
 def _dynamic_timeout_ms(snapshot: Mapping[str, Any]) -> int:
+    """A fix turn's budget: 300 s base + 2 ms per estimated repo token (cap 900 s) + 1 s per snapshot
+    file (cap 600 s), capped at 1800 s -- ``review_budget.size_budget_ms`` is the shared formula
+    (the review path feeds it the diff's lines/files/tokens with its own coefficients)."""
     raw_tokens = _int_value(snapshot.get("raw_repo_token_estimate"))
     files = _int_value(snapshot.get("snapshot_file_count") or snapshot.get("file_count"))
-    base = 300_000
-    token_budget = min(900_000, raw_tokens * 2)
-    file_budget = min(600_000, files * 1_000)
     configured = os.environ.get("ALGENTA_AGENT_TURN_TIMEOUT_MS") or os.environ.get("FIX_TIMEOUT_MS")
     if configured:
         return _env_int_value(configured, minimum=30_000, maximum=3_600_000)
-    return max(base, min(1_800_000, base + token_budget + file_budget))
+    return size_budget_ms(
+        base_ms=300_000, cap_ms=1_800_000,
+        tokens=raw_tokens, token_ms=2, token_cap_ms=900_000,
+        files=files, file_ms=1_000, file_cap_ms=600_000,
+    )
 
 
 def _prepare_workspace(

{codna-0.2.51 → codna-0.2.53}/codna/review.py

@@ -28,6 +28,22 @@ class ReviewError(RuntimeError):
         self.details: dict[str, object] = dict(details or {})
 
 
+class ReviewTimeout(ReviewError):
+    """The review turn outran the budget it was granted (review_budget).
+
+    Reported under its own code so the check run reads ``codna review failed (review_timeout): ...``
+    with the diff's size, the budget and how to proceed, rather than the generic sentence. The check
+    conclusion stays ``failure`` like every other review failure (webhook_worker.process_job marks a
+    non-ok job ``failure``; ``neutral`` would let an unreviewed PR through a queue that requires the
+    review, cf. ``_inherit_review_for_merge_group``), and no review -- so no approval -- is posted,
+    because this is raised before ``review_github.post_review`` runs. The webhook queue retries a
+    ``review_timeout`` (webhook_summaries._NON_RETRYABLE_CODES does not list it), and the retry's
+    budget grows from the recorded, exhausted turn.
+    """
+
+    code = "review_timeout"
+
+
 def _fail(message: str, details: dict[str, object] | None = None) -> None:
     raise ReviewError(message, details)
 
@@ -161,6 +177,7 @@ def run_findings_review(args) -> dict:
     PR head. Returns the ReviewResult dict (+ a ``posted`` block when ``--post`` succeeds)."""
     from . import review_findings as rf
     from . import review_github as rg
+    from .cline_agent import ReviewTurnTimeout
     from .project_rules import read_project_guidance
 
     diff_range = getattr(args, "diff", None)
@@ -231,6 +248,10 @@ def run_findings_review(args) -> dict:
                 guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
                 model=getattr(args, "model", None) or None,
             )
+        except ReviewTurnTimeout as exc:
+            # The turn outran its adaptive budget: its message already names the diff size, the
+            # budget granted and how to proceed, so it is the whole error, not a prefix's tail.
+            raise ReviewTimeout(str(exc), _wrapped_details(exc)) from exc
         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