codna 0.2.99__tar.gz → 0.2.101__tar.gz

{codna-0.2.99 → codna-0.2.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.99
+Version: 0.2.101
 Summary: Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.99 → codna-0.2.101}/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.99"
+__version__ = "0.2.101"

{codna-0.2.99 → codna-0.2.101}/codna/config_file.py

@@ -13,8 +13,9 @@ Mapping to real controls:
     provider.
   - ``model.base_url`` → ``CODNA_AGENT_BASE_URL``, the provider ENDPOINT override forwarded to the sidecar.
     A base URL decides where the provider credential is sent, so it is validated here (http/https, no
-    embedded credentials, no query/fragment) and it may come from THIS file or the environment only — never
-    from a repository-scoped settings file. ``env:NAME`` resolves the same way as ``model.key``.
+    embedded credentials, no query/fragment, plain HTTP only on loopback) and it may come from THIS
+    file or the environment only — never from a repository-scoped settings file. ``env:NAME`` resolves
+    the same way as ``model.key``.
   - ``privacy.egress: fail-closed`` → sets ``CODNA_REQUIRE_EGRESS_DENY=1`` (the real enforcement is the
     sandbox network-deny policy + the PR manifest gate; there is no global egress env otherwise).
   - ``privacy.redact_secrets`` → accept-and-warn: ``true`` is the posture; ``false`` is *ignored with a
@@ -28,6 +29,7 @@ import sys
 from urllib.parse import urlsplit
 
 from .keystore import PROVIDER_ALIASES
+from .provider_url import is_loopback_host
 
 _SEARCH = ("codna.yaml", ".codna.yaml")
 
@@ -116,8 +118,11 @@ def _validated_base_url(value: object, *, field: str) -> str:
     Fail-closed on every shape that could smuggle something past the consumer: a non-http(s) scheme, an
     embedded credential (``https://user:pass@host`` puts secrets in logs and in every request), a query or
     fragment (silently dropped by every consumer, so the config would lie about itself), and whitespace.
-    The trailing slash is removed so the consumer's ``${base}/v1`` cannot become ``//v1``.
+    Plain HTTP is restricted to loopback so a provider key cannot cross the network in cleartext. The
+    trailing slash is removed so the consumer's ``${base}/v1`` cannot become ``//v1``.
     """
+    if value is not None and not isinstance(value, str):
+        raise ConfigError(f"{field} must be a string URL")
     text = str(value or "").strip()
     if not text:
         raise ConfigError(f"{field} must not be blank")
@@ -128,10 +133,14 @@ def _validated_base_url(value: object, *, field: str) -> str:
         raise ConfigError(f"{field} must be an http(s) URL, got {parts.scheme or 'no scheme'!r}")
     if not parts.hostname:
         raise ConfigError(f"{field} must name a host")
-    if parts.username or parts.password:
+    if parts.username is not None or parts.password is not None:
         raise ConfigError(f"{field} must not embed credentials")
     if parts.query or parts.fragment:
         raise ConfigError(f"{field} must not carry a query string or fragment")
+    if parts.scheme == "http" and not is_loopback_host(parts.hostname):
+        raise ConfigError(
+            f"{field} over plain http must point at loopback; a remote endpoint must use https"
+        )
     path = parts.path.rstrip("/")
     netloc = parts.netloc
     return f"{parts.scheme}://{netloc}{path}"

{codna-0.2.99 → codna-0.2.101}/codna/durable/__init__.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import importlib
 import importlib.util
+import re
 import types
 from dataclasses import dataclass
 from typing import Final
@@ -55,8 +56,15 @@ class Requirement:
     minimum: tuple[int, ...]
     maximum: tuple[int, ...]
 
-    def accepts(self, version: tuple[int, ...]) -> bool:
-        return self.minimum <= version < self.maximum
+    def accepts(self, version: tuple[tuple[int, ...], bool]) -> bool:
+        release, prerelease = version
+        width = max(len(release), len(self.minimum), len(self.maximum))
+        release = release + (0,) * (width - len(release))
+        minimum = self.minimum + (0,) * (width - len(self.minimum))
+        maximum = self.maximum + (0,) * (width - len(self.maximum))
+        if prerelease:
+            return minimum < release <= maximum
+        return minimum <= release < maximum
 
 
 # The checkpoint package is pinned as well as declared in the extra because it carries the
@@ -154,14 +162,11 @@ class DurableStack:
     versions: dict[str, str]
 
 
-def _parse_version(raw: str) -> tuple[int, ...]:
-    """Parse the leading numeric release of a version string (``1.34.0b2`` → ``(1, 34, 0)``).
-
-    Deliberately tiny: this must not add a ``packaging`` dependency to a base install. Only the
-    release segment matters for the compatibility window; a pre-release sorts inside its range.
-    """
+def _parse_version(raw: str) -> tuple[tuple[int, ...], bool]:
+    """Return the numeric release and whether it is a prerelease, without a packaging dependency."""
+    base = raw.split("+", 1)[0]
     release: list[int] = []
-    for part in raw.split("+", 1)[0].split("-", 1)[0].split("."):
+    for part in base.split("-", 1)[0].split("."):
         digits = ""
         for char in part:
             if not char.isdigit():
@@ -172,7 +177,8 @@ def _parse_version(raw: str) -> tuple[int, ...]:
         release.append(int(digits))
     if not release:
         raise ValueError(f"unparseable version {raw!r}")
-    return tuple(release)
+    prerelease = re.search(r"(?i)(dev|a|alpha|b|beta|rc|c|pre|preview)[.-]?\d*$", base) is not None
+    return tuple(release), prerelease
 
 
 def _installed_version(distribution: str) -> str | None:

{codna-0.2.99 → codna-0.2.101}/codna/durable/activity_steps.py

@@ -307,7 +307,7 @@ def checkpoint_turn(request: CheckpointRequest) -> CheckpointOutcome:
     # the task's own checkout dirty and its branch pointing at a commit the worktree never saw.
     tree = ensure_checkout(active, context)
 
-    existing = _existing_commit(active, tree, message=message)
+    existing = _existing_commit(active, tree, branch=context.branch, message=message)
     if existing is not None:
         sha, created = existing, False
     else:
@@ -365,20 +365,18 @@ def _ledger_has_checkpoint(ledger: RunLedger, task_id: str, turn_seq: int) -> bo
     return False
 
 
-def _existing_commit(runtime: ActivityRuntime, tree: str, *, message: str) -> str | None:
+def _existing_commit(runtime: ActivityRuntime, tree: str, *, branch: str, message: str) -> str | None:
     """The commit a previous attempt of THIS turn already made, matched by its exact message.
 
-    Searched with ``--all`` in the tree the commit would be made in: a worktree shares the parent's
-    object store, so a commit another attempt left on this task's branch is visible from here. Scoped
-    to the tree rather than the repository so the search cannot be satisfied by a same-message commit
-    on some other branch — the message carries the run, task and turn, but a stale checkout of the same
-    task (an earlier run with a reused id) would match, and this is the check that would then wrongly
-    report "already done".
+    Searched only on this task's branch in the tree the commit would be made in: a worktree shares
+    the parent's object store, so a previous attempt's branch tip is visible from here. Restricting
+    the walk to that branch avoids scanning every ref on each cold checkpoint and cannot be satisfied
+    by a same-message commit on an unrelated branch.
     """
     out = git_ok(
         runtime,
         tree,
-        ["log", "--all", "--fixed-strings", "--format=%H", f"--grep={message}", "-n", "1"],
+        ["log", f"refs/heads/{branch}", "--fixed-strings", "--format=%H", f"--grep={message}", "-n", "1"],
     )
     if not out or not out.strip():
         return None

{codna-0.2.99 → codna-0.2.101}/codna/durable/cli.py

@@ -881,7 +881,7 @@ def _register_decide(actions: Any, name: str, help_text: str) -> None:
 def _register_control(actions: Any) -> None:
     control = actions.add_parser("control", help="Pause, resume or stop a run.")
     control.add_argument("--run", required=True, help="run id")
-    control.add_argument("action", choices=("pause", "resume", "stop"))
+    control.add_argument("control_action", choices=("pause", "resume", "stop"))
     control.set_defaults(func=cmd_durable, durable_action="control")
 
 

{codna-0.2.99 → codna-0.2.101}/codna/durable/provider.py

@@ -29,12 +29,12 @@ It lives in its own file because `contracts.py` crossed the repository's 1000-li
 """
 from __future__ import annotations
 
-import ipaddress
 import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Final, Mapping
 from urllib.parse import urlsplit
 
+from ..provider_url import is_loopback_host as _is_loopback_host
 from .contract_primitives import ContractError
 from .state import find_secret_like_strings
 
@@ -389,7 +389,7 @@ def _require_provider_base_url(value: Any) -> str:
         raise ContractError(
             "base_url must name a host", code="contract_invalid", details={"field": "base_url"}
         )
-    if parts.username or parts.password:
+    if parts.username is not None or parts.password is not None:
         raise ContractError(
             "base_url must not embed credentials",
             code="contract_invalid",
@@ -411,24 +411,6 @@ def _require_provider_base_url(value: Any) -> str:
     return text
 
 
-def _is_loopback_host(hostname: str) -> bool:
-    """Loopback by name or by address, including the whole 127/8 range.
-
-    Deliberately explicit rather than ``ipaddress.is_loopback`` alone: ``localhost`` is not an address,
-    and a host must be recognised without a DNS lookup (this runs inside a contract validator, which
-    must be deterministic and offline).
-    """
-    host = hostname.strip().lower().strip("[]")
-    if host == "localhost" or host.endswith(".localhost"):
-        return True
-    if host == "::1":
-        return True
-    try:
-        return ipaddress.ip_address(host).is_loopback
-    except ValueError:
-        return False
-
-
 def provider_session_spec(context: "TaskContext", *, key: str | None) -> dict[str, Any]:
     """The provider part of a create-session body, for a task context.
 

{codna-0.2.99 → codna-0.2.101}/codna/memory.py

@@ -47,6 +47,7 @@ from .codeunits import FILTER_COLUMNS, UnsupportedLanguageError, extract_repo, r
 # re-exported here because `codna.memory` is the public import surface every caller and test uses.
 from .memory_install import activate_install_site_packages as _activate_install_site_packages
 from .memory_install import candidate_install_roots as _candidate_codna_install_roots
+from .runtime_capabilities import require_compact_export
 from .memory_manifest import legacy_manifest_id_belongs_to_repo, manifest_entry, manifest_hash, manifest_scope
 
 COLLECTION = "repo_symbols"
@@ -922,12 +923,19 @@ class CodeMemory:
 
         The compact tiers keep the int8 slab, which only exists when the collection was sealed at
         dtype="int8". If this memory's collection is f32, a ONE-TIME transparent reset+reindex at
-        int8 runs first — search quality is tier-validated (int8 == f32 recall on the quant PoC)."""
+        int8 runs first — search quality is tier-validated (int8 == f32 recall on the quant PoC).
+
+        A runtime that *declares* ``export_compact`` but does not implement it (it is part of the SDK's
+        ``RuntimeHandle`` contract, so the method always exists) is rejected up front with the runtime's
+        own guidance, instead of failing midway through a rebuild with a bare ``NotImplementedError``.
+        ``hasattr`` cannot detect that, and the check runs BEFORE the int8 rebuild, which would
+        otherwise discard a working f32 index only to fail on the export."""
         col = self._collection()
         export = getattr(col, "export_compact", None)
         if export is None:
             raise CodeMemoryError(
                 "the resolved telys predates compact serve artifacts (telys#99) — upgrade telys")
+        require_compact_export(getattr(getattr(self, "_eng", None), "_runtime", None), CodeMemoryError)
         if getattr(col, "dtype", "f32") != "int8":
             self.reset()
             self._col = None

codna-0.2.101/codna/provider_url.py

@@ -0,0 +1,17 @@
+"""Provider endpoint validation shared by the CLI and durable contracts."""
+from __future__ import annotations
+
+import ipaddress
+
+__all__ = ["is_loopback_host"]
+
+
+def is_loopback_host(hostname: str) -> bool:
+    """Recognize loopback names and addresses deterministically, without DNS."""
+    host = hostname.strip().lower().strip("[]")
+    if host == "localhost" or host.endswith(".localhost") or host == "::1":
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False

codna-0.2.101/codna/runtime_capabilities.py

@@ -0,0 +1,77 @@
+"""Runtime capability decisions — one source of truth for "can this runtime do X?".
+
+`hasattr(collection, "export_compact")` cannot answer any of this: every method on the SDK's
+`RuntimeHandle` contract EXISTS on every runtime, so the attribute is always present even when calling it
+raises `NotImplementedError`. That is why a missing capability used to surface as a crash inside the
+caller instead of a clean, early refusal.
+
+The decision is made here, once, and used by both the product and the tests, so they cannot drift apart:
+
+  1. a runtime that declares the flag answers definitively;
+  2. otherwise (an SDK older than the flag) a method inherited unchanged from `RuntimeHandle` is the base
+     class's ``raise NotImplementedError`` body — present, supporting nothing;
+  3. anything else is assumed capable, which keeps pre-flag runtimes that DID implement the method working.
+
+This module lives in `codna` deliberately. A verified `telys runtime install` ships a SLIM `memengine`
+(`native_runtime.py` only), so capability logic placed in `memengine` would be absent from exactly the
+production installs that need it.
+"""
+
+from __future__ import annotations
+
+COMPACT_EXPORT = "supports_compact_export"
+COMPACT_OPEN = "supports_compact_open"
+
+
+def _overrides(runtime, method: str) -> bool:
+    """True when `runtime` supplies its own `method` rather than the SDK's unimplemented base body.
+
+    Resolved on the INSTANCE (not the class): a runtime may provide the method per-instance, and a bound
+    method is a fresh object on every access, so compare the underlying function. With no SDK importable
+    there is no base class to compare against, so assume it does (the caller's error handling still
+    applies) rather than refusing a runtime that may well work.
+    """
+    impl = getattr(runtime, method, None)
+    if impl is None:
+        return False
+    func = getattr(impl, "__func__", impl)
+    try:
+        from telys.runtime import RuntimeHandle
+    except Exception:  # noqa: BLE001 — no SDK base class to compare against
+        return True
+    return func is not getattr(RuntimeHandle, method, object())
+
+
+def _declares(runtime, capability: str, method: str) -> tuple[bool, str]:
+    name = type(runtime).__name__
+    flag = getattr(runtime, capability, None)
+    if flag is not None:
+        return bool(flag), f"{name}.{capability}={flag}"
+    if not _overrides(runtime, method):
+        return False, f"{name} inherits the SDK's unimplemented {method}"
+    return True, f"{name} implements {method} (no {capability} flag)"
+
+
+def supports_compact_export(runtime) -> tuple[bool, str]:
+    """(supported, detail) for WRITING a compact serve artifact with `runtime`."""
+    return _declares(runtime, COMPACT_EXPORT, "export_compact")
+
+
+def require_compact_export(runtime, error_type):
+    """Raise `error_type` unless `runtime` can write a compact serve artifact.
+
+    Kept here rather than at the call site so `memory.py` does not grow past its 1000-line ceiling
+    (`test_modularity.py`), and because this is the same decision `supports_compact_export` makes —
+    one source of truth, two presentations: a predicate for tests, an exception for the product.
+    """
+    supported, detail = supports_compact_export(runtime)
+    if not supported:
+        raise error_type(
+            f"the resolved runtime cannot export compact serve artifacts ({detail}) — "
+            "export from the local runtime (TELYS_RUNTIME=local)"
+        )
+
+
+def supports_compact_open(runtime) -> tuple[bool, str]:
+    """(supported, detail) for READING a compact serve artifact with `runtime`."""
+    return _declares(runtime, COMPACT_OPEN, "open_compact")

{codna-0.2.99 → codna-0.2.101}/codna/telys_onboarding.py

@@ -157,10 +157,42 @@ def ensure_provisioned(*, access_token: str | None = None, plan: str = _DEFAULT_
         install=status["kernel_source"] is None,
         open_browser=open_browser,
     )
+    # ``runtime_installed`` asks whether this device HAS a usable on-device runtime, so it is answered
+    # by the SAME resolver `codna status` and `ensure_licensed` use — never by ``result["installed"]``.
+    # ``telys.login`` reports ``installed`` for "this call downloaded a bundle", which is a different
+    # question: a device whose kernel already resolves passes ``install=False``, so provisioning
+    # succeeds and used to report ``runtime_installed: false`` — the flag described the branch taken,
+    # not the machine. Re-probing is also what makes the answer true for every path (a fresh download,
+    # a pre-existing kernel, a packaged runtime) instead of only the one this function happened to take.
+    after = provision_status()
+    if not after["provisioned"]:
+        # ``provisioned`` is "license AND kernel", so name WHICH half is missing rather than always
+        # blaming the kernel. A device whose kernel resolves but whose license was never written is a
+        # real state (a platform wheel ships a kernel; `run_login` may fail to write the license), and
+        # pointing that user at CODNA_TELYS_INSTALL_ROOT/TELYS_KERNEL would send them to fix the one
+        # thing that already works. Exit 0 means signed in AND provisioned (cmd_login's contract), so
+        # this must not return a success payload either way.
+        missing: list[str] = []
+        if not after["license_source"]:
+            missing.append(
+                "the per-device license was not written (re-run `codna login`; if it persists, check "
+                "that $TELYS_HOME is writable)"
+            )
+        if not after["kernel_source"]:
+            missing.append(
+                "no Telys kernel resolves (re-run `codna login`; if it persists, set "
+                "CODNA_TELYS_INSTALL_ROOT or TELYS_KERNEL to a Codna-managed runtime)"
+            )
+        raise OnboardingError(
+            "Codna device authorization succeeded but the on-device runtime is not fully provisioned: "
+            + "; ".join(missing)
+        )
     return {
         "provisioned": True,
         "already_provisioned": False,
-        "runtime_installed": bool(result.get("installed")),
+        # True now: ``after["provisioned"]`` requires a license AND a resolved kernel.
+        "runtime_installed": True,
+        "runtime_source": after["kernel_source"],
         "tier": result.get("tier"),
     }
 

{codna-0.2.99 → codna-0.2.101}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.99
+Version: 0.2.101
 Summary: Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.99 → codna-0.2.101}/codna.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ codna/policy.py
 codna/policy_cli.py
 codna/policy_document.py
 codna/project_rules.py
+codna/provider_url.py
 codna/python_import_paths.py
 codna/refengine.py
 codna/remote_http.py
@@ -67,6 +68,7 @@ codna/review_findings.py
 codna/review_github.py
 codna/review_grounding.py
 codna/review_manifests.py
+codna/runtime_capabilities.py
 codna/runtime_config.py
 codna/sandbox.py
 codna/sarif.py
@@ -247,6 +249,7 @@ tests/test_memory_rerank.py
 tests/test_memory_wordllama_rerank.py
 tests/test_memory_wrapper.py
 tests/test_modularity.py
+tests/test_native_compact_export.py
 tests/test_netjail.py
 tests/test_packaged_confidence.py
 tests/test_packaged_git_clone.py

{codna-0.2.99 → codna-0.2.101}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.99"
+version = "0.2.101"
 description = "Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine."
 readme = "README.md"
 requires-python = ">=3.12"

{codna-0.2.99 → codna-0.2.101}/tests/test_admission_control.py

@@ -106,19 +106,58 @@ def test_contention_grows_with_concurrency():
 
 
 # ── never stall ────────────────────────────────────────────────────────────────────────────────
-def test_a_raising_predictor_degrades_instead_of_blocking_admission():
-    """A predictor/engine outage must never wedge the gate. make_mojo_breach_fn wraps the kernel with
-    exactly this fallback, so verify the wrapper, not just the docstring."""
+def test_a_raising_predictor_degrades_instead_of_blocking_admission(capsys):
+    """A predictor/engine outage must never wedge the gate.
+
+    THE CONTRACT, stated twice in production code: the module docstring — "the gate can NEVER stall: a
+    kernel hiccup degrades to in-process math, it does not block admission" — and `make_mojo_breach_fn`
+    — "falling back to ``fallback`` (numpy by default) on any error so a predictor/engine outage never
+    stalls admission". So a raising kernel must DEGRADE to the fallback predictor and keep deciding; it
+    must not refuse admission and it must not raise out of the gate. The one error that does surface is
+    a fallback that ALSO raises: no predictor at all is the one case where "degrade" has no value to
+    degrade to, and swallowing it would turn a caller bug into an invisible admission.
+
+    The kernel is made to fail through an INJECTED client, which is the seam this file already uses for
+    the same purpose (`test_fallback_is_announced_not_silent`,
+    `test_the_kernel_predictor_reports_which_branch_answered`). Leaving it to the environment was the
+    defect this test carried: with a working in-process kernel `mojo_breach_probability` answers, the
+    fallback is never consulted — so the second half below was unreachable and the test pinned whether
+    the CI box happened to have a usable kernel, not the behaviour (it failed on this machine, where the
+    `build/local-telys` kernel answers). Both halves are now deterministic on any machine.
+    """
+    class _EngineDown:
+        def _request(self, *_a, **_k):
+            raise RuntimeError("engine down")
+
+    degraded_value = 0.25
+
+    def fallback(*_a):
+        return degraded_value
+
+    fn = ac.make_mojo_breach_fn(client=_EngineDown(), fallback=fallback)
+
+    # The fallback answered — asserted by BRANCH and by a value only the fallback can produce, because
+    # a breach probability alone cannot show which predictor computed it.
+    assert fn.probe([10.0, 11.0], 1.5, 900.0, 128) == (0.25, "numpy")
+    assert fn([10.0, 11.0], 1.5, 900.0, 128) == 0.25
+    assert fn.last_predictor == "numpy"
+    assert "fell back to in-process numpy" in capsys.readouterr().err
+
+    # ...and the gate still DECIDES with it, in the MC zone, instead of raising out of try_admit.
+    d = ac.MCAdmissionDecider(_cfg(model_rate_budget=1, ceiling=4), mc_fn=fn)
+    d.finish(10.0)
+    assert d.try_admit().admit is True       # deterministic floor: no prediction needed
+    verdict = d.try_admit()                  # MC zone, decided by the DEGRADED predictor
+    assert verdict.p_breach == 0.25
+    assert verdict.admit is False            # 0.25 >= breach_threshold: throttled, never raised
+
+    # An explicitly exploding fallback has nothing left to degrade to, so it surfaces rather than
+    # letting the gate continue on an invented number.
     def _boom(*_a, **_k):
         raise RuntimeError("engine down")
 
-    fn = ac.make_mojo_breach_fn(fallback=lambda *a: 0.0)
-    # mojo_breach_probability will fail (no client/daemon here) -> falls back to the given predictor.
-    assert fn([10.0, 11.0], 1.5, 900.0, 128) == 0.0
-
-    # And an explicitly exploding fallback surfaces rather than hanging.
-    fn_bad = ac.make_mojo_breach_fn(fallback=_boom)
-    with pytest.raises(RuntimeError):
+    fn_bad = ac.make_mojo_breach_fn(client=_EngineDown(), fallback=_boom)
+    with pytest.raises(RuntimeError, match="engine down"):
         fn_bad([10.0], 1.5, 900.0, 8)
 
 

{codna-0.2.99 → codna-0.2.101}/tests/test_config_file.py

@@ -163,6 +163,7 @@ def test_base_url_accepts_an_env_ref_and_fails_closed_when_unset(tmp_path, monke
         ("ftp://host/v1", "must be an http(s) URL"),
         ("file:///etc/passwd", "must be an http(s) URL"),
         ("https://user:pass@host/v1", "must not embed credentials"),
+        ("https://:@host/v1", "must not embed credentials"),
         ("https://host/v1?key=abc", "must not carry a query string"),
         ("https://host/v1#frag", "must not carry a query string"),
         ("host-without-scheme/v1", "must be an http(s) URL"),
@@ -177,6 +178,31 @@ def test_base_url_validation_is_fail_closed(tmp_path, bad, expected):
     assert expected in str(exc.value)
 
 
+def test_base_url_rejects_remote_plain_http(tmp_path):
+    p = _write(tmp_path, "codna.yaml", "model:\n  provider: openai\n  base_url: http://example.com/v1\n")
+    with pytest.raises(ConfigError, match="plain http must point at loopback"):
+        config_file.apply_config(str(p))
+
+
+@pytest.mark.parametrize("value", [0, False, []])
+def test_base_url_rejects_non_string_values(value):
+    with pytest.raises(ConfigError, match="must be a string URL"):
+        config_file._validated_base_url(value, field="model.base_url")
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "http://localhost:11434/v1",
+        "http://127.0.0.2:11434/v1",
+        "http://[::1]:11434/v1",
+        "https://llm.example.com/v1",
+    ],
+)
+def test_base_url_allows_https_and_loopback_http(url):
+    assert config_file._validated_base_url(url, field="model.base_url") == url
+
+
 def test_absent_base_url_leaves_the_provider_default_alone(tmp_path, monkeypatch):
     monkeypatch.delenv(config_file.BASE_URL_ENV, raising=False)
     p = _write(tmp_path, "codna.yaml", "model:\n  provider: openai\n")

{codna-0.2.99 → codna-0.2.101}/tests/test_impact_cli.py

@@ -168,8 +168,23 @@ def test_export_without_compact_seam_raises(monkeypatch):
     assert not os.path.exists("/tmp/never-written")
 
 
+def _compact_export_capability(mem):
+    """(supported, detail) for the memory's resolved runtime, from a REAL capability signal.
+
+    ``hasattr(collection, "export_compact")`` is the wrong probe: the method exists on every runtime
+    (it is part of the SDK's ``RuntimeHandle`` contract), so the attribute is always present even when
+    calling it raises ``NotImplementedError``. That is exactly how this test rotted into an error in its
+    own body instead of a clean skip. The decision lives in ``memengine.capabilities`` so the product and
+    this test cannot disagree.
+    """
+    from codna.runtime_capabilities import supports_compact_export
+
+    runtime = getattr(getattr(mem, "_eng", None), "_runtime", None)
+    return supports_compact_export(runtime)
+
+
 def test_export_end_to_end(tmp_path, monkeypatch):
-    """Needs the Telys kernel + the compact seam; skips on older stacks (offline CI lane)."""
+    """Needs the Telys kernel + a runtime that IMPLEMENTS the compact seam (offline CI lane skips)."""
     monkeypatch.setenv("CODNA_MEMORY_EMBED", "local")
     repo = str(tmp_path / "repo")
     os.makedirs(repo, exist_ok=True)
@@ -182,8 +197,9 @@ def test_export_end_to_end(tmp_path, monkeypatch):
         mem = CodeMemory(repo, db_path=str(tmp_path / "db"))
     except Exception as exc:  # noqa: BLE001
         pytest.skip(f"telys/kernel unavailable: {type(exc).__name__}: {exc}")
-    if not hasattr(mem._collection(), "export_compact"):
-        pytest.skip("resolved telys predates the compact seam (telys#99)")
+    supported, detail = _compact_export_capability(mem)
+    if not supported:
+        pytest.skip(f"resolved runtime cannot export compact serve artifacts: {detail}")
 
     info = CodeMemory(repo, db_path=str(tmp_path / "db")).export_serve_artifact(
         str(tmp_path / "artifact"))
@@ -192,3 +208,48 @@ def test_export_end_to_end(tmp_path, monkeypatch):
     assert info["mode"] == "int8" and info["size_bytes"] > 0
     assert os.path.isfile(os.path.join(info["artifact"], "manifest.json"))
     assert not os.path.exists(os.path.join(info["artifact"], "ty_base.npy"))  # no f32 slab
+    assert not os.path.exists(os.path.join(info["artifact"], "vectors.f32"))  # no f32 slab
+
+
+def test_compact_capability_probe_rejects_unimplemented_runtime(monkeypatch):
+    """The capability probe must read the runtime flag, not merely the method's presence.
+
+    Regression guard for the exact defect that made ``test_export_end_to_end`` an ERROR in its own body:
+    a runtime that declares the method but raises ``NotImplementedError`` satisfies ``hasattr`` while
+    supporting nothing. The probe must call it unsupported.
+    """
+    from types import SimpleNamespace
+
+    from codna.memory import CodeMemory, CodeMemoryError
+
+    # A runtime that inherits the SDK's base-class stub: the method EXISTS (so `hasattr` says yes) and
+    # calling it raises NotImplementedError. This is the exact shape that made the export test error
+    # inside its own body instead of skipping. No SDK here -> genuine skip (the offline CI lane).
+    try:
+        from telys.runtime import RuntimeHandle
+    except ImportError as exc:
+        pytest.skip(f"telys SDK unavailable: {exc}")
+
+    class _UnimplementedRuntime(RuntimeHandle):
+        pass
+
+    mem = CodeMemory.__new__(CodeMemory)
+    mem._eng = SimpleNamespace(_runtime=_UnimplementedRuntime())
+
+    supported, detail = _compact_export_capability(mem)
+    assert supported is False, detail
+    assert "unimplemented export_compact" in detail
+
+    # The product surface refuses for the SAME reason, before doing any rebuild work. Reachable with no
+    # flag at all — the legacy case the review flagged: `not getattr(...)` and the base-stub check must
+    # both treat an absent attribute as unsupported, not silently pass it.
+    mem._col = SimpleNamespace(export_compact=lambda *a: None, dtype="int8")
+    with pytest.raises(CodeMemoryError, match="cannot export compact serve artifacts"):
+        mem.export_serve_artifact("/tmp/never-written")
+    assert not os.path.exists("/tmp/never-written")
+
+    # A pre-flag runtime that DOES implement the method is still assumed capable (no regression for the
+    # runtimes the flag exists for). `SimpleNamespace` has no `export_compact`, so give it one.
+    mem._eng = SimpleNamespace(_runtime=SimpleNamespace(export_compact=lambda *a, **k: "/tmp"))
+    supported, detail = _compact_export_capability(mem)
+    assert supported is True and "no supports_compact_export flag" in detail