codna 0.1.22__tar.gz → 0.1.24__tar.gz

{codna-0.1.22 → codna-0.1.24}/PKG-INFO

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

{codna-0.1.22 → codna-0.1.24}/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.22"
+__version__ = "0.1.24"

{codna-0.1.22 → codna-0.1.24}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/home/runner/work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/home/runner/work/codna/codna/cli/codna-0.1.24/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.1.22 → codna-0.1.24}/codna/fix_run.py

@@ -12,6 +12,7 @@ you don't iterate a pushed PR from here).
 """
 from __future__ import annotations
 
+import contextlib
 import os
 import subprocess
 import time
@@ -19,6 +20,8 @@ from pathlib import Path
 
 from .fix_inputs import FixInputError, pr_body, resolve_issue, sim_id
 
+_REPOSITORY_AGENTIC_MODEL = "repository.verified_agentic_v1"
+
 
 def summarize_plan(plan: dict) -> dict:
     """Extract the stable fields the CLI reports (human + JSON) from a decision plan."""
@@ -80,6 +83,40 @@ def _int_or_zero(value) -> int:
     return 0
 
 
+def _decision_plan_model_and_agent_env(model: str | None) -> tuple[str, dict[str, str]]:
+    requested = (model or "").strip()
+    if not requested:
+        return _REPOSITORY_AGENTIC_MODEL, {}
+    if requested.startswith("repository."):
+        return requested, {}
+    if "/" not in requested:
+        return _REPOSITORY_AGENTIC_MODEL, {"ALGENTA_AGENT_MODEL": requested}
+    provider, model_id = requested.split("/", 1)
+    provider = provider.strip()
+    model_id = model_id.strip()
+    if not provider or not model_id:
+        return _REPOSITORY_AGENTIC_MODEL, {"ALGENTA_AGENT_MODEL": requested}
+    return _REPOSITORY_AGENTIC_MODEL, {
+        "ALGENTA_AGENT_PROVIDER": provider,
+        "ALGENTA_AGENT_MODEL": model_id,
+    }
+
+
+@contextlib.contextmanager
+def _scoped_agent_env(updates: dict[str, str]):
+    previous = {key: os.environ.get(key) for key in updates}
+    try:
+        for key, value in updates.items():
+            os.environ[key] = value
+        yield
+    finally:
+        for key, value in previous.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+
+
 def attach_usage_totals(result: dict) -> dict:
     """Expose aggregate model usage at the top level for scriptable ``codna fix --json`` users."""
     totals = {
@@ -137,12 +174,14 @@ def _plan_once(c, *, repo, ref, issue, failing, model, open_pr, gh_token):
         if guidance:
             sig["project_guidance"] = guidance
     tri = _cli._dump(c.triage_repository(rid, {"snapshot_id": snap["snapshot_id"], "signals": sig}))
-    plan = _cli._dump(c.create_repository_decision_plan(rid, {
-        "snapshot_id": snap["snapshot_id"],
-        "workspace_evidence_bundle_ref": tri.get("workspace_evidence_bundle_ref"),
-        "signals": sig,
-        "model": model,
-    }))
+    plan_model, agent_env = _decision_plan_model_and_agent_env(model)
+    with _scoped_agent_env(agent_env):
+        plan = _cli._dump(c.create_repository_decision_plan(rid, {
+            "snapshot_id": snap["snapshot_id"],
+            "workspace_evidence_bundle_ref": tri.get("workspace_evidence_bundle_ref"),
+            "signals": sig,
+            "model": plan_model,
+        }))
     return rid, snap, plan
 
 

{codna-0.1.22 → codna-0.1.24}/codna/local_mojo_pool.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from types import ModuleType
 from typing import Any
 
-from .python_import_paths import compatible_engine_site_packages, site_packages_python_version
+from .python_import_paths import compatible_engine_site_packages
 from .runtime.config import RuntimeConfig
 
 LOCAL_MOJO_WARMUP_PAYLOAD = {

{codna-0.1.22 → codna-0.1.24}/codna/local_repository_shims.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import difflib
 import importlib
+import os
 import re
 import sys
 from pathlib import Path
@@ -100,7 +101,7 @@ def install_repository_module_suffix_support() -> None:
 
 
 def install_verified_agentic_diff_compatibility() -> None:
-    """Patch local Algenta verified-agentic diffs so `git apply` accepts them."""
+    """Patch local Algenta verified-agentic behavior for Codna's local runtime contract."""
     try:
         verified_agentic = _load_repository_module(
             "apps.api_server.services.repository_intelligence_verified_agentic"
@@ -122,19 +123,62 @@ def install_verified_agentic_diff_compatibility() -> None:
             "Local Algenta verified-agentic module is missing _unified_diff_from_tree_states.",
             {"module": verified_agentic.__name__},
         )
-    if getattr(current, "_codna_git_apply_compatible", False):
+    if not getattr(current, "_codna_git_apply_compatible", False):
+
+        def unified_diff_from_tree_states(before: dict[str, str], after: dict[str, str]) -> str:
+            return git_apply_compatible_unified_diff_from_tree_states(before, after)
+
+        unified_diff_from_tree_states.__name__ = "_unified_diff_from_tree_states"
+        unified_diff_from_tree_states.__qualname__ = "_unified_diff_from_tree_states"
+        unified_diff_from_tree_states.__module__ = verified_agentic.__name__
+        unified_diff_from_tree_states._codna_git_apply_compatible = True  # type: ignore[attr-defined]
+        verified_agentic._unified_diff_from_tree_states = unified_diff_from_tree_states
+        if hasattr(planner_generation, "_unified_diff_from_tree_states"):
+            planner_generation._unified_diff_from_tree_states = unified_diff_from_tree_states
+    _install_verified_agentic_agent_model_env_support(verified_agentic)
+
+
+def _install_verified_agentic_agent_model_env_support(verified_agentic: ModuleType) -> None:
+    original = getattr(verified_agentic, "_run_agent_with_failover", None)
+    if original is None:
+        raise LocalRepositoryShimError(
+            "local_repository_verified_agentic_model_env_shim_missing_target",
+            "Local Algenta verified-agentic module is missing _run_agent_with_failover.",
+            {"module": verified_agentic.__name__},
+        )
+    if getattr(original, "_codna_agent_model_env_support", False):
         return
 
-    def unified_diff_from_tree_states(before: dict[str, str], after: dict[str, str]) -> str:
-        return git_apply_compatible_unified_diff_from_tree_states(before, after)
+    async def run_agent_with_failover(
+        run_agent,
+        *,
+        working_dir,
+        task_spec,
+        injected_context,
+        limits,
+        root_path,
+    ):
+        provider = os.environ.get("ALGENTA_AGENT_PROVIDER") or None
+        model = os.environ.get("ALGENTA_AGENT_MODEL") or None
+        if provider or model:
+            task_spec = dict(task_spec)
+            engine = task_spec.get("engine")
+            engine = dict(engine) if isinstance(engine, dict) else {}
+            task_spec["engine"] = engine
+        return await original(
+            run_agent,
+            working_dir=working_dir,
+            task_spec=task_spec,
+            injected_context=injected_context,
+            limits=limits,
+            root_path=root_path,
+        )
 
-    unified_diff_from_tree_states.__name__ = "_unified_diff_from_tree_states"
-    unified_diff_from_tree_states.__qualname__ = "_unified_diff_from_tree_states"
-    unified_diff_from_tree_states.__module__ = verified_agentic.__name__
-    unified_diff_from_tree_states._codna_git_apply_compatible = True  # type: ignore[attr-defined]
-    verified_agentic._unified_diff_from_tree_states = unified_diff_from_tree_states
-    if hasattr(planner_generation, "_unified_diff_from_tree_states"):
-        planner_generation._unified_diff_from_tree_states = unified_diff_from_tree_states
+    run_agent_with_failover.__name__ = "_run_agent_with_failover"
+    run_agent_with_failover.__qualname__ = "_run_agent_with_failover"
+    run_agent_with_failover.__module__ = verified_agentic.__name__
+    run_agent_with_failover._codna_agent_model_env_support = True  # type: ignore[attr-defined]
+    verified_agentic._run_agent_with_failover = run_agent_with_failover
 
 
 def install_patch_artifact_newline_preservation() -> None:

{codna-0.1.22 → codna-0.1.24}/codna/mcp_server.py

@@ -9,8 +9,10 @@ the same engine client the CLI uses. Add to your MCP config:
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import json
 import os
+from pathlib import Path
 
 from .cli import _client, _dump, _register
 
@@ -23,6 +25,22 @@ def _default_repo(repo: str) -> str:
     return os.environ.get("CODNA_MCP_DEFAULT_REPO") or "."
 
 
+def _mcp_memory_root() -> Path:
+    override = (os.environ.get("CODNA_TELYS_MEMORY_ROOT") or "").strip()
+    if override:
+        return Path(override).expanduser().resolve(strict=False)
+    return (Path.home() / ".codna" / "telys-memory").resolve(strict=False)
+
+
+def _mcp_memory_db_path(repo: str) -> str:
+    """Store background MCP recall indexes outside the user's git checkout."""
+    from .memory import repo_id_for
+
+    repo_id = repo_id_for(repo)
+    digest = hashlib.sha256(repo_id.encode("utf-8")).hexdigest()[:24]
+    return str(_mcp_memory_root() / "mcp" / digest)
+
+
 def recall_json(repo: str = ".", query: str = "", service: str = "", language: str = "",
                 final_k: int = 8) -> str:
     """Return local Telys memory recall as JSON without crashing the MCP server."""
@@ -32,7 +50,7 @@ def recall_json(repo: str = ".", query: str = "", service: str = "", language: s
     try:
         from .memory import CodeMemory
 
-        mem = CodeMemory(repo, service=service or None)
+        mem = CodeMemory(repo, db_path=_mcp_memory_db_path(repo), service=service or None)
         if mem.is_empty():
             mem.index(languages=(language,) if language else None)
         res = mem.recall(query, service=service or None, language=language or None, final_k=final_k)

{codna-0.1.22 → codna-0.1.24}/codna/packaged_repository_backend.py

@@ -17,6 +17,8 @@ SCHEMA_VERSION = 1
 BACKEND_MODE = "packaged_local_triage"
 MAX_SAMPLE_BYTES = 64 * 1024
 MAX_SNIPPET_CHARS = 900
+SNIPPET_CONTEXT_BEFORE = 4
+SNIPPET_CONTEXT_AFTER = 6
 MAX_EVIDENCE_ITEMS = 10
 TOKEN_BYTES = 4
 
@@ -236,6 +238,12 @@ class PackagedRepositoryBackendError(RuntimeError):
         self.details = details or {}
 
 
+@dataclass(frozen=True)
+class SnippetSelection:
+    snippet: str
+    symbol: str | None
+
+
 @dataclass(frozen=True)
 class FileEntry:
     path: str
@@ -713,8 +721,8 @@ def _score_entry(entry: FileEntry, terms: set[str], changed_files: set[str]) ->
 
 
 def _evidence_item(*, rank: int, entry: FileEntry, score: float, query: str) -> dict[str, Any]:
-    snippet = _snippet(entry.sample, _query_terms(query))
-    symbol = _top_symbol(entry.sample)
+    selection = _snippet_selection(entry.sample, _query_terms(query))
+    snippet = selection.snippet
     return {
         "evidence_id": "ev_" + _sha256_text(f"{rank}|{entry.path}|{entry.sample_sha256}")[:16],
         "rank": rank,
@@ -722,31 +730,74 @@ def _evidence_item(*, rank: int, entry: FileEntry, score: float, query: str) ->
         "source_ref": entry.path,
         "summary": f"{entry.path} ({entry.language}, {entry.token_estimate} estimated tokens)",
         "snippet": snippet,
-        "token_count": max(1, len(snippet.encode("utf-8")) // TOKEN_BYTES),
+        "token_count": min(max(1, entry.token_estimate), max(1, len(snippet.encode("utf-8")) // TOKEN_BYTES)),
         "score": float(score),
         "file_path": entry.path,
-        "symbol_name": symbol,
+        "symbol_name": selection.symbol,
     }
 
 
-def _snippet(sample: str, terms: set[str]) -> str:
+def _snippet_selection(sample: str, terms: set[str]) -> SnippetSelection:
     lines = [line.rstrip() for line in sample.splitlines()]
-    selected = ""
-    for line in lines:
-        line_lower = line.lower()
-        if any(term.lower() in line_lower for term in terms):
-            selected = line
-            break
-    if not selected:
-        selected = next((line for line in lines if line.strip()), "")
-    if len(selected) > MAX_SNIPPET_CHARS:
-        return selected[: MAX_SNIPPET_CHARS - 3] + "..."
-    return selected
-
-
-def _top_symbol(sample: str) -> str | None:
-    match = SYMBOL_RE.search(sample)
-    return match.group(1) if match else None
+    if not lines:
+        return SnippetSelection(snippet="", symbol=None)
+    selected_index = _best_snippet_line_index(lines, terms)
+    snippet = _numbered_context_window(lines, selected_index)
+    if len(snippet) > MAX_SNIPPET_CHARS:
+        snippet = snippet[: MAX_SNIPPET_CHARS - 3] + "..."
+    return SnippetSelection(snippet=snippet, symbol=_nearest_symbol(lines, selected_index))
+
+
+def _best_snippet_line_index(lines: list[str], terms: set[str]) -> int:
+    best_index = -1
+    best_score = 0
+    for index, line in enumerate(lines):
+        score = _snippet_line_score(line, terms)
+        if score > best_score:
+            best_score = score
+            best_index = index
+    if best_index >= 0:
+        return best_index
+    for index, line in enumerate(lines):
+        if line.strip():
+            return index
+    return 0
+
+
+def _snippet_line_score(line: str, terms: set[str]) -> int:
+    stripped = line.strip()
+    lower = stripped.lower()
+    score = 0
+    for term in terms:
+        normalized = term.lower()
+        count = lower.count(normalized)
+        if count:
+            score += count * (3 + min(len(normalized) // 4, 4))
+    if score and SYMBOL_RE.match(line):
+        score += 10
+    if score and stripped.startswith(("return ", "raise ", "assert ")):
+        score += 3
+    if score and stripped.startswith(("import ", "from ")):
+        score = max(1, score - 5)
+    return score
+
+
+def _numbered_context_window(lines: list[str], selected_index: int) -> str:
+    start = max(0, selected_index - SNIPPET_CONTEXT_BEFORE)
+    end = min(len(lines), selected_index + SNIPPET_CONTEXT_AFTER + 1)
+    return "\n".join(f"{index + 1:6}\t{lines[index]}" for index in range(start, end))
+
+
+def _nearest_symbol(lines: list[str], selected_index: int) -> str | None:
+    for index in range(selected_index, -1, -1):
+        match = SYMBOL_RE.match(lines[index])
+        if match:
+            return match.group(1)
+    for index in range(selected_index + 1, len(lines)):
+        match = SYMBOL_RE.match(lines[index])
+        if match:
+            return match.group(1)
+    return None
 
 
 def _suspect_symbols(evidence_items: list[dict[str, Any]]) -> list[str]:

{codna-0.1.22 → codna-0.1.24}/codna.egg-info/PKG-INFO

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

{codna-0.1.22 → codna-0.1.24}/pyproject.toml

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

{codna-0.1.22 → codna-0.1.24}/setup.py

@@ -120,6 +120,7 @@ def _prepare_agent_core_workspace(source: Path, *, bun: str, env: dict[str, str]
 
 
 def _ensure_agent_core_bundle(source: Path) -> Path:
+    source = source.expanduser().resolve()
     bundle = source / AGENT_CORE_BUNDLE_NAME
     if bundle.is_file() and bundle.stat().st_size > 0:
         return bundle
@@ -158,8 +159,8 @@ def _ensure_agent_core_bundle(source: Path) -> Path:
 
 
 def _copy_agent_core_runtime(destination: Path) -> None:
-    source = _source_agent_core_dir()
-    _ensure_agent_core_bundle(source)
+    source = _source_agent_core_dir().expanduser().resolve()
+    destination = destination.expanduser().resolve()
     if destination.exists():
         shutil.rmtree(destination)
 
@@ -167,6 +168,21 @@ def _copy_agent_core_runtime(destination: Path) -> None:
         return {name for name in names if _is_excluded_agent_core_name(name)}
 
     shutil.copytree(source, destination, ignore=ignore)
+    _ensure_agent_core_bundle(destination)
+    _remove_agent_core_generated_paths(destination)
+
+
+def _remove_agent_core_generated_paths(root: Path) -> None:
+    generated_names = {"node_modules", ".turbo", "build", "dist"}
+    for path in sorted(
+        (candidate for candidate in root.rglob("*") if candidate.name in generated_names),
+        key=lambda candidate: len(candidate.parts),
+        reverse=True,
+    ):
+        if path.is_symlink() or path.is_file():
+            path.unlink(missing_ok=True)
+        elif path.is_dir():
+            shutil.rmtree(path, ignore_errors=True)
 
 
 def _remove_python_bytecode(root: Path) -> None:

{codna-0.1.22 → codna-0.1.24}/tests/test_fix_run.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 
 
 from codna import cli, fix_run
@@ -88,6 +89,82 @@ def test_fix_json_exposes_top_level_usage_totals(monkeypatch):
     assert result["iterations"][0]["summary"]["total_tokens"] == 3495
 
 
+def test_plan_once_routes_provider_model_to_sidecar_agent_env(monkeypatch, tmp_path):
+    captured = {}
+
+    class Client:
+        def triage_repository(self, _repository_id, _request):
+            return {"workspace_evidence_bundle_ref": "bundle-1"}
+
+        def create_repository_decision_plan(self, _repository_id, request):
+            captured["request"] = dict(request)
+            captured["agent_provider"] = os.environ.get("ALGENTA_AGENT_PROVIDER")
+            captured["agent_model"] = os.environ.get("ALGENTA_AGENT_MODEL")
+            return _plan(model="gpt-5.5")
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    monkeypatch.delenv("ALGENTA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("ALGENTA_AGENT_MODEL", raising=False)
+    monkeypatch.setattr(cli, "_register", lambda *_args, **_kwargs: ("rid", {"snapshot_id": "snap-1"}))
+    monkeypatch.setattr(cli, "_issue_focus_paths", lambda *_args, **_kwargs: [])
+    monkeypatch.setattr(cli, "_dump", lambda value: value)
+
+    fix_run._plan_once(
+        Client(),
+        repo=str(repo),
+        ref=None,
+        issue="broken",
+        failing=[],
+        model="openai-native/gpt-5.5",
+        open_pr=False,
+        gh_token=None,
+    )
+
+    assert captured["request"]["model"] == "repository.verified_agentic_v1"
+    assert captured["agent_provider"] == "openai-native"
+    assert captured["agent_model"] == "gpt-5.5"
+    assert "ALGENTA_AGENT_PROVIDER" not in os.environ
+    assert "ALGENTA_AGENT_MODEL" not in os.environ
+
+
+def test_plan_once_preserves_repository_planner_model(monkeypatch, tmp_path):
+    captured = {}
+
+    class Client:
+        def triage_repository(self, _repository_id, _request):
+            return {"workspace_evidence_bundle_ref": "bundle-1"}
+
+        def create_repository_decision_plan(self, _repository_id, request):
+            captured["request"] = dict(request)
+            captured["agent_provider"] = os.environ.get("ALGENTA_AGENT_PROVIDER")
+            captured["agent_model"] = os.environ.get("ALGENTA_AGENT_MODEL")
+            return _plan(model="repository.deterministic_local_v1")
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    monkeypatch.delenv("ALGENTA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("ALGENTA_AGENT_MODEL", raising=False)
+    monkeypatch.setattr(cli, "_register", lambda *_args, **_kwargs: ("rid", {"snapshot_id": "snap-1"}))
+    monkeypatch.setattr(cli, "_issue_focus_paths", lambda *_args, **_kwargs: [])
+    monkeypatch.setattr(cli, "_dump", lambda value: value)
+
+    fix_run._plan_once(
+        Client(),
+        repo=str(repo),
+        ref=None,
+        issue="broken",
+        failing=[],
+        model="repository.deterministic_local_v1",
+        open_pr=False,
+        gh_token=None,
+    )
+
+    assert captured["request"]["model"] == "repository.deterministic_local_v1"
+    assert captured["agent_provider"] is None
+    assert captured["agent_model"] is None
+
+
 def test_apply_local_branch(monkeypatch):
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     monkeypatch.setattr(fix_run, "_apply_once",

{codna-0.1.22 → codna-0.1.24}/tests/test_local_client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import os
 import subprocess
 import sys
@@ -216,11 +217,56 @@ def test_local_client_uses_packaged_backend_for_clean_install_triage(tmp_path, m
     assert triage["backend_mode"] == "packaged_local_triage"
     assert triage["suspect_files"][0] == "src/payment.py"
     assert triage["workspace_evidence_bundle_ref"].startswith("packaged-local://")
-    assert triage["raw_repo_token_estimate"] > triage["evidence_bundle_token_count"]
+    assert triage["raw_repo_token_estimate"] >= triage["evidence_bundle_token_count"]
     artifacts = list((tmp_path / ".codna" / "repository-intelligence" / "steps").glob("**/step.parquet"))
     assert len(artifacts) == 2
 
 
+def test_packaged_triage_snippet_prefers_strong_function_match_over_import(tmp_path, monkeypatch) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    package = repo / "jmespath"
+    package.mkdir()
+    (package / "functions.py").write_text(
+        "from jmespath import exceptions\n\n"
+        "def _func_ends_with(search, suffix):\n"
+        "    return search.endswith(suffix)\n\n"
+        "def _func_join(separator, array):\n"
+        "    return \"\".join(array)\n",
+        encoding="utf-8",
+    )
+    monkeypatch.delenv("ALGENTA_ENGINE_DIR", raising=False)
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    monkeypatch.setattr(local_client_module, "_import_repository_modules", _raise_missing_apps_backend)
+
+    client = LocalCodnaRuntimeClient()
+    connector = client.create_connector(
+        name="jmespath",
+        connector_type="local_repo",
+        config={"path": str(repo)},
+    )
+    snapshot = client.create_repository_snapshot(connector["id"], {})
+    triage = client.triage_repository(
+        connector["id"],
+        {
+            "snapshot_id": snapshot["snapshot_id"],
+            "signals": {
+                "issue_text": (
+                    "Regression: jmespath join ignores the separator. "
+                    "join(`-`, items) returns alphabetagamma. Fix the join implementation."
+                )
+            },
+        },
+    )
+
+    top = triage["evidence_items"][0]
+    assert top["file_path"] == "jmespath/functions.py"
+    assert top["symbol_name"] == "_func_join"
+    assert "_func_join" in top["snippet"]
+    assert "return \"\".join(array)" in top["snippet"]
+    assert top["snippet"].strip().splitlines()[0] != "from jmespath import exceptions"
+
+
 def test_local_client_does_not_mask_explicit_algenta_engine_dir_failure(tmp_path, monkeypatch) -> None:
     engine_dir = tmp_path / "broken-engine"
     engine_dir.mkdir()
@@ -769,6 +815,67 @@ def test_patch_artifact_read_preserves_crlf_payload_lines(tmp_path) -> None:
     assert text.encode("utf-8") == patch_bytes
 
 
+def test_verified_agentic_model_env_shim_supplies_provider_without_engine_url(monkeypatch) -> None:
+    captured = {}
+    verified_agentic = ModuleType("apps.api_server.services.repository_intelligence_verified_agentic")
+    planner_generation = ModuleType("apps.api_server.services.repository_intelligence_planner_generation")
+
+    def original_diff(_before, _after):
+        return ""
+
+    async def original_run_agent_with_failover(
+        _run_agent,
+        *,
+        working_dir,
+        task_spec,
+        injected_context,
+        limits,
+        root_path,
+    ):
+        captured["working_dir"] = working_dir
+        captured["task_spec"] = task_spec
+        captured["injected_context"] = injected_context
+        captured["limits"] = limits
+        captured["root_path"] = root_path
+        engine = task_spec.get("engine") if isinstance(task_spec.get("engine"), dict) else None
+        if engine is not None:
+            provider = os.environ.get("ALGENTA_AGENT_PROVIDER") or None
+            model = os.environ.get("ALGENTA_AGENT_MODEL") or None
+            if provider is not None:
+                engine["provider"] = provider
+            if model is not None:
+                engine["model"] = model
+        return {"status": "succeeded"}
+
+    verified_agentic._unified_diff_from_tree_states = original_diff
+    verified_agentic._run_agent_with_failover = original_run_agent_with_failover
+    planner_generation._unified_diff_from_tree_states = original_diff
+    monkeypatch.setitem(sys.modules, verified_agentic.__name__, verified_agentic)
+    monkeypatch.setitem(sys.modules, planner_generation.__name__, planner_generation)
+    monkeypatch.setenv("ALGENTA_AGENT_PROVIDER", "openai-native")
+    monkeypatch.setenv("ALGENTA_AGENT_MODEL", "gpt-5.5")
+
+    local_client_module._install_verified_agentic_diff_compatibility()
+    result = asyncio.run(
+        verified_agentic._run_agent_with_failover(
+            lambda **_kwargs: {"status": "succeeded"},
+            working_dir="/repo",
+            task_spec={"issue_text": "broken"},
+            injected_context={"evidence": []},
+            limits={"max_turns": 4},
+            root_path=Path("/repo"),
+        )
+    )
+
+    assert result == {"status": "succeeded"}
+    assert captured["task_spec"]["engine"] == {
+        "provider": "openai-native",
+        "model": "gpt-5.5",
+    }
+    assert "url" not in captured["task_spec"]["engine"]
+    assert captured["working_dir"] == "/repo"
+
+
 def test_local_client_snapshot_uses_in_process_connector_and_runtime_env(tmp_path, monkeypatch) -> None:
     captured = {}