codna 0.1.37__tar.gz → 0.1.39__tar.gz

{codna-0.1.37 → codna-0.1.39}/PKG-INFO

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

{codna-0.1.37 → codna-0.1.39}/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.1.37"
+__version__ = "0.1.39"

{codna-0.1.37 → codna-0.1.39}/codna/agent-core/run-server.bundle.mjs

@@ -256588,13 +256588,16 @@ function enabledToolPolicy() {
   return { enabled: true, autoApprove: true };
 }
 function defaultApprovalProfileForArgs(args) {
+  if (args.task_kind === "review") {
+    return "repository_review";
+  }
   if (exactRestoreDisablesPatchTools(args)) {
     return "local_validation";
   }
   return args.tool_profile === "no_exploration_local_validation" ? "local_validation" : DEFAULT_APPROVAL_PROFILE;
 }
 function resolveTaskKind(payload, taskSpec) {
-  return ensureEnumValue(payload.task_kind ?? taskSpec.task_kind, ["fix", "triage"], "task_kind", "fix");
+  return ensureEnumValue(payload.task_kind ?? taskSpec.task_kind, ["fix", "triage", "review"], "task_kind", "fix");
 }
 function requestedToolPolicies(value) {
   const input = asRecord(value);
@@ -256666,10 +256669,13 @@ function resolveSessionPolicy(payload, args) {
     policies.editor = disabledToolPolicy();
     policies.apply_patch = disabledToolPolicy();
   }
-  if (args.task_kind === "triage") {
+  if (args.task_kind === "triage" || args.task_kind === "review") {
     policies.editor = disabledToolPolicy();
     policies.apply_patch = disabledToolPolicy();
   }
+  if (args.task_kind === "review") {
+    policies.run_commands = disabledToolPolicy();
+  }
   if (profile === "repository_review") {
     policies.editor = disabledToolPolicy();
     policies.apply_patch = disabledToolPolicy();

{codna-0.1.37 → codna-0.1.39}/codna/agent-core/vendor/cline/algenta/policy.test.ts

@@ -105,6 +105,15 @@ test("server session policy disables write tools for triage tasks", () => {
 	expect(policy.toolPolicies.run_commands?.enabled).toBeUndefined();
 });
 
+test("server session policy defaults review tasks to repository_review and disables shell/writes", () => {
+	const policy = resolveSessionPolicy({}, { ...ARGS, task_kind: "review" } as never);
+	expect(policy.profile).toBe("repository_review");
+	expect(policy.allowedWriteScope).toEqual([]);
+	expect(policy.toolPolicies.editor?.enabled).toBe(false);
+	expect(policy.toolPolicies.apply_patch?.enabled).toBe(false);
+	expect(policy.toolPolicies.run_commands?.enabled).toBe(false);
+});
+
 test("session_id is path-validated; the artifact run id is server-generated (decoupled)", () => {
 	const ok = normalizeSessionPayload({ ...base, session_id: "sess-123" }, "owner");
 	expect(ok.sessionId).toBe("sess-123");
@@ -256,6 +265,15 @@ test("normalizeSessionPayload preserves explicit task_kind and rejects unknown v
 		"owner",
 	);
 	expect(triage.taskKind).toBe("triage");
+	const review = normalizeSessionPayload(
+		{
+			...base,
+			task_kind: "review",
+		},
+		"owner",
+	);
+	expect(review.taskKind).toBe("review");
+	expect(review.approvalProfile).toBe("repository_review");
 	expect(() =>
 		normalizeSessionPayload(
 			{

{codna-0.1.37 → codna-0.1.39}/codna/agent-core/vendor/cline/algenta/server/policy.ts

@@ -40,6 +40,9 @@ function enabledToolPolicy(): ToolPolicy {
 }
 
 function defaultApprovalProfileForArgs(args: RunAgentArgs): ApprovalProfile {
+	if (args.task_kind === "review") {
+		return "repository_review";
+	}
 	if (exactRestoreDisablesPatchTools(args)) {
 		return "local_validation";
 	}
@@ -54,7 +57,7 @@ function resolveTaskKind(
 ): AgentTaskKind {
 	return ensureEnumValue(
 		payload.task_kind ?? taskSpec.task_kind,
-		["fix", "triage"] as const,
+		["fix", "triage", "review"] as const,
 		"task_kind",
 		"fix",
 	);
@@ -161,10 +164,13 @@ export function resolveSessionPolicy(
 		policies.editor = disabledToolPolicy();
 		policies.apply_patch = disabledToolPolicy();
 	}
-	if (args.task_kind === "triage") {
+	if (args.task_kind === "triage" || args.task_kind === "review") {
 		policies.editor = disabledToolPolicy();
 		policies.apply_patch = disabledToolPolicy();
 	}
+	if (args.task_kind === "review") {
+		policies.run_commands = disabledToolPolicy();
+	}
 	if (profile === "repository_review") {
 		policies.editor = disabledToolPolicy();
 		policies.apply_patch = disabledToolPolicy();

{codna-0.1.37 → codna-0.1.39}/codna/fix_run.py

@@ -227,15 +227,6 @@ def _verify_applied_checkout(applied: dict, test_cmd: str | None):
     from .testrun import discover_failing_tests
 
     checkout = applied.get("local_checkout_path")
-    commit_sha = applied.get("commit_sha")
-    if checkout and commit_sha:
-        try:
-            from .worktree import EphemeralWorktree
-
-            with EphemeralWorktree(checkout, commit_sha, prefix="codna-verify-") as worktree:
-                return discover_failing_tests(worktree.path, test_cmd)
-        except Exception:
-            raise
     return discover_failing_tests(checkout, test_cmd)
 
 

{codna-0.1.37 → codna-0.1.39}/codna/packaged_agent_runner.py

@@ -120,8 +120,9 @@ class SidecarPackagedAgentRunner:
 
 
 def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[str, Any]:
-    timeout_ms = _dynamic_timeout_ms(request.snapshot)
-    max_turns = _env_int("ALGENTA_AGENT_MAX_TURNS", default=4, minimum=1, maximum=50)
+    task_kind = _validated_task_kind(request.task_kind)
+    timeout_ms = _timeout_ms_for_request(request)
+    max_turns = _max_turns_for_request(request)
     requested_provider, requested_model = _provider_model_from_request(request.model)
     provider = (
         os.environ.get("ALGENTA_AGENT_PROVIDER")
@@ -137,19 +138,20 @@ def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[
         "working_dir": str(workspace),
         "channel": "cli",
         "repository_scope": request.repository_id,
-        "task_kind": "fix",
-        "tool_profile": os.environ.get(
-            "ALGENTA_REPOSITORY_AGENT_TOOL_PROFILE",
-            "no_exploration_local_validation",
-        ),
+        "task_kind": task_kind,
+        "tool_profile": _tool_profile_for_task(task_kind),
         "limits": {"maxIterations": max_turns, "timeoutMs": timeout_ms},
         "task_spec": {
             "issue_text": _issue_text_with_guidance(request),
+            "task_kind": task_kind,
             "engine": {"enabled": False},
         },
         "injected_context": _injected_context(request),
-        "allowed_write_paths": _allowed_write_paths(request),
+        "allowed_write_paths": [] if task_kind == "review" else _allowed_write_paths(request),
     }
+    if task_kind == "review":
+        payload["approval_profile"] = "repository_review"
+        payload["allowed_write_scope"] = []
     if provider:
         payload["provider"] = provider
     if model:
@@ -157,6 +159,40 @@ def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[
     return payload
 
 
+def _validated_task_kind(value: str) -> str:
+    task_kind = (value or "fix").strip()
+    if task_kind not in {"fix", "triage", "review"}:
+        raise PackagedRepositoryAdvancedError(
+            "agent_task_kind_invalid",
+            "Unsupported local agent task kind.",
+            {"task_kind": value, "allowed": ["fix", "triage", "review"]},
+        )
+    return task_kind
+
+
+def _tool_profile_for_task(task_kind: str) -> str | None:
+    if task_kind == "review":
+        return None
+    return os.environ.get(
+        "ALGENTA_REPOSITORY_AGENT_TOOL_PROFILE",
+        "no_exploration_local_validation",
+    )
+
+
+def _timeout_ms_for_request(request: PackagedAgentRunRequest) -> int:
+    value = request.signals.get("review_timeout_s") if request.task_kind == "review" else None
+    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)
+
+
+def _max_turns_for_request(request: PackagedAgentRunRequest) -> int:
+    value = request.signals.get("review_max_iterations") if request.task_kind == "review" else None
+    if isinstance(value, int) and not isinstance(value, bool):
+        return max(1, min(50, value))
+    return _env_int("ALGENTA_AGENT_MAX_TURNS", default=4, minimum=1, maximum=50)
+
+
 def _provider_model_from_request(model: str) -> tuple[str | None, str | None]:
     requested = (model or "").strip()
     if not requested or requested == _VERIFIED_AGENTIC_MODEL:
@@ -324,7 +360,7 @@ def _prepare_workspace(
     workspace.parent.mkdir(parents=True, exist_ok=True)
     if _is_clean_git_repo(repo_root) and _git_worktree_add(repo_root, workspace):
         return _Workspace(path=workspace, kind="git_worktree")
-    shutil.copytree(repo_root, workspace, ignore=_copy_ignore)
+    shutil.copytree(repo_root, workspace, ignore=_copy_ignore_for(runtime_root))
     _init_baseline_git_repo(workspace)
     return _Workspace(path=workspace, kind="copy")
 
@@ -462,8 +498,27 @@ def _git_worktree_add(repo_root: Path, workspace: Path) -> bool:
     return False
 
 
-def _copy_ignore(_directory: str, names: list[str]) -> set[str]:
-    return {name for name in names if name in _WORKSPACE_SKIP_DIRS}
+def _copy_ignore_for(runtime_root: Path):
+    runtime_root = runtime_root.expanduser().resolve()
+
+    def _copy_ignore(directory: str, names: list[str]) -> set[str]:
+        directory_path = Path(directory).resolve()
+        ignored = {name for name in names if name in _WORKSPACE_SKIP_DIRS}
+        for name in names:
+            child = (directory_path / name).resolve()
+            if child == runtime_root or _is_relative_to(child, runtime_root):
+                ignored.add(name)
+        return ignored
+
+    return _copy_ignore
+
+
+def _is_relative_to(path: Path, parent: Path) -> bool:
+    try:
+        path.relative_to(parent)
+        return True
+    except ValueError:
+        return False
 
 
 def _parse_final_frame(body: str, *, sidecar_url: str) -> dict[str, Any]:

{codna-0.1.37 → codna-0.1.39}/codna/packaged_repository_advanced.py

@@ -33,6 +33,7 @@ class PackagedAgentRunRequest:
     signals: dict[str, Any]
     evidence_bundle: dict[str, Any]
     snapshot: dict[str, Any]
+    task_kind: str = "fix"
 
 
 @dataclass(frozen=True)

{codna-0.1.37 → codna-0.1.39}/codna/review.py

@@ -12,6 +12,15 @@ import os
 import subprocess
 
 
+class ReviewError(RuntimeError):
+    code = "review_error"
+    details: dict[str, object] = {}
+
+
+def _fail(message: str) -> None:
+    raise ReviewError(message)
+
+
 def changed_files(repo_dir: str, base: str = "HEAD") -> list[str]:
     """Files changed in the working tree relative to `base` (default HEAD = all uncommitted). Best-effort."""
     try:
@@ -31,7 +40,7 @@ def run_review(c, args) -> dict:
 
     local = os.path.abspath(os.path.expanduser(args.repo))
     if not os.path.isdir(local):
-        _cli._die("`codna review` needs a local repo path (it diffs the working tree).")
+        _fail("`codna review` needs a local repo path (it diffs the working tree).")
     base = getattr(args, "base", None) or "HEAD"
     files = changed_files(local, base)
     if not files:
@@ -116,7 +125,6 @@ def run_findings_review(args) -> dict:
 
     Local path (default): diffs the working tree. Remote URL (webhook/CI): clones + materializes the
     PR head. Returns the ReviewResult dict (+ a ``posted`` block when ``--post`` succeeds)."""
-    from . import cli as _cli
     from . import review_findings as rf
     from . import review_github as rg
     from .project_rules import read_project_guidance
@@ -138,19 +146,19 @@ def run_findings_review(args) -> dict:
         # from the URL — never the CWD's git remote — so running `codna review <url> --pr N` from
         # inside an UNRELATED repo can't misroute the review/post to that repo (a real footgun).
         if not pr:
-            _cli._die("reviewing a remote URL needs --pr (the PR to review).")
+            _fail("reviewing a remote URL needs --pr (the PR to review).")
         repo_slug = rg.repo_slug_from_url(str(args.repo))
         if not repo_slug:
-            _cli._die(f"could not parse owner/repo from {args.repo!r}.")
+            _fail(f"could not parse owner/repo from {args.repo!r}.")
         _, pr_number = rg.parse_pr_arg(str(pr), str(args.repo))  # take only the number from --pr
         if not pr_number:
-            _cli._die(f"--pr {pr!r}: could not resolve a PR number.")
+            _fail(f"--pr {pr!r}: could not resolve a PR number.")
         try:
             meta = rg.fetch_pr(repo_slug, pr_number, token)
         except Exception as exc:  # noqa: BLE001
-            _cli._die(f"could not fetch PR #{pr_number}: {exc}")
+            _fail(f"could not fetch PR #{pr_number}: {exc}")
         if not meta.get("base_ref"):
-            _cli._die(f"PR #{pr_number} has no base ref (cannot compute the diff).")
+            _fail(f"PR #{pr_number} has no base ref (cannot compute the diff).")
         # Cross-run context: prior human/bot comments (don't duplicate) + the last-reviewed head SHA
         # (review only the commits pushed since → incremental). Best-effort; needs a token.
         incremental_base = None
@@ -163,41 +171,44 @@ def run_findings_review(args) -> dict:
             local, diff_range, head_sha = _materialize_pr(
                 str(args.repo), pr_number, meta["base_ref"], token, incremental_base=incremental_base)
         except Exception as exc:  # noqa: BLE001
-            _cli._die(f"could not materialize PR #{pr_number}: {exc}")
+            _fail(f"could not materialize PR #{pr_number}: {exc}")
         base = None
     else:
         local = os.path.abspath(os.path.expanduser(args.repo))
         if not os.path.isdir(local):
-            _cli._die("`codna review` needs a local repo path or a git URL (with --pr).")
+            _fail("`codna review` needs a local repo path or a git URL (with --pr).")
         if pr:
             repo_slug, pr_number = rg.parse_pr_arg(str(pr), local)
             if not repo_slug or not pr_number:
-                _cli._die(f"--pr {pr!r}: could not resolve owner/repo#number (pass owner/repo#123 or a PR URL).")
+                _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
-        _cli._die(f"review config error: {exc}")
+        _fail(f"review config error: {exc}")
 
     guidance = read_project_guidance(local)
-    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,
-    )
+    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.
+        _fail(f"review agent failed: {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):
-            _cli._die("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
+            _fail("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
         if not token:
-            _cli._die("--post needs a write token: pass --github-token or set GITHUB_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
-            _cli._die(f"posting the review failed: {exc}")
+            _fail(f"posting the review failed: {exc}")
     return out
 
 

{codna-0.1.37 → codna-0.1.39}/codna/review_findings.py

@@ -12,10 +12,12 @@ from __future__ import annotations
 
 import fnmatch
 import hashlib
+import os
 import re
 import subprocess
 import time
 from dataclasses import dataclass, field, asdict
+from pathlib import Path
 
 SEVERITIES = ("high", "medium", "low")
 CATEGORIES = ("correctness", "security", "performance")
@@ -474,8 +476,6 @@ def run_diff_review(
     timeout_s: int = 240,
 ) -> ReviewResult:
     """Run the read-only agent over the diff and return a fully finalized :class:`ReviewResult`."""
-    from .cline_agent import run_cline_review
-
     t0 = time.perf_counter()
     base_label = diff_range or base or "HEAD"
     # Effort → iteration budget (unless the caller pins max_iterations explicitly).
@@ -489,7 +489,7 @@ def run_diff_review(
         )
     resolved_head = head_sha or resolve_head_sha(repo_dir, diff_range)
     prompt = build_review_prompt(diff_text, changed, guidance, config, prior_feedback)
-    raw, agent = run_cline_review(
+    raw, agent = run_review_agent(
         repo_dir, prompt, provider=provider, model=model,
         max_iterations=iterations, timeout_s=timeout_s,
     )
@@ -501,3 +501,64 @@ def run_diff_review(
         conclusion=check_conclusion([*inline, *summary], config), dropped=dropped,
         model=(agent or {}).get("model"), elapsed_s=round(time.perf_counter() - t0, 1),
     )
+
+
+def run_review_agent(
+    repo_dir: str,
+    prompt: str,
+    *,
+    provider: str = "anthropic",
+    model: str | None = None,
+    max_iterations: int = 12,
+    timeout_s: int = 240,
+) -> tuple[list[dict], dict]:
+    """Run the packaged local sidecar in read-only review mode.
+
+    This is the installed-product path. It does not require source-checkout ``node_modules``;
+    the bundled sidecar owns the Cline SDK runtime and enforces ``task_kind=review`` below
+    the model.
+    """
+    from . import cli as _cli
+    from .cline_agent import extract_findings_json
+    from .packaged_agent_runner import SidecarPackagedAgentRunner
+    from .packaged_repository_advanced import PackagedAgentRunRequest
+    from .runtime.config import resolve_runtime_config
+
+    repo_root = Path(repo_dir).expanduser().resolve()
+    keys = _cli._runtime_keys(include_keychain=True)
+    config_runtime = resolve_runtime_config(keys=keys)
+    prompt_digest = hashlib.sha256(prompt.encode("utf-8")).hexdigest()[:16]
+    request = PackagedAgentRunRequest(
+        repository_id="review_" + hashlib.sha256(str(repo_root).encode("utf-8")).hexdigest()[:16],
+        snapshot_id="review_" + prompt_digest,
+        repo_root=repo_root,
+        issue_text=prompt,
+        model=_review_model(provider=provider, model=model),
+        signals={"review_timeout_s": timeout_s, "review_max_iterations": max_iterations},
+        evidence_bundle={},
+        snapshot={
+            "snapshot_id": "review_" + prompt_digest,
+            "snapshot_file_count": 0,
+            "raw_repo_token_estimate": max(1, len(prompt) // 4),
+        },
+        task_kind="review",
+    )
+    result = SidecarPackagedAgentRunner(config=config_runtime, keys=keys).run(request)
+    agent = {
+        "status": result.status,
+        "terminal_state": result.terminal_state,
+        "model": result.telemetry.get("model"),
+        "usage": result.telemetry,
+        "agent_run_id": result.agent_run_id,
+        "session_id": result.session_id,
+    }
+    return extract_findings_json(result.text), agent
+
+
+def _review_model(*, provider: str, model: str | None) -> str:
+    if model:
+        return model if "/" in model else f"{provider}/{model}"
+    env_model = os.environ.get("CODNA_REVIEW_MODEL") or os.environ.get("ALGENTA_REVIEW_MODEL")
+    if env_model:
+        return env_model
+    return "repository.verified_agentic_v1"

{codna-0.1.37 → codna-0.1.39}/codna.egg-info/PKG-INFO

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

{codna-0.1.37 → codna-0.1.39}/pyproject.toml

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

{codna-0.1.37 → codna-0.1.39}/tests/test_benchmark_suite.py

@@ -92,6 +92,23 @@ def test_run_returns_127_for_missing_executable(tmp_path: Path) -> None:
     assert "No such file" in err
 
 
+def test_ensure_codna_runtime_uses_published_doctor_contract(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = []
+
+    def fake_run(cmd, *, timeout):
+        calls.append((cmd, timeout))
+        return 0, "Codna runtime: healthy", "", 0.2
+
+    monkeypatch.delenv("CODNA_ENGINE_URL", raising=False)
+    monkeypatch.delenv("ALGENTA_ENGINE_URL", raising=False)
+    monkeypatch.delenv("ALGENTA_BASE_URL", raising=False)
+    monkeypatch.setattr(bench, "CODNA", "codna")
+    monkeypatch.setattr(bench, "_run", fake_run)
+
+    assert bench._ensure_codna_runtime() is None
+    assert calls == [(["codna", "doctor", "--start-stack"], 120)]
+
+
 def test_codna_fix_reports_planner_token_split(monkeypatch: pytest.MonkeyPatch) -> None:
     payload = {
         "runtime_model": "claude-sonnet-4-6",

{codna-0.1.37 → codna-0.1.39}/tests/test_fix_run.py

@@ -369,7 +369,12 @@ def test_apply_codna_error_keeps_patch_ref_hint(monkeypatch):
     assert "apply failed:" in msg and "patch://abc" in msg  # framing + recovery hint preserved
 
 
-def test_verify_uses_temp_worktree_when_commit_sha_available(monkeypatch, tmp_path):
+def test_verify_uses_applied_checkout_when_commit_sha_available(monkeypatch, tmp_path):
+    """Regression: clean git worktrees omit untracked dependency caches such as node_modules.
+
+    A local --apply fix should be verified in the checkout the user will continue using, not in
+    a detached worktree that can fail only because install artifacts are untracked.
+    """
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     checkout = tmp_path / "repo"
     checkout.mkdir()
@@ -386,29 +391,16 @@ def test_verify_uses_temp_worktree_when_commit_sha_available(monkeypatch, tmp_pa
     monkeypatch.setattr("os.path.isdir", lambda p: True)
     seen = []
 
-    class _FakeWorktree:
-        def __init__(self, repo_dir, commit, prefix=""):
-            assert repo_dir == str(checkout)
-            assert commit == "a" * 40
-            self.path = "/tmp/codna-verify-worktree"
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, *exc):
-            return None
-
     def fake_discover(repo, cmd=None):
         seen.append(repo)
         return _FAIL if len(seen) == 1 else _GREEN
 
-    monkeypatch.setattr("codna.worktree.EphemeralWorktree", _FakeWorktree)
     monkeypatch.setattr("codna.testrun.discover_failing_tests", fake_discover)
 
     result = fix_run.run_fix(object(), _Args(apply=True, tests=True))
 
     assert result["verified"] is True
-    assert seen == ["/repo", "/tmp/codna-verify-worktree"]
+    assert seen == ["/repo", str(checkout)]
 
 
 def test_cleanup_generated_apply_artifacts_removes_new_untracked_patch_file(tmp_path):

{codna-0.1.37 → codna-0.1.39}/tests/test_packaged_guidance.py

@@ -73,3 +73,43 @@ def test_default_repository_model_does_not_force_agent_provider(monkeypatch):
 
     assert "provider" not in payload
     assert "model" not in payload
+
+
+def test_review_payload_uses_read_only_sidecar_profile():
+    payload = par._sidecar_payload(
+        _req(
+            task_kind="review",
+            evidence_bundle={"suspect_files": ["calc.py"]},
+            signals={"review_max_iterations": 3, "review_timeout_s": 45},
+        ),
+        Path("/tmp"),
+    )
+
+    assert payload["task_kind"] == "review"
+    assert payload["task_spec"]["task_kind"] == "review"
+    assert payload["approval_profile"] == "repository_review"
+    assert payload["allowed_write_paths"] == []
+    assert payload["allowed_write_scope"] == []
+    assert payload["limits"] == {"maxIterations": 3, "timeoutMs": 45000}
+
+
+def test_prepare_workspace_excludes_repo_local_runtime_root(tmp_path):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "calc.py").write_text("def add(a, b):\n    return a + b\n", encoding="utf-8")
+    runtime_root = repo / "runtime"
+    nested = runtime_root / "repository-intelligence" / "packaged"
+    nested.mkdir(parents=True)
+    (nested / "state.json").write_text("{}", encoding="utf-8")
+
+    workspace = par._prepare_workspace(
+        repo_root=repo,
+        runtime_root=runtime_root,
+        repository_id="r",
+        snapshot_id="s",
+    )
+    try:
+        assert (workspace.path / "calc.py").is_file()
+        assert not (workspace.path / "runtime").exists()
+    finally:
+        par._cleanup_workspace(repo, workspace)

{codna-0.1.37 → codna-0.1.39}/tests/test_review_findings.py

@@ -291,8 +291,6 @@ def test_run_findings_review_url_materializes_pr(monkeypatch, tmp_path):
 
 def test_run_diff_review_end_to_end_real_git(tmp_path, monkeypatch):
     """Full pipeline against a REAL git working-tree diff (only the agent is stubbed)."""
-    from codna import cline_agent
-
     def git(*a):
         subprocess.run(["git", "-C", str(tmp_path), *a], check=True, capture_output=True, text=True,
                        env={**os.environ, "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t",
@@ -309,7 +307,7 @@ def test_run_diff_review_end_to_end_real_git(tmp_path, monkeypatch):
     line = sorted(rf.parse_diff(diff)["a.py"].added_lines)[0]  # a real changed new-side line
 
     monkeypatch.setattr(
-        cline_agent, "run_cline_review",
+        rf, "run_review_agent",
         lambda cwd, prompt, **kw: (
             [{"path": "a.py", "line": line, "severity": "high", "category": "correctness",
               "title": "bug", "explanation": "boom", "confidence": 0.95}],