@ngocsangairvds/vsaf 4.1.8 → 4.1.9

package/skills/vds-skill/vds-scripts/vds_agent_core/tests/unit/runtime/test_for_agent.py

@@ -1,322 +0,0 @@
-"""Tests for Phase 225 Track-B per-agent settings cascade (W2).
-
-Covers FR-226.1, FR-226.2, FR-226.4, FR-226.7, FR-226.11, FR-226.12,
-NFR-225.14, NFR-226.1, and NFR-226.4.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import re
-from typing import Any
-from unittest.mock import patch
-
-import pytest
-import structlog
-from vds_agent_core.llm._cascade import _reset_resolution_log
-from vds_agent_core.llm.embedding import EmbeddingSettings
-from vds_agent_core.llm.provider import LLMSettings
-from vds_agent_core.runtime.agent_id import (
-    AgentIdCollisionError,
-    reset_agent_id_registry,
-    sanitize_agent_id,
-)
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture(autouse=True)
-def _clear_per_agent_state(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Clear agent-id registry, resolution-log set, and any per-agent env vars."""
-    reset_agent_id_registry()
-    _reset_resolution_log()
-    # Belt-and-suspenders: zap any env vars from prior tests/sessions that
-    # would otherwise bleed into Path A resolution.
-    for key in list(os.environ.keys()):
-        if re.match(r"^VDS_AGENT_[A-Z0-9_]+_(LLM|EMBED)__", key):
-            monkeypatch.delenv(key, raising=False)
-    monkeypatch.delenv("VDS_AGENT_CORE__LOG_RESOLUTION", raising=False)
-
-
-@pytest.fixture()
-def configure_structlog_for_caplog() -> None:
-    """Wire structlog to stdlib so caplog captures structured events."""
-    structlog.configure(
-        processors=[
-            structlog.stdlib.add_log_level,
-            structlog.processors.KeyValueRenderer(key_order=["event"]),
-        ],
-        wrapper_class=structlog.stdlib.BoundLogger,
-        logger_factory=structlog.stdlib.LoggerFactory(),
-        cache_logger_on_first_use=False,
-    )
-
-
-# sanitize_agent_id (NFR-226.4) ---------------------------------------------
-
-
-class TestSanitizeAgentId:
-    def test_hyphen_to_underscore_uppercase(self) -> None:
-        assert sanitize_agent_id("agent-1") == "AGENT_1"
-
-    def test_dot_and_slash_to_underscore(self) -> None:
-        # Different inputs → different sanitized forms (no collision):
-        assert sanitize_agent_id("a.b.c") == "A_B_C"
-        assert sanitize_agent_id("x/y/z") == "X_Y_Z"
-
-    def test_collision_raises(self) -> None:
-        sanitize_agent_id("agent-1")
-        # 'agent.1' sanitizes to AGENT_1 too -> collision.
-        with pytest.raises(AgentIdCollisionError):
-            sanitize_agent_id("agent.1")
-
-    def test_idempotent_same_id(self) -> None:
-        s1 = sanitize_agent_id("agent-x")
-        s2 = sanitize_agent_id("agent-x")
-        assert s1 == s2 == "AGENT_X"
-
-    def test_empty_raises(self) -> None:
-        with pytest.raises(ValueError):
-            sanitize_agent_id("")
-
-    def test_non_string_raises(self) -> None:
-        with pytest.raises(ValueError):
-            sanitize_agent_id(123)  # type: ignore[arg-type]
-
-    def test_invalid_chars_rejected(self) -> None:
-        with pytest.raises(ValueError):
-            sanitize_agent_id("agent space")
-        with pytest.raises(ValueError):
-            sanitize_agent_id("agent$1")
-
-
-# ---------------------------------------------------------------------------
-# LLMSettings.for_agent — 3-layer cascade
-# ---------------------------------------------------------------------------
-
-
-class _FakeApiSettings:
-    """Stand-in for the multi_agent_orchestrator ``Agent`` model."""
-
-    def __init__(
-        self,
-        llm_settings: dict[str, Any] | None = None,
-        embedding_settings: dict[str, Any] | None = None,
-    ) -> None:
-        self.llm_settings = llm_settings
-        self.embedding_settings = embedding_settings
-
-
-class TestLLMSettingsForAgentCascade:
-    def test_defaults_when_no_layer_set(self) -> None:
-        s = LLMSettings.for_agent("agent-default")
-        assert isinstance(s, LLMSettings)
-        # Default base_url is None per LLMRuntimeConfig.
-        assert s.base_url is None
-        assert s.model_standard == "gpt-4o-mini"
-
-    def test_path_a_env_vars_resolved(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("VDS_AGENT_AGENT_A_LLM__MODEL_STANDARD", "gpt-4o")
-        monkeypatch.setenv(
-            "VDS_AGENT_AGENT_A_LLM__BASE_URL", "https://path-a.example.com/v1"
-        )
-        s = LLMSettings.for_agent("agent-a")
-        assert s.model_standard == "gpt-4o"
-        assert s.base_url == "https://path-a.example.com/v1"
-
-    def test_path_b_overrides_path_a_with_warn(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_AGENT_B_LLM__MODEL_STANDARD", "from-path-a")
-        api = _FakeApiSettings(llm_settings={"model_standard": "from-path-b"})
-        with caplog.at_level(logging.WARNING):
-            s = LLMSettings.for_agent("agent-b", api_settings=api)
-        assert s.model_standard == "from-path-b"
-        # FR-226.7: structured WARN event observed.
-        joined = " ".join(rec.getMessage() for rec in caplog.records)
-        assert "for_agent_path_conflict" in joined
-        assert "from-path-a" in joined
-        assert "from-path-b" in joined
-        assert "winner=path_b" in joined or "winner='path_b'" in joined
-
-    def test_path_c_overrides_everything(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("VDS_AGENT_AGENT_C_LLM__MODEL_STANDARD", "from-a")
-        api = _FakeApiSettings(llm_settings={"model_standard": "from-b"})
-        s = LLMSettings.for_agent(
-            "agent-c", api_settings=api, overrides={"model_standard": "from-c"}
-        )
-        assert s.model_standard == "from-c"
-
-    def test_no_warn_when_paths_agree(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_AGENT_AGREE_LLM__MODEL_STANDARD", "gpt-4o")
-        api = _FakeApiSettings(llm_settings={"model_standard": "gpt-4o"})
-        with caplog.at_level(logging.WARNING):
-            LLMSettings.for_agent("agent-agree", api_settings=api)
-        assert "for_agent_path_conflict" not in " ".join(
-            rec.getMessage() for rec in caplog.records
-        )
-
-
-# ---------------------------------------------------------------------------
-# EmbeddingSettings.for_agent — mirror cascade
-# ---------------------------------------------------------------------------
-
-
-class TestEmbeddingSettingsForAgentCascade:
-    def test_defaults_when_no_layer_set(self) -> None:
-        s = EmbeddingSettings.for_agent("embed-default")
-        assert isinstance(s, EmbeddingSettings)
-        assert s.provider == "ollama"
-        assert s.model_standard == "bge-m3"
-
-    def test_path_a_env_vars_resolved(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        # Use ollama provider to keep dim validation happy.
-        monkeypatch.setenv(
-            "VDS_AGENT_EMBED_A_EMBED__BASE_URL", "http://path-a.local:11434"
-        )
-        s = EmbeddingSettings.for_agent("embed-a")
-        assert s.base_url == "http://path-a.local:11434"
-
-    def test_path_b_overrides_path_a_with_warn(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv(
-            "VDS_AGENT_EMBED_B_EMBED__BASE_URL", "http://path-a.local:11434"
-        )
-        api = _FakeApiSettings(
-            embedding_settings={"base_url": "http://path-b.local:11434"}
-        )
-        with caplog.at_level(logging.WARNING):
-            s = EmbeddingSettings.for_agent("embed-b", api_settings=api)
-        assert s.base_url == "http://path-b.local:11434"
-        joined = " ".join(rec.getMessage() for rec in caplog.records)
-        assert "for_agent_path_conflict" in joined
-        assert "kind=embedding" in joined or "kind='embedding'" in joined
-
-    def test_path_c_overrides_everything(self) -> None:
-        s = EmbeddingSettings.for_agent(
-            "embed-c", overrides={"base_url": "http://path-c.local:11434"}
-        )
-        assert s.base_url == "http://path-c.local:11434"
-
-
-# ---------------------------------------------------------------------------
-# FR-226.11 — side-effect-free settings construction
-# ---------------------------------------------------------------------------
-
-
-class TestForAgentSideEffectFree:
-    def test_no_httpx_async_client_constructed_for_llm(self) -> None:
-        # The settings construction itself must not instantiate any network
-        # client. We patch httpx.AsyncClient and assert it is never called.
-        with patch("httpx.AsyncClient") as mock_async_client:
-            LLMSettings.for_agent("no-side-effects-llm")
-        mock_async_client.assert_not_called()
-
-    def test_no_httpx_async_client_constructed_for_embedding(self) -> None:
-        with patch("httpx.AsyncClient") as mock_async_client:
-            EmbeddingSettings.for_agent("no-side-effects-embed")
-        mock_async_client.assert_not_called()
-
-
-# ---------------------------------------------------------------------------
-# FR-226.12 — backward-compat lock for the no-args ``LLMSettings()`` path
-# ---------------------------------------------------------------------------
-
-
-class TestBackwardCompatNoArgsLLMSettings:
-    """Existing ``LLMSettings()`` no-args call sites must keep working.
-
-    The audit-orchestrator subclass at the spec-cited line numbers
-    (`agents/base.py:125`, `llm/evaluator.py:80`, `llm/engine.py:68`) inherits
-    from :class:`vds_agent_core.llm.provider.LLMSettings`. This test locks the
-    canonical (core) no-args path and verifies the audit subclass module
-    still imports cleanly. Audit's own ``LLMSettings()`` instantiation is
-    covered by audit's own test suite (which loads the audit conftest that
-    pre-resolves ``SecretStr`` for forward-ref binding).
-    """
-
-    def test_core_llmsettings_no_args_constructs(self) -> None:
-        settings = LLMSettings()
-        assert isinstance(settings, LLMSettings)
-        assert callable(settings.build_client)
-        assert callable(settings.select_model)
-
-# ---------------------------------------------------------------------------
-# Concurrency — for_agent under thread-pool concurrency must not race
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_for_agent_no_race_under_concurrency() -> None:
-    results = await asyncio.gather(
-        *[
-            asyncio.to_thread(LLMSettings.for_agent, f"agent-{i}")
-            for i in range(100)
-        ]
-    )
-    assert len(results) == 100
-    assert all(isinstance(r, LLMSettings) for r in results)
-
-
-# ---------------------------------------------------------------------------
-# NFR-226.1 — one-shot resolution log
-# ---------------------------------------------------------------------------
-
-
-class TestResolutionLogOneShot:
-    def test_log_resolution_emits_one_per_agent_kind(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_CORE__LOG_RESOLUTION", "true")
-        with caplog.at_level(logging.INFO):
-            LLMSettings.for_agent("agent-log")
-            LLMSettings.for_agent("agent-log")  # second call: zero new logs.
-        events = [rec.getMessage() for rec in caplog.records if "for_agent_resolved" in rec.getMessage()]
-        assert len(events) == 1, f"expected exactly 1 resolved log, got {len(events)}: {events}"
-
-    def test_log_resolution_disabled_emits_nothing(
-        self,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        # No env var set -> no log even on first call.
-        with caplog.at_level(logging.INFO):
-            LLMSettings.for_agent("agent-no-log")
-        assert all(
-            "for_agent_resolved" not in rec.getMessage() for rec in caplog.records
-        )
-
-    def test_log_resolution_separate_kinds(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_CORE__LOG_RESOLUTION", "true")
-        with caplog.at_level(logging.INFO):
-            LLMSettings.for_agent("agent-multi")
-            EmbeddingSettings.for_agent("agent-multi")
-        events = [
-            rec.getMessage() for rec in caplog.records if "for_agent_resolved" in rec.getMessage()
-        ]
-        # Same agent_id, two different kinds -> two logs.
-        assert len(events) == 2

package/skills/vds-skill/vds-scripts/vds_agent_core/tests/unit/runtime/test_w9_cascade_edges.py

@@ -1,369 +0,0 @@
-"""Phase 225 W9 broader-coverage — _cascade.py edge cases not yet locked.
-
-The existing ``test_for_agent.py`` covers Path A alone, Path B-overrides-A
-WARN, Path C precedence, and the one-shot resolution log. This file
-widens coverage to:
-
-* Path A ``api_settings=None`` AND env-var Path A both set → Path A wins.
-* All three paths set the same value → no WARN, deterministic precedence.
-* WARN log content shape (FR-226.7) — fields ``path_a_value``,
-  ``path_b_value``, ``winner=path_b``, ``field`` all present, ``kind`` set.
-* WARN does NOT fire when Path A is unset and only Path B is set.
-* Multi-field conflict — every conflicting field emits its own WARN.
-* Path A reads only the matching ``env_prefix`` (no leakage from other
-  agents' env vars with similar prefixes).
-* Path B with non-dict attribute is gracefully ignored.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import re
-from typing import Any
-from unittest.mock import patch
-
-import pytest
-import structlog
-from vds_agent_core.llm._cascade import _reset_resolution_log, resolve_for_agent
-from vds_agent_core.llm.embedding import EmbeddingSettings
-from vds_agent_core.llm.provider import LLMSettings
-from vds_agent_core.runtime.agent_id import reset_agent_id_registry
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture(autouse=True)
-def _clean_per_agent_state(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Same belt-and-suspenders cleanup as test_for_agent.py."""
-    reset_agent_id_registry()
-    _reset_resolution_log()
-    for key in list(os.environ.keys()):
-        if re.match(r"^VDS_AGENT_[A-Z0-9_]+_(LLM|EMBED)__", key):
-            monkeypatch.delenv(key, raising=False)
-    monkeypatch.delenv("VDS_AGENT_CORE__LOG_RESOLUTION", raising=False)
-
-
-@pytest.fixture()
-def configure_structlog_for_caplog() -> None:
-    structlog.configure(
-        processors=[
-            structlog.stdlib.add_log_level,
-            structlog.processors.KeyValueRenderer(key_order=["event"]),
-        ],
-        wrapper_class=structlog.stdlib.BoundLogger,
-        logger_factory=structlog.stdlib.LoggerFactory(),
-        cache_logger_on_first_use=False,
-    )
-
-
-class _FakeApi:
-    """Stand-in for the multi_agent_orchestrator Agent model."""
-
-    def __init__(
-        self,
-        *,
-        llm_settings: dict[str, Any] | None = None,
-        embedding_settings: dict[str, Any] | None = None,
-    ) -> None:
-        self.llm_settings = llm_settings
-        self.embedding_settings = embedding_settings
-
-
-# ---------------------------------------------------------------------------
-# Combinatorial coverage — api_settings=None + env Path A set
-# ---------------------------------------------------------------------------
-
-
-class TestPathANoneApiSettings:
-    """When ``api_settings`` is None and Path A env vars are set, the cascade
-    must still resolve Path A's value (no implicit dependency on Path B
-    being present)."""
-
-    def test_llm_path_a_alone_resolves(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setenv("VDS_AGENT_LONELY_A_LLM__MODEL_STANDARD", "gpt-4o-only-a")
-        s = LLMSettings.for_agent("lonely-a", api_settings=None)
-        assert s.model_standard == "gpt-4o-only-a"
-
-    def test_llm_path_a_no_warn_emitted_without_path_b(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        """Path B absent → no for_agent_path_conflict event."""
-        monkeypatch.setenv("VDS_AGENT_LONELY_NOWARN_LLM__MODEL_STANDARD", "from-a")
-        with caplog.at_level(logging.WARNING):
-            LLMSettings.for_agent("lonely-nowarn", api_settings=None)
-        assert "for_agent_path_conflict" not in " ".join(
-            rec.getMessage() for rec in caplog.records
-        )
-
-    def test_embedding_path_a_alone_resolves(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.setenv(
-            "VDS_AGENT_LONELY_E_EMBED__BASE_URL", "http://lonely-e:11434"
-        )
-        s = EmbeddingSettings.for_agent("lonely-e", api_settings=None)
-        assert s.base_url == "http://lonely-e:11434"
-
-
-# ---------------------------------------------------------------------------
-# Deterministic precedence — all three paths agree → C value, no WARN
-# ---------------------------------------------------------------------------
-
-
-class TestAllThreePathsAgree:
-    """When env var, api_settings, and overrides all set the same field to
-    the same value, no WARN fires (because Path A == Path B), and the final
-    resolved value matches that shared value (Path C is the strongest writer
-    but writes the same string)."""
-
-    def test_all_agree_no_warn(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_TRIPLE_LLM__MODEL_STANDARD", "gpt-4o")
-        api = _FakeApi(llm_settings={"model_standard": "gpt-4o"})
-        with caplog.at_level(logging.WARNING):
-            s = LLMSettings.for_agent(
-                "triple",
-                api_settings=api,
-                overrides={"model_standard": "gpt-4o"},
-            )
-        assert s.model_standard == "gpt-4o"
-        assert "for_agent_path_conflict" not in " ".join(
-            rec.getMessage() for rec in caplog.records
-        )
-
-    def test_all_three_disagree_path_c_wins(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        """A ≠ B ≠ C → C is the final winner, but only A vs B emits the WARN
-        (because the implementation diff-checks Path A against Path B before
-        applying Path C)."""
-        monkeypatch.setenv("VDS_AGENT_TRIPLE_DIFF_LLM__MODEL_STANDARD", "from-a")
-        api = _FakeApi(llm_settings={"model_standard": "from-b"})
-        with caplog.at_level(logging.WARNING):
-            s = LLMSettings.for_agent(
-                "triple-diff",
-                api_settings=api,
-                overrides={"model_standard": "from-c"},
-            )
-        assert s.model_standard == "from-c"
-        joined = " ".join(rec.getMessage() for rec in caplog.records)
-        # The A-vs-B WARN must still fire.
-        assert "for_agent_path_conflict" in joined
-        assert "from-a" in joined
-        assert "from-b" in joined
-        # winner=path_b (the diff is computed on A vs B; C is applied after).
-        assert "winner=path_b" in joined or "winner='path_b'" in joined
-
-
-# ---------------------------------------------------------------------------
-# WARN log shape — FR-226.7 contract
-# ---------------------------------------------------------------------------
-
-
-class TestWarnLogShape:
-    def test_warn_includes_required_fields(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_WARN_FIELDS_LLM__MODEL_STANDARD", "v-a")
-        api = _FakeApi(llm_settings={"model_standard": "v-b"})
-        with caplog.at_level(logging.WARNING):
-            LLMSettings.for_agent("warn-fields", api_settings=api)
-        joined = " ".join(rec.getMessage() for rec in caplog.records)
-        assert "for_agent_path_conflict" in joined
-        # FR-226.7: agent_id, kind, field, path_a_value, path_b_value, winner.
-        assert "agent_id=warn-fields" in joined or "agent_id='warn-fields'" in joined
-        assert "kind=llm" in joined or "kind='llm'" in joined
-        assert "field=model_standard" in joined or "field='model_standard'" in joined
-        assert "path_a_value=v-a" in joined or "path_a_value='v-a'" in joined
-        assert "path_b_value=v-b" in joined or "path_b_value='v-b'" in joined
-
-    def test_warn_kind_embedding_when_embedding_cascade(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv(
-            "VDS_AGENT_WARN_KIND_EMBED__BASE_URL", "http://a:11434"
-        )
-        api = _FakeApi(embedding_settings={"base_url": "http://b:11434"})
-        with caplog.at_level(logging.WARNING):
-            EmbeddingSettings.for_agent("warn-kind", api_settings=api)
-        joined = " ".join(rec.getMessage() for rec in caplog.records)
-        assert "kind=embedding" in joined or "kind='embedding'" in joined
-
-
-# ---------------------------------------------------------------------------
-# Multi-field conflict — each conflicting field gets its own WARN
-# ---------------------------------------------------------------------------
-
-
-class TestMultipleFieldConflicts:
-    def test_two_fields_conflict_emit_two_warns(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        caplog: pytest.LogCaptureFixture,
-        configure_structlog_for_caplog: None,
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_MULTIWARN_LLM__MODEL_STANDARD", "model-a")
-        monkeypatch.setenv("VDS_AGENT_MULTIWARN_LLM__BASE_URL", "http://a:9000/v1")
-        api = _FakeApi(
-            llm_settings={
-                "model_standard": "model-b",
-                "base_url": "http://b:9000/v1",
-            }
-        )
-        with caplog.at_level(logging.WARNING):
-            LLMSettings.for_agent("multiwarn", api_settings=api)
-        # Count distinct conflict events.
-        conflicts = [
-            rec.getMessage()
-            for rec in caplog.records
-            if "for_agent_path_conflict" in rec.getMessage()
-        ]
-        assert len(conflicts) == 2, f"expected 2 WARNs, got {len(conflicts)}: {conflicts}"
-        joined = " ".join(conflicts)
-        assert "model_standard" in joined
-        assert "base_url" in joined
-
-
-# ---------------------------------------------------------------------------
-# Path A env-prefix isolation — no cross-agent leakage
-# ---------------------------------------------------------------------------
-
-
-class TestPathAPrefixIsolation:
-    def test_other_agents_env_vars_ignored(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        # Set env vars for OTHER agents — must not bleed into our resolution.
-        monkeypatch.setenv("VDS_AGENT_OTHER_LLM__MODEL_STANDARD", "wrong-1")
-        monkeypatch.setenv("VDS_AGENT_TARGET_LLM__MODEL_STANDARD", "right-target")
-        monkeypatch.setenv("VDS_AGENT_TARGET_X_LLM__MODEL_STANDARD", "wrong-2")
-        s = LLMSettings.for_agent("target")
-        assert s.model_standard == "right-target"
-
-    def test_kind_prefix_isolation(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """``LLM__`` prefix must not be confused with ``EMBED__`` prefix."""
-        monkeypatch.setenv("VDS_AGENT_KIND_ISO_EMBED__BASE_URL", "http://embed:1")
-        # No LLM prefix set for this agent → Path A empty for LLM.
-        s = LLMSettings.for_agent("kind-iso")
-        # base_url stays at the default (None) because the EMBED env var
-        # belongs to the embedding cascade, not the LLM cascade.
-        assert s.base_url is None
-
-
-# ---------------------------------------------------------------------------
-# Path B graceful handling
-# ---------------------------------------------------------------------------
-
-
-class TestPathBGracefulHandling:
-    def test_api_settings_with_no_attr_ignored(self) -> None:
-        """If api_settings has no ``llm_settings`` attribute, Path B is skipped."""
-
-        class _Naked:
-            pass
-
-        # Should not raise; falls back to defaults.
-        s = LLMSettings.for_agent("naked", api_settings=_Naked())
-        assert isinstance(s, LLMSettings)
-
-    def test_api_settings_with_none_attr_ignored(self) -> None:
-        """``api_settings.llm_settings = None`` → Path B contributes nothing."""
-        api = _FakeApi(llm_settings=None)
-        s = LLMSettings.for_agent("none-attr", api_settings=api)
-        assert s.model_standard == "gpt-4o-mini"  # default
-
-    def test_api_settings_with_non_dict_attr_ignored(self) -> None:
-        """``api_settings.llm_settings = "not a dict"`` → Path B skipped."""
-        api = _FakeApi()
-        api.llm_settings = "not a dict"  # type: ignore[assignment]
-        # Cascade must not raise on non-dict; resolves to default.
-        s = LLMSettings.for_agent("non-dict-attr", api_settings=api)
-        assert isinstance(s, LLMSettings)
-
-    def test_api_settings_unknown_field_dropped(self) -> None:
-        """Path B keys that aren't model fields are silently dropped."""
-        api = _FakeApi(llm_settings={"this_field_does_not_exist": "X"})
-        s = LLMSettings.for_agent("unknown-key", api_settings=api)
-        assert isinstance(s, LLMSettings)
-        # The unknown key wasn't set as an attribute either.
-        assert not hasattr(s, "this_field_does_not_exist")
-
-
-# ---------------------------------------------------------------------------
-# resolve_for_agent direct invocation — covers the function in isolation
-# ---------------------------------------------------------------------------
-
-
-class TestResolveForAgentDirect:
-    """The ``resolve_for_agent`` function is the underlying cascade primitive;
-    most tests go through ``LLMSettings.for_agent`` / ``EmbeddingSettings.for_agent``.
-    Calling the primitive directly locks the function signature."""
-
-    def test_overrides_unknown_keys_dropped(self) -> None:
-        """Overrides containing keys absent from the model are silently
-        dropped (defense-in-depth — the same logic Path B uses)."""
-        s = resolve_for_agent(
-            LLMSettings,
-            "direct-1",
-            kind="llm",
-            env_prefix_template="VDS_AGENT_{sanitized}_LLM__",
-            api_attr="llm_settings",
-            api_settings=None,
-            overrides={"model_standard": "gpt-4o", "this_does_not_exist": "x"},
-        )
-        assert s.model_standard == "gpt-4o"
-        assert not hasattr(s, "this_does_not_exist")
-
-    def test_no_overrides_no_api_no_env_returns_defaults(self) -> None:
-        """Empty cascade returns the equivalent of ``cls()`` plus defaults."""
-        s = resolve_for_agent(
-            LLMSettings,
-            "direct-defaults",
-            kind="llm",
-            env_prefix_template="VDS_AGENT_{sanitized}_LLM__",
-            api_attr="llm_settings",
-        )
-        assert isinstance(s, LLMSettings)
-        assert s.model_standard == "gpt-4o-mini"
-
-
-# ---------------------------------------------------------------------------
-# Side-effect-free under cascade with all paths populated
-# ---------------------------------------------------------------------------
-
-
-class TestSideEffectFreeUnderFullCascade:
-    """FR-226.11 — settings construction must remain side-effect-free even
-    when every path is populated (tests today only run with empty paths)."""
-
-    def test_no_httpx_under_full_path_population(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.setenv("VDS_AGENT_FULL_SIDE_LLM__MODEL_STANDARD", "from-a")
-        api = _FakeApi(llm_settings={"model_standard": "from-b"})
-        with patch("httpx.AsyncClient") as mock_async_client:
-            LLMSettings.for_agent(
-                "full-side",
-                api_settings=api,
-                overrides={"model_standard": "from-c"},
-            )
-        mock_async_client.assert_not_called()