codna 0.1.7__tar.gz → 0.1.8__tar.gz

{codna-0.1.7 → codna-0.1.8}/MANIFEST.in

@@ -4,4 +4,6 @@ exclude codna/_telys_runtime/oem-license.jwt
 recursive-exclude codna/_telys_runtime libame_kernel.* manifest.json oem-license.jwt
 recursive-exclude .codna *
 recursive-exclude .codna-memory *
+recursive-exclude codna __pycache__ *.py[cod] *.pyo
+global-exclude __pycache__ *.py[cod] *.pyo
 global-exclude keys.txt .keys.txt .env .env.* *.log *.pem *.key *.jwt local-stack.json launcher.state

{codna-0.1.7 → codna-0.1.8}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.7
+Version: 0.1.8
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn
-License-Expression: Apache-2.0
+License: Apache-2.0
 Project-URL: Homepage, https://codna.ai
 Project-URL: Documentation, https://docs.codna.ai
 Project-URL: Source, https://github.com/thyn-ai/codna
@@ -31,13 +31,14 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: keyring>=24
-Requires-Dist: mcp>=1.2.0
-Requires-Dist: pyarrow>=15.0.0
+Requires-Dist: mcp<2,>=1.2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyarrow>=17.0.0
 Requires-Dist: pyyaml>=6
+Requires-Dist: telys>=0.1.0b1
 Provides-Extra: mcp
 Provides-Extra: memory
-Requires-Dist: telys>=0.1.0b1; extra == "memory"
-Requires-Dist: numpy>=1.24; extra == "memory"
 Requires-Dist: faiss-cpu>=1.7; extra == "memory"
 Requires-Dist: wordllama>=0.3; extra == "memory"
 Requires-Dist: tree-sitter>=0.23; extra == "memory"
@@ -118,25 +119,20 @@ codna mcp
 Use this when Cursor, Claude, or another MCP-compatible client needs Codna's
 repo understanding as a local tool.
 
-## Optional Local Memory
+## Local Memory
 
-Optional local code-memory support is available through:
+Base `pip install codna` includes Codna's local Telys recall path: the public
+Telys SDK, Codna's vendored local runtime package, and release-wheel native
+runtime artifacts for supported platforms.
 
-```bash
-pip install "codna[memory]"
-```
-
-The memory extra uses the public Telys SDK for on-device retrieval. It installs
-public Python dependencies only; the signed native runtime is installed
-separately:
-
-```bash
-telys runtime install --file <bundle> --license <license.jwt>
-```
+The optional `codna[memory]` extra adds heavier recall enhancements such as
+FAISS, WordLlama reranking, and tree-sitter grammars. It is not required for
+basic on-device recall.
 
-Codna also supports release builds that include signed native Telys runtime
-artifacts for supported platforms. Source distributions intentionally exclude
-bundled native runtime artifacts.
+Source distributions intentionally exclude bundled native runtime artifacts and
+OEM licenses; platform wheels carry them at release time. Source-checkout and
+unsupported-platform development can point Codna at an explicit runtime with
+`TELYS_KERNEL` or `CODNA_TELYS_INSTALL_ROOT`.
 
 ## Security And Local Files
 

{codna-0.1.7 → codna-0.1.8}/README.md

@@ -50,25 +50,20 @@ codna mcp
 Use this when Cursor, Claude, or another MCP-compatible client needs Codna's
 repo understanding as a local tool.
 
-## Optional Local Memory
+## Local Memory
 
-Optional local code-memory support is available through:
+Base `pip install codna` includes Codna's local Telys recall path: the public
+Telys SDK, Codna's vendored local runtime package, and release-wheel native
+runtime artifacts for supported platforms.
 
-```bash
-pip install "codna[memory]"
-```
-
-The memory extra uses the public Telys SDK for on-device retrieval. It installs
-public Python dependencies only; the signed native runtime is installed
-separately:
-
-```bash
-telys runtime install --file <bundle> --license <license.jwt>
-```
+The optional `codna[memory]` extra adds heavier recall enhancements such as
+FAISS, WordLlama reranking, and tree-sitter grammars. It is not required for
+basic on-device recall.
 
-Codna also supports release builds that include signed native Telys runtime
-artifacts for supported platforms. Source distributions intentionally exclude
-bundled native runtime artifacts.
+Source distributions intentionally exclude bundled native runtime artifacts and
+OEM licenses; platform wheels carry them at release time. Source-checkout and
+unsupported-platform development can point Codna at an explicit runtime with
+`TELYS_KERNEL` or `CODNA_TELYS_INSTALL_ROOT`.
 
 ## Security And Local Files
 

{codna-0.1.7 → codna-0.1.8}/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.7"
+__version__ = "0.1.8"

{codna-0.1.7 → codna-0.1.8}/codna/agent_core_runtime.py

@@ -842,12 +842,19 @@ def stop_agent_core_runtime(
         try:
             return stop_local_mojo_daemon(config)
         except LocalMojoDaemonError as exc:
-            raise LocalRuntimeError(exc.code, str(exc), exc.details) from exc
+            return {
+                "status": "error",
+                "error": {
+                    "code": exc.code,
+                    "message": str(exc),
+                    "details": exc.details,
+                },
+            }
 
     def _stop_unlocked(*, lock_acquired: bool) -> dict[str, Any]:
-        mojo_daemon = _stop_mojo_daemon()
         listener = _single_listener(config.sidecar_port)
         if listener is None:
+            mojo_daemon = _stop_mojo_daemon()
             state_unlink_error = _unlink_state_if_possible(config)
             payload: dict[str, Any] = {
                 "status": "not_running",
@@ -867,6 +874,7 @@ def stop_agent_core_runtime(
         if healthy or _state_owns_listener(state, listener):
             listener_payload = _listener_payload(listener)
             _stop_owned_sidecar(config, listener, reason="stop_requested")
+            mojo_daemon = _stop_mojo_daemon()
             state_unlink_error = _unlink_state_if_possible(config)
             payload = {
                 "status": "stopped",

{codna-0.1.7 → codna-0.1.8}/codna/byok_cli.py

@@ -68,7 +68,7 @@ def cmd_key(args) -> int:
     try:
         if action == "list":
             print(json.dumps(
-                {"ok": True, "keys": keystore.stored_key_names(), "keychain": keystore.available()},
+                {"ok": True, "keys": keystore.stored_key_names(force=True), "keychain": keystore.available(force=True)},
                 indent=2,
             ))
             return 0

{codna-0.1.7 → codna-0.1.8}/codna/cli.py

@@ -23,6 +23,9 @@ from . import __version__
 from .focus_paths import _issue_focus_paths  # focus-path extraction (split out to keep cli.py small)
 from .agent_core_runtime import ensure_agent_core_running, inspect_agent_core_runtime, stop_agent_core_runtime
 from .local_mojo_pool import legacy_global_mojo_worker_diagnostics, mojo_worker_diagnostics
+from .mcp_cli import cmd_mcp as _cmd_mcp
+from .webhook_cli import cmd_webhook
+from .remote_http import RemoteHttpTimeoutError, remote_http_timeout
 from .runtime import LocalRuntimeError, ensure_running
 from .runtime.config import API_KEY_KEYS, RuntimeConfigError, parse_keys_file_values, resolve_runtime_config
 
@@ -68,16 +71,15 @@ def _keys_file_path() -> Path | None:
     return here.parents[2] / "keys.txt"
 
 
-def _runtime_keys():
-    # Precedence (env wins later at resolution time in runtime.config): keychain over legacy keys.txt,
-    # so `codna key set` takes effect even if a stale keys.txt exists. keys.txt is DEV-only and is never
-    # looked for in an installed package (see _keys_file_path). The keychain read never raises.
+def _runtime_keys(*, include_keychain: bool = True):
     merged = {}
     path = _keys_file_path()
     if path is not None:
         path = path.expanduser()
         if path.is_file():
             merged.update(parse_keys_file_values(path))
+    if not include_keychain:
+        return merged
     from . import keystore
     merged.update(keystore.config_values())
     return merged
@@ -261,6 +263,13 @@ def _engine_url_key():
     return url.rstrip("/"), _api_key(keys)
 
 
+def _remote_http_timeout() -> httpx.Timeout:
+    try:
+        return remote_http_timeout(os.environ)
+    except RemoteHttpTimeoutError as exc:
+        raise CodnaError(str(exc)) from exc
+
+
 def _client():
     keys = _runtime_keys()
     config = resolve_runtime_config(keys=keys)
@@ -273,8 +282,7 @@ def _client():
     key = _api_key(keys)
     if not key:
         _die("no API key — set CODNA_API_KEY (your codna key).")
-    timeout = float(os.environ.get("CODNA_TIMEOUT_S", "1800"))
-    return _HttpCodnaClient(api_key=key, base_url=url, timeout=timeout)
+    return _HttpCodnaClient(api_key=key, base_url=url, timeout=_remote_http_timeout())
 
 
 def _dump(x):
@@ -403,12 +411,16 @@ def cmd_fix(args) -> int:
     from . import fix_run
     c = _client()
     as_json = getattr(args, "as_json", False)
-    if not as_json:
-        print(f"codna: fixing {args.repo} …")
-    result = fix_run.run_fix(c, args)
     if as_json:
+        import contextlib
+
+        # Keep stdout machine-parseable even if the local engine/agent stack logs to stdout.
+        with contextlib.redirect_stdout(sys.stderr):
+            result = fix_run.run_fix(c, args)
         print(json.dumps(result, indent=2))
     else:
+        print(f"codna: fixing {args.repo} …")
+        result = fix_run.run_fix(c, args)
         print("\n".join(fix_run.render_human(result)))
     # non-zero exit when verification ran and did not reach green (scriptable signal)
     return 1 if result.get("verified") is False else 0
@@ -420,7 +432,7 @@ def cmd_secure(args) -> None:
     --fix/--open-pr, runs the sandboxed worker + PR writer to remediate eligible findings."""
     from .engine import EngineAdapter, http_post_factory
     from .policy import Policy
-    from .sarif import ingest_sarif
+    from .sarif import SarifError, ingest_sarif
 
     if not args.from_sarif:
         _die("`codna secure` needs --from-sarif <results.sarif>.")
@@ -429,6 +441,8 @@ def cmd_secure(args) -> None:
     if args.fix and args.engine != "local" and not args.verification:
         _die("--fix needs --verification <codna-security.yaml> (scanner + build/test commands); "
              "or use --engine local for a scanner-less local fix.")
+    if getattr(args, "as_json", False) and (args.fix or args.open_pr):
+        _die("`codna secure --json` is read-only; remove --json to run --fix/--open-pr.")
 
     policy = Policy()
     config_digest = None
@@ -443,7 +457,12 @@ def cmd_secure(args) -> None:
             except ManifestError as exc:
                 _die(str(exc))
 
-    ingest = ingest_sarif(args.from_sarif)
+    if not os.path.isfile(args.from_sarif):
+        _die(f"could not read SARIF {args.from_sarif}: file not found")
+    try:
+        ingest = ingest_sarif(args.from_sarif)
+    except SarifError as exc:
+        _die(f"could not ingest SARIF {args.from_sarif}: {exc}")
     if not ingest.provenance_valid:
         _die("SARIF provenance incomplete: " + "; ".join(ingest.provenance_errors))
 
@@ -630,9 +649,12 @@ def cmd_secure_open_pr(args) -> None:
     from .evidence import HmacSigner, read_evidence
     from .findings import NormalizedFinding
     from .secure import Patch
-    from .writer import GitHubWriter, gh_create_pr_factory, gh_head_resolver_factory
+    from .writer import GitHubWriter, WriterError, cloned_push_pr_factory, gh_head_resolver_factory
 
-    att, diff, desc = read_evidence(args.evidence)
+    try:
+        att, diff, desc = read_evidence(args.evidence)
+    except Exception as exc:  # noqa: BLE001 - evidence is external input; never leak tracebacks.
+        _die(f"could not read evidence bundle {args.evidence}: {exc}")
     if not desc:
         _die("evidence is missing finding.json (cannot derive the branch).")
     key_bytes = (os.environ.get("CODNA_ATTESTATION_KEY") or "").encode()
@@ -647,66 +669,29 @@ def cmd_secure_open_pr(args) -> None:
     signer = HmacSigner(key_bytes, key_id=att.signer_id)
     finding = NormalizedFinding.minimal(canonical_id=desc["canonical_id"], rule_id=desc["rule_id"],
                                         finding_kind=desc["finding_kind"])
-    writer = GitHubWriter(trusted_signers={signer.key_id: signer},
-                          create_pr=gh_create_pr_factory(args.repo_slug, gh),
+    base_branch = args.base_branch or "main"
+    # Clone the base branch so the writer's git backend applies the verified diff onto real files
+    # and pushes a REAL branch (git plumbing only — never runs the project's code). This replaced
+    # an API-only factory that opened an EMPTY PR (the diff was never committed).
+    try:
+        create_pr, cleanup = cloned_push_pr_factory(args.repo_slug, gh, base_branch)
+    except WriterError as exc:
+        _die(str(exc))
+    writer = GitHubWriter(trusted_signers={signer.key_id: signer}, create_pr=create_pr,
                           head_resolver=gh_head_resolver_factory(args.repo_slug, gh),
-                          base_branch=args.base_branch or "main")
+                          base_branch=base_branch)
     try:
         url = writer.open_draft_pr(finding, Patch(att.payload["patch_digest"], diff=diff), att)
     except Exception as exc:  # noqa: BLE001
         _die(f"writer refused to open the PR: {exc}")
+    finally:
+        cleanup()
     print(f"✓ opened draft PR: {url}")
 
 
-def cmd_webhook(args):
-    """Run Codna's GitHub App webhook — the App channel, owned in Codna.
 
-    Verifies each delivery's signature, classifies the event into a Codna job
-    (fix on failing CI / `codna-fix`; security-autofix on `codna-secure` /
-    code-scanning alerts), and dispatches by invoking the `codna` CLI. All of
-    this is Codna-specific product wiring and lives in Codna, never in the
-    Algenta SDK/engine (which ships generic to other users).
-    """
-    from .webhook import WebhookError, serve
-
-    action = getattr(args, "action", "serve") or "serve"
-    if action != "serve":
-        _die(f"unknown `codna webhook` action: {action}")
-    host = getattr(args, "host", "0.0.0.0")
-    port = int(getattr(args, "port", 8080))
-    try:
-        print(f"codna webhook: listening on {host}:{port}/webhooks/github", file=sys.stderr)
-        serve(host=host, port=port)
-    except WebhookError as exc:
-        _die(str(exc))
-    except KeyboardInterrupt:
-        return 0
-    return 0
-
-
-def cmd_mcp(args):
-    action = getattr(args, "action", "start") or "start"
-    if action == "install":
-        from .mcp_install import McpInstallError, install
-        client = getattr(args, "client", None)
-        if not client:
-            _die("`codna mcp install` needs --client cursor|claude.")
-        try:
-            summary = install(client, project=getattr(args, "project", False), repo=getattr(args, "repo", None))
-        except McpInstallError as exc:
-            print(json.dumps({"ok": False, "error": str(exc)}, indent=2), file=sys.stderr)
-            return 1
-        print(json.dumps({"ok": True, **summary}, indent=2))
-        return 0
-    # start (default): `codna mcp start --repo X` sets the default repo the MCP tools use when a client
-    # passes "." — FastMCP tool functions get their args from the client, so the default is carried via env.
-    repo = getattr(args, "repo", None)
-    if repo:
-        local = os.path.abspath(os.path.expanduser(repo))
-        os.environ["CODNA_MCP_DEFAULT_REPO"] = local if os.path.isdir(local) else repo
-    from .mcp_server import main as mcp_main
-    mcp_main()
-    return 0
+def cmd_mcp(args) -> int:
+    return _cmd_mcp(args, die=_die)
 
 
 def cmd_review(args) -> int:
@@ -739,7 +724,7 @@ def cmd_init(args) -> int:
 def cmd_status(args) -> int:
     """Concise health: engine · telys runtime · license · keys. Degrades gracefully (no spawn)."""
     from .status import build_status_lines
-    keys = _runtime_keys()
+    keys = _runtime_keys(include_keychain=False)
     print("\n".join(build_status_lines(keys, api_key_present=bool(_api_key(keys)))))
     return 0
 
@@ -785,12 +770,12 @@ def cmd_login(args) -> int:
 
 
 def cmd_doctor(args) -> int:
-    keys = _runtime_keys()
     try:
         start_stack = bool(getattr(args, "start_stack", False))
         stop_stack = bool(getattr(args, "stop_stack", False))
         if start_stack and stop_stack:
             _die("--start-stack and --stop-stack are mutually exclusive")
+        keys = _runtime_keys(include_keychain=start_stack)
         if stop_stack:
             payload = stop_agent_core_runtime(keys=keys)
             payload["mojo_workers"] = _doctor_mojo_worker_diagnostics(keys)
@@ -869,7 +854,7 @@ def build_parser() -> argparse.ArgumentParser:
     pf.add_argument("--json", dest="as_json", action="store_true", help="emit the fix result as JSON")
     pf.add_argument("--max-iterations", dest="max_iterations", type=int, default=1,
                     help="with --tests --apply: re-fix up to N times until the tests pass (default: 1)")
-    pf.set_defaults(func=cmd_fix, uses_config=True)
+    pf.set_defaults(func=cmd_fix, uses_config=True, uses_model_config=True)
 
     pd = sub.add_parser("doctor", help="Inspect the owned local Codna runtime and optionally start agent-core.")
     pd.add_argument("--start-stack", action="store_true", help="Ensure the fixed local agent-core runtime is running.")
@@ -958,30 +943,48 @@ def build_parser() -> argparse.ArgumentParser:
     return p
 
 
+def _restore_environ(snapshot: dict[str, str] | None) -> None:
+    if snapshot is None:
+        return
+    os.environ.clear()
+    os.environ.update(snapshot)
+
+
 def main(argv=None) -> int:
     p = build_parser()
     args = p.parse_args(argv)
     if not getattr(args, "func", None):
         p.print_help()
         return 0
-    # Apply codna.yaml (model/privacy) — but ONLY for commands that consume it (fix/triage/secure), so a
-    # stray/broken ./codna.yaml can't fail-close unrelated commands (doctor/key/login/mcp). Explicit
-    # codna.yaml config is authoritative and overwrites the corresponding shell env vars before dispatch.
+    # Apply codna.yaml only at the scope a command consumes. Deterministic commands load privacy
+    # posture but must not require model keys; model-backed fix actions load the full model config.
+    # Snapshot/restore keeps embedded callers and tests from inheriting command-local config state.
+    env_snapshot: dict[str, str] | None = None
     if getattr(args, "uses_config", False) or getattr(args, "config", None):
         from .config_file import ConfigError, load_and_apply
+        env_snapshot = dict(os.environ)
         try:
-            load_and_apply(getattr(args, "config", None))
+            load_and_apply(
+                getattr(args, "config", None),
+                include_model=bool(getattr(args, "uses_model_config", False)),
+            )
         except ConfigError as exc:
+            _restore_environ(env_snapshot)
             print(json.dumps({"error": {"code": "config_error", "message": str(exc)}}, indent=2), file=sys.stderr)
             return 1
     try:
         result = args.func(args)
+    except CodnaError as exc:
+        print(json.dumps({"error": {"code": "cli_error", "message": str(exc), "details": {}}}, indent=2), file=sys.stderr)
+        return 1
     except Exception as exc:  # noqa: BLE001
         payload = _structured_error(exc)
         if payload is None:
             raise
         print(json.dumps(payload, indent=2), file=sys.stderr)
         return 1
+    finally:
+        _restore_environ(env_snapshot)
     return int(result) if isinstance(result, int) else 0
 
 

{codna-0.1.7 → codna-0.1.8}/codna/config_file.py

@@ -1,7 +1,9 @@
-"""``codna.yaml`` loader — applies ``model`` + ``privacy`` config into the process env before dispatch.
+"""``codna.yaml`` loader — applies command-relevant config before dispatch.
 
-Fail-closed on unresolved ``env:`` refs and unknown providers so config is never a silent no-op. YAML
-via PyYAML when present, else the file may be JSON (the same tolerant pattern as manifest loading).
+Fail-closed on unresolved ``env:`` refs and unknown providers when a command actually consumes the
+model configuration, so config is never a silent no-op for model-backed actions. Deterministic
+commands still load privacy posture without requiring an LLM key. YAML via PyYAML when present, else
+the file may be JSON (the same tolerant pattern as manifest loading).
 
 Mapping to real controls:
   - ``model.provider`` + ``model.key`` → the provider's ``*_API_KEY`` env (via ``keystore.PROVIDER_ALIASES``),
@@ -79,11 +81,11 @@ def discover_config_path(explicit: str | None = None) -> str | None:
     return None
 
 
-def apply_config(path: str) -> None:
+def apply_config(path: str, *, include_model: bool = True) -> None:
     data = _load(path)
 
     model = data.get("model") or {}
-    if model:
+    if include_model and model:
         provider = str(model.get("provider", "")).strip().lower()
         if not provider:
             raise ConfigError("model.provider is required when a model block is set")
@@ -108,9 +110,9 @@ def apply_config(path: str) -> None:
         )
 
 
-def load_and_apply(explicit: str | None = None) -> str | None:
+def load_and_apply(explicit: str | None = None, *, include_model: bool = True) -> str | None:
     """Discover + apply a codna.yaml. Returns the path applied (or None). Raises ConfigError."""
     path = discover_config_path(explicit)
     if path:
-        apply_config(path)
+        apply_config(path, include_model=include_model)
     return path

{codna-0.1.7 → codna-0.1.8}/codna/fix_inputs.py

@@ -5,6 +5,7 @@ extraction and PR-body rendering. Split out of ``cli.py`` to keep it under the m
 from __future__ import annotations
 
 import os
+import subprocess
 
 
 class FixInputError(Exception):
@@ -24,6 +25,46 @@ def from_junit(path: str):
     return f"{len(failing)} failing test(s): " + "; ".join(failing[:8]), failing
 
 
+def _clean_git_head(repo_dir: str) -> str | None:
+    try:
+        head = subprocess.run(
+            ["git", "rev-parse", "--verify", "HEAD"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=10,
+        )
+        if head.returncode != 0:
+            return None
+        status = subprocess.run(
+            ["git", "status", "--porcelain=v1", "-z", "--untracked-files=all"],
+            cwd=repo_dir,
+            capture_output=True,
+            check=False,
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if status.returncode != 0 or status.stdout:
+        return None
+    revision = head.stdout.strip()
+    return revision if len(revision) == 40 else None
+
+
+def _discover_failing_tests_for_fix(repo_dir: str, test_cmd: str | None):
+    from .testrun import discover_failing_tests
+
+    head = _clean_git_head(repo_dir)
+    if head is None:
+        return discover_failing_tests(repo_dir, test_cmd)
+
+    from .worktree import EphemeralWorktree
+
+    with EphemeralWorktree(repo_dir, head, prefix="codna-test-discovery-") as worktree:
+        return discover_failing_tests(worktree.path, test_cmd)
+
+
 def resolve_issue(args):
     """Resolve ``(issue_text, failing_test_ids)`` from the fix args. Raises FixInputError on bad input.
 
@@ -39,11 +80,9 @@ def resolve_issue(args):
         return (args.issue or issue), merged
 
     if getattr(args, "tests", False):
-        from .testrun import discover_failing_tests
-
         repo_dir = os.path.abspath(os.path.expanduser(getattr(args, "repo", ".") or "."))
         try:
-            issue, failing = discover_failing_tests(repo_dir, getattr(args, "test_cmd", None))
+            issue, failing = _discover_failing_tests_for_fix(repo_dir, getattr(args, "test_cmd", None))
         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.1.7 → codna-0.1.8}/codna/fix_run.py

@@ -13,7 +13,9 @@ you don't iterate a pushed PR from here).
 from __future__ import annotations
 
 import os
+import subprocess
 import time
+from pathlib import Path
 
 from .fix_inputs import FixInputError, pr_body, resolve_issue, sim_id
 
@@ -66,6 +68,57 @@ def _plan_once(c, *, repo, ref, issue, failing, model, open_pr, gh_token):
     return rid, snap, plan
 
 
+_GENERATED_APPLY_ARTIFACTS = (".algenta.patch.diff", ".codna-packaged.patch.diff")
+
+
+def _snapshot_generated_apply_artifacts(repo: str) -> dict[str, bool]:
+    root = Path(os.path.abspath(os.path.expanduser(repo)))
+    return {name: (root / name).exists() for name in _GENERATED_APPLY_ARTIFACTS}
+
+
+def _is_untracked_file(repo_root: Path, path: Path) -> bool:
+    try:
+        relative = path.relative_to(repo_root).as_posix()
+    except ValueError:
+        return False
+    result = subprocess.run(
+        ["git", "-C", str(repo_root), "ls-files", "--others", "--exclude-standard", "--", relative],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=10,
+    )
+    return result.returncode == 0 and relative in {line.strip() for line in result.stdout.splitlines()}
+
+
+def _cleanup_generated_apply_artifacts(checkout: str | None, before: dict[str, bool]) -> None:
+    if not checkout:
+        return
+    repo_root = Path(os.path.abspath(os.path.expanduser(checkout)))
+    for name in _GENERATED_APPLY_ARTIFACTS:
+        if before.get(name):
+            continue
+        path = repo_root / name
+        if path.is_file() and _is_untracked_file(repo_root, path):
+            path.unlink()
+
+
+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)
+
+
 def _apply_once(c, rid, snap, plan, *, open_pr, args, issue, summary):
     from . import cli as _cli
 
@@ -115,13 +168,13 @@ def run_fix(c, args) -> dict:
         if not gh_token:
             _cli._die("--open-pr needs a write token: pass --github-token or set GITHUB_TOKEN.")
 
-    verify = bool(getattr(args, "tests", False)) and apply and not open_pr
+    verify = (bool(getattr(args, "tests", False)) or bool(getattr(args, "test_cmd", None))) and apply and not open_pr
     max_iterations = max(1, int(getattr(args, "max_iterations", 1) or 1)) if verify else 1
 
     t0 = time.perf_counter()
     repo = args.repo
     result: dict = {"repository": repo, "issue": issue, "iterations": [], "applied": None,
-                    "verified": None, "remaining_failing_tests": None}
+                    "verified": None, "remaining_failing_tests": None, "pull_request_url": None}
 
     for i in range(max_iterations):
         try:
@@ -142,8 +195,11 @@ def run_fix(c, args) -> dict:
             result["elapsed_s"] = round(time.perf_counter() - t0, 1)
             return result
 
+        apply_artifacts_before = _snapshot_generated_apply_artifacts(repo) if apply and not open_pr else {}
         try:
             applied = _apply_once(c, rid, snap, plan, open_pr=open_pr, args=args, issue=issue, summary=summary)
+            if applied.get("mode") == "local_branch":
+                _cleanup_generated_apply_artifacts(applied.get("local_checkout_path"), apply_artifacts_before)
         except Exception as exc:  # noqa: BLE001 — mirror the old cmd_fix: ALL apply errors (incl. a
             # CodnaError from the remote engine's risk gate, or a missing sim id) get the 'apply failed:'
             # framing + the patch-ref recovery hint, so the user can still apply the generated patch.
@@ -153,6 +209,10 @@ def run_fix(c, args) -> dict:
             ) from exc
         iteration["applied"] = applied
         result["applied"] = applied
+        # Surface the PR URL at the top level so `--json` consumers (the GitHub Action) read one
+        # stable field instead of scraping human output with a regex.
+        if applied.get("mode") == "remote_pr" and applied.get("pull_request_url"):
+            result["pull_request_url"] = applied["pull_request_url"]
 
         if not verify:
             result["iterations"].append(iteration)
@@ -166,9 +226,7 @@ def run_fix(c, args) -> dict:
             result["verified"] = False
             result["iterations"].append(iteration)
             break
-        from .testrun import discover_failing_tests
-
-        verify_issue, still_failing = discover_failing_tests(checkout, getattr(args, "test_cmd", None))
+        verify_issue, still_failing = _verify_applied_checkout(applied, getattr(args, "test_cmd", None))
         # GREEN iff discover reports no failure at all. `still_failing` can be [] even when the tests
         # FAILED (custom --test-cmd with no JUnit / a collection error) — in that case verify_issue is a
         # non-None "tests are failing …" string, so keying greenness on the id-list alone would falsely