@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/test_cli/test_runtime_profiles_cli.py

@@ -1,1658 +0,0 @@
-"""Tests for Phase 45 runtime protocol profile CLI wiring."""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-import pytest
-from typer.testing import CliRunner
-from vds_audit_orchestrator import cli
-
-runner = CliRunner()
-
-
-@pytest.fixture(autouse=True)
-def _clear_legacy_runtime_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Isolate runtime profile tests from host ~/.vds/.env legacy values."""
-    keys = (
-        "VDS_AUDIT_BOOTSTRAP_HOME",
-        "VDS_AUDIT_LLM_ENABLED",
-        "VDS_AUDIT_LLM_PROTOCOL",
-        "VDS_AUDIT_LLM__MODEL_SIMPLE",
-        "VDS_AUDIT_LLM__MODEL_STANDARD",
-        "VDS_AUDIT_LLM__MODEL_COMPLEX",
-        "VDS_AUDIT_LLM__STREAM",
-        "VDS_AUDIT_LLM__REASONING_EFFORT",
-        "VDS_AUDIT_LLM__API_KEY",
-        "VDS_AUDIT_LLM__MAX_TOKENS_PER_REQUEST",
-        "VDS_AUDIT_LLM__AGENT_RETRIES",
-        "VDS_AUDIT_LLM__OUTPUT_RETRIES",
-        "VDS_AUDIT_DSPY_MODEL",
-        "VDS_AUDIT_DSPY_PROTOCOL",
-        "VDS_AUDIT_DSPY_API_KEY",
-        "VDS_AUDIT_DSPY_MAX_TOKENS",
-        "VDS_AUDIT_DSPY_TEMPERATURE",
-        "VDS_AUDIT_DSPY_BASE_URL",
-        "VDS_AUDIT_DSPY_SYSTEM_ROLE_COMPAT",
-        "VDS_AUDIT_EMBEDDING__BASE_URL",
-        "VDS_AUDIT_EMBEDDING__MODEL",
-        "VDS_AUDIT_EMBEDDING__API_KEY",
-        "VDS_AUDIT_LLM__BASE_URL",
-        "VDS_AUDIT_LLM_PROTOCOL",
-        "VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_OVERRIDE",
-        "VDS_AUDIT_ACTIVE_PROFILE",
-        "VDS_AUDIT_LLM__AGENT_RUNTIME_MODE",
-        "VDS_AUDIT_AGENTIC_TOOL_ALLOWLISTS",
-        "VDS_AUDIT_AGENTIC_NON_PROGRESS_POLICY",
-        "VDS_AUDIT_AGENTIC_NON_PROGRESS_PRESET",
-        "VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS",
-        "VDS_AUDIT_AGENTIC_TOOL_FIRST_TIMEOUT_SECONDS",
-        "VDS_AUDIT_AGENTIC_TOOL_FIRST_BUDGET_UNITS",
-        "VDS_AUDIT_AGENTIC_SECURITY_TOOL_CALLS_LIMIT",
-        "VDS_AUDIT_AGENTIC_STRICT_NO_FALLBACK",
-        "VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS",
-        "VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS_PER_PAIR",
-        "VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS",
-        "VDS_AUDIT_AGENTIC_CODE_REVIEW_MAX_TOTAL_CHARS",
-        "VDS_AUDIT_LLM__SKILLS_TOOLSET_ENABLED",
-        "VDS_AUDIT_AGENTIC_ENABLE_SKILLS_TOOLSET",
-        "VDS_AUDIT_AGENTIC_SECURITY_ENABLE_SKILLS_TOOLSET",
-        "VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL",
-        "VDS_AUDIT_ROW_TIMEOUT_MS",
-        "VDS_AUDIT_BATCH_TIMEOUT_MS",
-        "VDS_AUDIT_TIMEOUT_POLICY__ROW_PROGRESS_LEASE_SECONDS",
-        "VDS_AUDIT_TIMEOUT_POLICY__ROW_STALL_DETECTION_SECONDS",
-        "VDS_AUDIT_TIMEOUT_POLICY__ROW_ABSOLUTE_TIMEOUT_MS",
-        "VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_ENABLED",
-        "VDS_AUDIT_ROW_TIMEOUT_PROGRESS_RETRY_ATTEMPTS",
-        "VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_MS",
-        "VDS_AUDIT_ROW_TIMEOUT_PROGRESS_MAX_MS",
-        "VDS_AUDIT_CLAUDE_AGENT_SDK__SETTING_SOURCES",
-        "VDS_AUDIT_CLAUDE_AGENT_SDK__ALLOWED_TOOLS",
-        "VDS_AUDIT_CLAUDE_AGENT_SDK__WORKING_DIRECTORY",
-        "VDS_AUDIT_CLAUDE_AGENT_SDK__SKILLS_DIRECTORY",
-        "VDS_AUDIT_CLAUDE_AGENT_SDK__MCP_CONFIG_PATH",
-        "VDS_AUDIT_PROFILE",
-        "VDS_AUDIT_AGENTIC_TOOL_TIMEOUT_SEC",
-    )
-    for key in keys:
-        monkeypatch.delenv(key, raising=False)
-    monkeypatch.setenv("VDS_AUDIT_BOOTSTRAP_HOME", "false")
-    monkeypatch.setenv("VDS_AUDIT_LLM_ENABLED", "false")
-    # Pre-set to a small value so load_shared_env inside _core_apply cannot load the
-    # host ~/.vds/.env value (120) which would violate the CC-02 coherence constraint
-    # when batch_timeout_ms / batch_size (52.5s) < tool_timeout_sec.
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_TOOL_TIMEOUT_SEC", "30")
-    yield
-    for key in keys:
-        monkeypatch.delenv(key, raising=False)
-
-
-def _write_profiles(path: Path) -> None:
-    path.write_text(
-        """
-default_profile: openai-default
-profiles:
-  openai-default:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-  openai-local:
-    model:
-      llm:
-        api_key: sk-llm-profile
-        simple: qwen3-coder:8b
-        standard: qwen3-coder:30b
-        complex: qwen3-coder:32b
-      dspy:
-        api_key: sk-dspy-profile
-        model: openai/qwen3-coder:30b
-        max_tokens: 2048
-        temperature: 0.1
-      embedding:
-        base_url: http://localhost:11434
-        model: bge-m3:latest
-        api_key: sk-embed-profile
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__BASE_URL: http://localhost:11434
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    timeout_policy:
-      agent_timeout_seconds: 900
-      agent_timeout_max_seconds: 3600
-      agent_timeout_extension_seconds: 300
-      agent_timeout_extension_attempts: 4
-      agent_timeout_heartbeat_seconds: 20
-      agent_idle_timeout_seconds: 150
-      row_timeout_ms: 60000
-      batch_timeout_ms: 420000
-      row_progress_lease_seconds: 60
-      row_stall_detection_seconds: 30
-      row_absolute_timeout_ms: 600000
-      row_timeout_progress_extension_enabled: true
-      row_timeout_progress_retry_attempts: 2
-      row_timeout_progress_extension_ms: 45000
-      row_timeout_progress_max_ms: 180000
-    skill_policy:
-      enabled: true
-      directories:
-        - /tmp/vds-skills
-      allow_script_execution: true
-      default_trust_tier: external-verified
-      allowed_trust_tiers:
-        - internal
-        - external-verified
-      strict_require_effective_skill: false
-      allowlist:
-        - safe-skill
-      trust_tiers:
-        safe-skill: internal
-    backend_policy:
-      backend: prompt_evaluator
-      locked: false
-      allow_override: false
-    agent_runtime_policy:
-      mode: pydanticai
-      tool_allowlists:
-        code: [grep_search, read_file]
-        docs: [search_evidence, read_evidence_document]
-      non_progress_policy:
-        search_only_burst_min_tool_calls: 5
-        search_only_burst_min_search_calls: 4
-        search_only_burst_max_read_calls: 0
-  gemini:
-    model:
-      llm:
-        simple: gemini-3-pro-high
-        standard: gemini-3-pro-high
-        complex: gemini-3-pro-high
-      dspy:
-        model: gemini/gemini-3-pro-high
-        base_url: http://127.0.0.1:8045
-        system_role_compat: true
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: gemini
-      VDS_AUDIT_LLM__API_KEY: "sk-test"
-      VDS_AUDIT_LLM__BASE_URL: "http://127.0.0.1:8045"
-    backend_policy:
-      backend: prompt_evaluator
-      locked: false
-      allow_override: false
-    agent_runtime_policy:
-      mode: pydanticai
-      tool_allowlists:
-        security: [search_evidence, read_evidence_document]
-      non_progress_policy:
-        search_only_burst_min_tool_calls: 5
-  nvidia-glm-anthropic:
-    model:
-      llm:
-        type: anthropic
-        base_url: http://localhost:8082
-        api_key: sk-nvidia-anthropic
-        stream: false
-        agent_stream: false
-        model: z-ai/glm5
-      dspy:
-        type: anthropic
-        model: anthropic/z-ai/glm5
-  nvidia-glm-anthropic-streaming:
-    model:
-      llm:
-        type: anthropic
-        base_url: http://localhost:8082
-        api_key: sk-nvidia-anthropic
-        stream: true
-        agent_stream: true
-        model: z-ai/glm5
-      dspy:
-        type: anthropic
-        model: anthropic/z-ai/glm5
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-
-
-def test_runtime_profile_applies_default_when_no_cli_override(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-
-    result = runner.invoke(cli.app, ["--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "openai-default"
-
-
-def test_runtime_profile_cli_override_wins(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-llm-profile"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_DSPY_API_KEY") == "sk-dspy-profile"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__MODEL") == "bge-m3:latest"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__API_KEY") == "sk-embed-profile"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "openai-local"
-
-
-def test_runtime_profile_invalid_embedding_model_policy_key_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    model:
-      embedding:
-        base_url: http://localhost:11434
-        model: bge-m3
-        dimensions: 1024
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "model.embedding keys" in result.output
-
-
-def test_runtime_profile_structured_model_supports_model_base_url_api_key(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  protocol-complete:
-    model:
-      llm:
-        type: openai
-        base_url: http://localhost:11434
-        api_key: sk-llm-complete
-        stream: true
-        reasoning_effort: HIGH
-        model: glm-4.7-flash
-      dspy:
-        type: anthropic
-        base_url: https://chat.example.com
-        api_key: sk-dspy-complete
-        model: anthropic/claude-sonnet-4-20250514
-      embedding:
-        base_url: http://localhost:11434
-        api_key: sk-embedding-complete
-        model: bge-m3
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "protocol-complete", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-llm-complete"
-    assert os.environ.get("VDS_AUDIT_LLM__STREAM") == "true"
-    assert os.environ.get("VDS_AUDIT_LLM__REASONING_EFFORT") == "high"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_SIMPLE") == "glm-4.7-flash"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "glm-4.7-flash"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_COMPLEX") == "glm-4.7-flash"
-    assert os.environ.get("VDS_AUDIT_DSPY_PROTOCOL") == "anthropic"
-    assert os.environ.get("VDS_AUDIT_DSPY_BASE_URL") == "https://chat.example.com"
-    assert os.environ.get("VDS_AUDIT_DSPY_API_KEY") == "sk-dspy-complete"
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "anthropic/claude-sonnet-4-20250514"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__API_KEY") == "sk-embedding-complete"
-    assert os.environ.get("VDS_AUDIT_EMBEDDING__MODEL") == "bge-m3"
-
-
-@pytest.mark.parametrize(
-    ("profile_name", "expected_protocol", "expected_base_url", "expected_dspy_protocol", "expected_dspy_model"),
-    [
-        (
-            "alibaba-openai",
-            "openai",
-            "https://coding-intl.dashscope.aliyuncs.com/v1",
-            "openai",
-            "openai/qwen3.5-plus",
-        ),
-        (
-            "alibaba-anthropic",
-            "anthropic",
-            "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic",
-            "anthropic",
-            "anthropic/qwen3.5-plus",
-        ),
-    ],
-)
-def test_runtime_profile_supports_alibaba_qwen35_baseline_without_reasoning_effort(
-    monkeypatch,
-    tmp_path: Path,
-    profile_name: str,
-    expected_protocol: str,
-    expected_base_url: str,
-    expected_dspy_protocol: str,
-    expected_dspy_model: str,
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  alibaba-openai:
-    model:
-      llm:
-        type: openai
-        base_url: https://coding-intl.dashscope.aliyuncs.com/v1
-        api_key: ${ALIBABA_API_KEY}
-        simple: qwen3.5-plus
-        standard: qwen3.5-plus
-        complex: qwen3.5-plus
-      dspy:
-        type: openai
-        model: openai/qwen3.5-plus
-    env:
-      VDS_AUDIT_LLM_ENABLED: "true"
-      VDS_AUDIT_LLM__API_KEY: ${ALIBABA_API_KEY}
-      VDS_AUDIT_LLM__MAX_TOKENS_PER_REQUEST: "12000"
-      VDS_AUDIT_LLM__AGENT_RETRIES: "2"
-      VDS_AUDIT_LLM__OUTPUT_RETRIES: "4"
-
-  alibaba-anthropic:
-    model:
-      llm:
-        type: anthropic
-        base_url: https://coding-intl.dashscope.aliyuncs.com/apps/anthropic
-        api_key: ${ALIBABA_API_KEY}
-        simple: qwen3.5-plus
-        standard: qwen3.5-plus
-        complex: qwen3.5-plus
-      dspy:
-        type: anthropic
-        model: anthropic/qwen3.5-plus
-    env:
-      VDS_AUDIT_LLM_ENABLED: "true"
-      VDS_AUDIT_LLM__API_KEY: ${ALIBABA_API_KEY}
-      VDS_AUDIT_LLM__MAX_TOKENS_PER_REQUEST: "12000"
-      VDS_AUDIT_LLM__AGENT_RETRIES: "2"
-      VDS_AUDIT_LLM__OUTPUT_RETRIES: "4"
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("ALIBABA_API_KEY", "sk-alibaba")
-
-    result = runner.invoke(cli.app, ["--profile", profile_name, "--json-only", "status"])
-
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == expected_protocol
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == expected_base_url
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-alibaba"
-    assert os.environ.get("VDS_AUDIT_LLM_ENABLED") == "true"
-    assert os.environ.get("VDS_AUDIT_LLM__MAX_TOKENS_PER_REQUEST") == "12000"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_RETRIES") == "2"
-    assert os.environ.get("VDS_AUDIT_LLM__OUTPUT_RETRIES") == "4"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_SIMPLE") == "qwen3.5-plus"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "qwen3.5-plus"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_COMPLEX") == "qwen3.5-plus"
-    assert os.environ.get("VDS_AUDIT_DSPY_PROTOCOL") == expected_dspy_protocol
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == expected_dspy_model
-    assert os.environ.get("VDS_AUDIT_LLM__REASONING_EFFORT") is None
-
-
-def test_runtime_profile_rejects_invalid_llm_reasoning_effort(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  bad-reasoning:
-    model:
-      llm:
-        type: openai
-        base_url: http://localhost:11434
-        api_key: sk-llm-complete
-        reasoning_effort: extreme
-        model: glm-4.7-flash
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "bad-reasoning", "status"])
-    assert result.exit_code != 0
-    assert "model.llm.reasoning_effort" in result.output
-
-
-@pytest.mark.parametrize(
-    ("profile_name", "expected_stream", "expected_agent_stream"),
-    [
-        ("nvidia-glm-anthropic", "false", "false"),
-        ("nvidia-glm-anthropic-streaming", "true", "true"),
-    ],
-)
-def test_runtime_profile_nvidia_glm_anthropic_stream_mapping(
-    monkeypatch,
-    tmp_path: Path,
-    profile_name: str,
-    expected_stream: str,
-    expected_agent_stream: str,
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__STREAM", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_STREAM", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_SIMPLE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_STANDARD", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_COMPLEX", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", profile_name, "--json-only", "status"])
-
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "anthropic"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://localhost:8082"
-    assert os.environ.get("VDS_AUDIT_LLM__STREAM") == expected_stream
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_STREAM") == expected_agent_stream
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_SIMPLE") == "z-ai/glm5"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "z-ai/glm5"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_COMPLEX") == "z-ai/glm5"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == profile_name
-
-
-def test_runtime_profile_resolves_api_key_from_env_reference(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  env-key-profile:
-    model:
-      llm:
-        type: openai
-        base_url: http://localhost:11434
-        api_key: ${TROLLLLM_API_KEY}
-        model: glm-4.7-flash
-    env:
-      VDS_AUDIT_LLM__API_KEY: ${TROLLLLM_API_KEY}
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("TROLLLLM_API_KEY", "sk-env-ref-123")
-
-    result = runner.invoke(cli.app, ["--profile", "env-key-profile", "--json-only", "status"])
-
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-env-ref-123"
-
-
-def test_runtime_profile_resolves_env_reference_from_process_env(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  env-key-profile:
-    model:
-      llm:
-        type: anthropic
-        base_url: http://127.0.0.1:8045
-        api_key: ${ANTHROPIC_API_KEY}
-        model: claude-sonnet-4-20250514
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_BOOTSTRAP_HOME", "true")
-    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-from-shared-env")
-    monkeypatch.delenv("VDS_AUDIT_LLM__API_KEY", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "env-key-profile", "--json-only", "status"])
-
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-from-shared-env"
-
-
-def test_runtime_profile_missing_env_reference_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  missing-env-profile:
-    model:
-      llm:
-        type: openai
-        base_url: http://localhost:11434
-        api_key: ${MISSING_PROFILE_KEY}
-        model: glm-4.7-flash
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("MISSING_PROFILE_KEY", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "missing-env-profile", "status"])
-
-    assert result.exit_code != 0
-    assert "MISSING_PROFILE_KEY" in result.output
-    assert "not set or empty" in result.output
-
-
-def test_runtime_profile_gemini_provider_switch(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__API_KEY", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "gemini", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "gemini"
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-test"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://127.0.0.1:8045"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "gemini-3-pro-high"
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "gemini/gemini-3-pro-high"
-    assert os.environ.get("VDS_AUDIT_DSPY_BASE_URL") == "http://127.0.0.1:8045"
-    assert os.environ.get("VDS_AUDIT_DSPY_SYSTEM_ROLE_COMPAT") == "1"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "gemini"
-
-
-def test_runtime_profile_auto_derives_dspy_model_from_provider_and_standard_tier(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  openai-derived:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_DSPY_MODEL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-derived", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "openai/gpt-4o"
-
-
-def test_runtime_profile_explicit_dspy_model_wins_over_auto_derivation(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  openai-explicit:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-      dspy:
-        model: openai/o3-mini
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_DSPY_MODEL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-explicit", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "openai/o3-mini"
-
-
-def test_runtime_profile_split_protocol_does_not_auto_derive_dspy_model(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  split-protocol:
-    model:
-      llm:
-        simple: qwen3-coder:8b
-        standard: qwen3-coder:30b
-        complex: qwen3-coder:32b
-      dspy:
-        type: anthropic
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_DSPY_MODEL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "split-protocol", "status"])
-    assert result.exit_code != 0
-    assert "CC-08 CONFIG_COHERENCE_VIOLATION" in result.output
-
-
-def test_runtime_profile_trollllm_split_protocol_uses_independent_openai_endpoints(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  trollllm-split:
-    env:
-      VDS_AUDIT_LLM_ENABLED: "true"
-      VDS_AUDIT_LLM__API_KEY: sk-trollllm-test
-    model:
-      llm:
-        type: openai
-        base_url: https://chat.trollllm.xyz
-        simple: claude-opus-4-6
-        standard: claude-opus-4-6
-        complex: claude-opus-4-6
-      dspy:
-        type: openai
-        base_url: http://localhost:11434
-        model: ollama/glm-4.7-flash
-    backend_policy:
-      backend: dspy
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_BASE_URL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_MODEL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "trollllm-split", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "https://chat.trollllm.xyz"
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-trollllm-test"
-    assert os.environ.get("VDS_AUDIT_DSPY_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_DSPY_BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "ollama/glm-4.7-flash"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND") == "dspy"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "trollllm-split"
-
-
-def test_runtime_profile_anthropic_gemini_split_protocol_uses_separate_credentials_and_base_urls(
-    monkeypatch, tmp_path: Path
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  anthropic-gemini-split:
-    env:
-      VDS_AUDIT_LLM_ENABLED: "true"
-      VDS_AUDIT_LLM__API_KEY: sk-anthropic-test
-      VDS_AUDIT_DSPY_API_KEY: sk-gemini-test
-    model:
-      llm:
-        type: anthropic
-        base_url: https://api.anthropic.com
-        simple: claude-sonnet-4-20250514
-        standard: claude-sonnet-4-20250514
-        complex: claude-opus-4-20250414
-      dspy:
-        type: gemini
-        base_url: https://generativelanguage.googleapis.com/v1beta
-        model: gemini/gemini-2.0-flash
-        system_role_compat: true
-    backend_policy:
-      backend: dspy
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__API_KEY", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_BASE_URL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_API_KEY", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_DSPY_MODEL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "anthropic-gemini-split", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "anthropic"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "https://api.anthropic.com"
-    assert os.environ.get("VDS_AUDIT_LLM__API_KEY") == "sk-anthropic-test"
-    assert os.environ.get("VDS_AUDIT_DSPY_PROTOCOL") == "gemini"
-    assert os.environ.get("VDS_AUDIT_DSPY_BASE_URL") == "https://generativelanguage.googleapis.com/v1beta"
-    assert os.environ.get("VDS_AUDIT_DSPY_API_KEY") == "sk-gemini-test"
-    assert os.environ.get("VDS_AUDIT_DSPY_MODEL") == "gemini/gemini-2.0-flash"
-    assert os.environ.get("VDS_AUDIT_DSPY_SYSTEM_ROLE_COMPAT") == "1"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND") == "dspy"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "anthropic-gemini-split"
-
-
-def test_runtime_profile_fail_fast_on_dspy_provider_model_mismatch(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: gemini
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gemini-3-pro-high
-        standard: gemini-3-pro-high
-        complex: gemini-3-pro-high
-      dspy:
-        model: anthropic/claude-sonnet-4-20250514
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "incoherent" in result.output
-
-
-def test_runtime_profile_env_override_wins(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_PROFILE", "openai-local")
-    monkeypatch.delenv("VDS_AUDIT_LLM_PROTOCOL", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__BASE_URL", raising=False)
-
-    result = runner.invoke(cli.app, ["--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://localhost:11434"
-    assert cli._cli_state.get("runtime_profile", {}).get("name") == "openai-local"
-
-
-def test_runtime_profile_cli_override_replaces_existing_env(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_LLM_PROTOCOL", "openai")
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-
-
-def test_runtime_profile_cli_override_allows_explicit_model_and_base_url_under_openai_protocol(
-    monkeypatch, tmp_path: Path
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_LLM__MODEL_STANDARD", "gemini-3-pro-high")
-    monkeypatch.setenv("VDS_AUDIT_DSPY_MODEL", "gemini/gemini-3-pro-high")
-    monkeypatch.setenv("VDS_AUDIT_LLM__BASE_URL", "http://127.0.0.1:8045")
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-
-
-def test_runtime_profile_cli_override_allows_prefixed_dspy_model_for_openai_protocol(
-    monkeypatch, tmp_path: Path
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_DSPY_MODEL", "gemini/gemini-3-pro-high")
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-
-
-def test_runtime_profile_cli_override_preserves_explicit_dspy_temperature(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_DSPY_TEMPERATURE", "0.7")
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_DSPY_TEMPERATURE") == "0.7"
-
-
-def test_runtime_profile_default_does_not_override_existing_env(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_LLM_PROTOCOL", "openai")
-    monkeypatch.setenv("VDS_AUDIT_LLM__MODEL_SIMPLE", "existing-simple")
-    monkeypatch.setenv("VDS_AUDIT_LLM__MODEL_STANDARD", "existing-standard")
-    monkeypatch.setenv("VDS_AUDIT_LLM__MODEL_COMPLEX", "existing-complex")
-
-    result = runner.invoke(cli.app, ["--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-
-
-def test_runtime_profile_applies_timeout_policy(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_TIMEOUT_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_TIMEOUT_MAX_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_TIMEOUT_EXTENSION_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_TIMEOUT_EXTENSION_ATTEMPTS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_TIMEOUT_HEARTBEAT_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_IDLE_TIMEOUT_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ROW_TIMEOUT_MS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_BATCH_TIMEOUT_MS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_TIMEOUT_POLICY__ROW_PROGRESS_LEASE_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_TIMEOUT_POLICY__ROW_STALL_DETECTION_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_TIMEOUT_POLICY__ROW_ABSOLUTE_TIMEOUT_MS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_ENABLED", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_RETRY_ATTEMPTS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_MS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_MAX_MS", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_TIMEOUT_SECONDS") == "900.0"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_TIMEOUT_MAX_SECONDS") == "3600.0"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_TIMEOUT_EXTENSION_SECONDS") == "300.0"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_TIMEOUT_EXTENSION_ATTEMPTS") == "4"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_TIMEOUT_HEARTBEAT_SECONDS") == "20.0"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_IDLE_TIMEOUT_SECONDS") == "150.0"
-    assert os.environ.get("VDS_AUDIT_ROW_TIMEOUT_MS") == "60000"
-    assert os.environ.get("VDS_AUDIT_BATCH_TIMEOUT_MS") == "420000"
-    assert os.environ.get("VDS_AUDIT_TIMEOUT_POLICY__ROW_PROGRESS_LEASE_SECONDS") == "60"
-    assert os.environ.get("VDS_AUDIT_TIMEOUT_POLICY__ROW_STALL_DETECTION_SECONDS") == "30"
-    assert os.environ.get("VDS_AUDIT_TIMEOUT_POLICY__ROW_ABSOLUTE_TIMEOUT_MS") == "600000"
-    assert os.environ.get("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_ENABLED") == "1"
-    assert os.environ.get("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_RETRY_ATTEMPTS") == "2"
-    assert os.environ.get("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_EXTENSION_MS") == "45000"
-    assert os.environ.get("VDS_AUDIT_ROW_TIMEOUT_PROGRESS_MAX_MS") == "180000"
-
-
-def test_runtime_profile_missing_name_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "missing-profile", "status"])
-    assert result.exit_code != 0
-    assert "missing-profile" in result.output
-
-
-def test_runtime_profile_invalid_timeout_policy_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    timeout_policy:
-      agent_timeout_extension_attempts: -1
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "timeout_policy.agent_timeout_extension_attempts" in result.output
-
-
-def test_runtime_profile_applies_skill_policy(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_TOOLSET_ENABLED", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_DIRECTORIES", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_ALLOW_SCRIPT_EXECUTION", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_DEFAULT_TRUST_TIER", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_ALLOWED_TRUST_TIERS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_ALLOWLIST", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__SKILLS_TRUST_TIERS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_TOOLSET_ENABLED") == "true"
-    import json as _json
-
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_DIRECTORIES") == _json.dumps([os.path.realpath("/tmp/vds-skills")])
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_ALLOW_SCRIPT_EXECUTION") == "true"
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_DEFAULT_TRUST_TIER") == "external-verified"
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_ALLOWED_TRUST_TIERS") == '["internal", "external-verified"]'
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_ALLOWLIST") == '["safe-skill"]'
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_TRUST_TIERS") == '{"safe-skill": "internal"}'
-    assert os.environ.get("VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL") == "false"
-
-
-def test_runtime_profile_cli_override_preserves_explicit_skill_policy_env(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL", "true")
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL") == "true"
-
-
-def test_runtime_profile_cli_override_switches_profiles_in_same_process(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    cli._cli_state.clear()
-
-    first = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert first.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "openai"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://localhost:11434"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "qwen3-coder:30b"
-
-    second = runner.invoke(cli.app, ["--profile", "gemini", "--json-only", "status"])
-    assert second.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM_PROTOCOL") == "gemini"
-    assert os.environ.get("VDS_AUDIT_LLM__BASE_URL") == "http://127.0.0.1:8045"
-    assert os.environ.get("VDS_AUDIT_LLM__MODEL_STANDARD") == "gemini-3-pro-high"
-
-
-def test_runtime_profile_invalid_skill_policy_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    skill_policy:
-      default_trust_tier: unknown-tier
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "skill_policy.default_trust_tier" in result.output
-
-
-def test_runtime_profile_invalid_skill_policy_directories_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    skill_policy:
-      directories: not-a-list
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "skill_policy.directories" in result.output
-
-
-def test_runtime_profile_applies_backend_policy(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_SOURCE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_LOCKED", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_ALLOW_OVERRIDE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_OVERRIDE", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND") == "prompt_evaluator"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_SOURCE") == "profile"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_LOCKED") == "false"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_ALLOW_OVERRIDE") == "false"
-
-
-def test_runtime_profile_applies_agent_runtime_policy(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    _write_profiles(profiles_file)
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM__AGENT_RUNTIME_MODE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_ALLOWLISTS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_NON_PROGRESS_POLICY", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "openai-local", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_RUNTIME_MODE") == "pydanticai"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_ALLOWLISTS") is not None
-    assert os.environ.get("VDS_AUDIT_AGENTIC_NON_PROGRESS_POLICY") is not None
-
-
-def test_runtime_profile_fail_fast_when_pydantic_mode_has_sdk_settings(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  mixed:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: anthropic
-      VDS_AUDIT_LLM__AGENT_RUNTIME_MODE: pydanticai
-      VDS_AUDIT_CLAUDE_AGENT_SDK__SETTING_SOURCES: '["user","project"]'
-      VDS_AUDIT_CLAUDE_AGENT_SDK__ALLOWED_TOOLS: '["Skill"]'
-      VDS_AUDIT_CLAUDE_AGENT_SDK__WORKING_DIRECTORY: /tmp
-      VDS_AUDIT_CLAUDE_AGENT_SDK__SKILLS_DIRECTORY: /tmp
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "mixed", "status"])
-    assert result.exit_code != 0
-    assert "VDS_AUDIT_CLAUDE_AGENT_SDK" in result.output
-
-
-def test_runtime_profile_fail_fast_when_legacy_mode_requested(monkeypatch, tmp_path: Path) -> None:
-    """FR-37: Legacy runtime mode (claude-agent-sdk) must be rejected at config load."""
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  sdk-broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: anthropic
-      VDS_AUDIT_LLM__AGENT_RUNTIME_MODE: claude-agent-sdk
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_CLAUDE_AGENT_SDK__SETTING_SOURCES", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_CLAUDE_AGENT_SDK__ALLOWED_TOOLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_CLAUDE_AGENT_SDK__WORKING_DIRECTORY", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_CLAUDE_AGENT_SDK__SKILLS_DIRECTORY", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "sdk-broken", "status"])
-    # FR-37: Hard-cut rejection - invalid mode must fail, not fallback
-    assert result.exit_code != 0
-    # The rejection surfaces as a ValueError exception, not stdout output
-    assert result.exception is not None
-    assert "claude-agent-sdk" in str(result.exception)
-    assert "pydanticai" in str(result.exception)
-
-
-def test_runtime_profile_fail_fast_on_official_anthropic_model_policy_mismatch(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  endpoint-mismatch:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: anthropic
-      VDS_AUDIT_LLM__BASE_URL: https://api.anthropic.com
-      VDS_AUDIT_LLM__MODEL_STANDARD: gpt-4o-mini
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "endpoint-mismatch", "status"])
-    assert result.exit_code != 0
-    assert "Endpoint/model compatibility check failed" in result.output
-
-
-def test_runtime_profile_fail_fast_when_llm_enabled_and_model_tiers_missing(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  missing-tiers:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM_ENABLED: "true"
-      VDS_AUDIT_LLM__API_KEY: sk-test
-      VDS_AUDIT_LLM__MODEL_SIMPLE: "__VDS_MODEL_REQUIRED__"
-      VDS_AUDIT_LLM__MODEL_STANDARD: "__VDS_MODEL_REQUIRED__"
-      VDS_AUDIT_LLM__MODEL_COMPLEX: "__VDS_MODEL_REQUIRED__"
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_SIMPLE", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_STANDARD", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__MODEL_COMPLEX", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "missing-tiers", "status"])
-    assert result.exit_code != 0
-    assert "LLM model tier configuration is required when LLM is enabled" in result.output
-
-
-def test_runtime_profile_backend_policy_override_request(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  open:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    backend_policy:
-      backend: prompt_evaluator
-      allow_override: true
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_OVERRIDE", "dspy")
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_SOURCE", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "open", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND") == "dspy"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_SOURCE") == "override_request"
-
-
-def test_runtime_profile_backend_policy_locked_rejects_override_request(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  locked:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    backend_policy:
-      backend: prompt_evaluator
-      locked: true
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.setenv("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND_OVERRIDE", "dspy")
-
-    result = runner.invoke(cli.app, ["--profile", "locked", "status"])
-    assert result.exit_code != 0
-    assert "ROW_EVALUATION_BACKEND_OVERRIDE" in result.output
-
-
-def test_runtime_profile_backend_policy_invalid_backend_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    backend_policy:
-      backend: invalid-backend
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "backend_policy.backend" in result.output
-
-
-def test_runtime_profile_backend_policy_anthropic_direct_rejected(monkeypatch, tmp_path: Path) -> None:
-    """FR-37: anthropic-direct backend must be rejected at profile validation (hard-cut)."""
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  legacy-anthropic:
-    backend_policy:
-      backend: anthropic-direct
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "legacy-anthropic", "status"])
-    assert result.exit_code != 0
-    assert "backend_policy.backend" in result.output
-
-
-def test_runtime_profile_agent_runtime_policy_invalid_mode_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    agent_runtime_policy:
-      mode: unsupported
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "agent_runtime_policy.mode" in result.output
-
-
-def test_runtime_profile_agent_runtime_policy_invalid_allowlist_fails_fast(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  broken:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-    agent_runtime_policy:
-      mode: pydanticai
-      tool_allowlists:
-        docs: [search_evidence, ""]
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "broken", "status"])
-    assert result.exit_code != 0
-    assert "agent_runtime_policy.tool_allowlists.docs[1]" in result.output
-
-
-def test_project_profile_flag_renamed_in_command_help() -> None:
-    result = runner.invoke(cli.app, ["analyze-template", "--help"])
-    assert result.exit_code == 0
-    assert "--project-profile" in result.output
-
-
-def test_normalize_run_parameters_injects_runtime_profile_and_mode(monkeypatch) -> None:
-    cli._cli_state["runtime_profile"] = {"name": "openai-local"}
-
-    class _RuntimeMode:
-        value = "pydanticai"
-
-    class _LlmConfig:
-        agent_runtime_mode = _RuntimeMode()
-
-    class _Config:
-        llm = _LlmConfig()
-
-    monkeypatch.setattr(cli, "get_config", _Config)
-
-    normalized = cli._normalize_run_parameters({"command": "workflow"})
-    assert normalized["runtime_profile"] == "openai-local"
-    assert normalized["agent_runtime_mode"] == "pydanticai"
-
-
-def test_runtime_profile_supports_agentic_non_progress_preset(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  preset-profile:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      non_progress_preset: permissive
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_NON_PROGRESS_PRESET", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "preset-profile", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_NON_PROGRESS_PRESET") == "permissive"
-
-
-def test_cli_non_progress_preset_overrides_profile(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  preset-profile:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      non_progress_preset: strict
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(
-        cli.app,
-        ["--profile", "preset-profile", "--non-progress-preset", "permissive", "--json-only", "status"],
-    )
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_NON_PROGRESS_PRESET") == "permissive"
-
-
-def test_runtime_profile_fails_fast_on_coherence_violation(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  incoherent:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-      VDS_AUDIT_LLM__MODEL_SIMPLE: gpt-4o-mini
-      VDS_AUDIT_LLM__MODEL_STANDARD: gpt-4o
-      VDS_AUDIT_LLM__MODEL_COMPLEX: gpt-4.1
-      VDS_AUDIT_AGENTIC_NON_PROGRESS_POLICY: '{"high_repeat_min_tool_calls": 4, "fallback_single_tool_min_tool_calls": 6}'
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "incoherent", "status"])
-    assert result.exit_code != 0
-
-
-# ── Agentic tool-first scalar policy tests ─────────────────────────
-
-
-def test_runtime_profile_supports_agentic_tool_first_max_steps(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  steps-profile:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      tool_first_max_steps: 25
-      tool_first_timeout_seconds: 30.0
-      tool_first_budget_units: 40
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_TIMEOUT_SECONDS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_BUDGET_UNITS", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "steps-profile", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS") == "25"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_TIMEOUT_SECONDS") == "30.0"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_BUDGET_UNITS") == "40"
-
-
-def test_runtime_profile_agentic_tool_first_out_of_range_fails(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  bad-steps:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      tool_first_max_steps: 999
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "bad-steps", "status"])
-    assert result.exit_code != 0
-    assert "out-of-range" in result.output
-
-
-def test_runtime_profile_env_var_overrides_agentic_tool_first(monkeypatch, tmp_path: Path) -> None:
-    """Process env var wins over default profile YAML value (force_override=False)."""
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-default_profile: steps-profile
-profiles:
-  steps-profile:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      tool_first_max_steps: 25
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    # Pre-set the env var — it should win over default profile value
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS", "10")
-
-    result = runner.invoke(cli.app, ["--json-only", "status"])
-    assert result.exit_code == 0
-    # Env var wins over default profile (force_override=False)
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_STEPS") == "10"
-
-
-def test_runtime_profile_supports_agentic_security_tool_calls_limit(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  security-budget:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      security_tool_calls_limit: 11
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_TOOL_CALLS_LIMIT", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "security-budget", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_SECURITY_TOOL_CALLS_LIMIT") == "11"
-
-
-def test_runtime_profile_supports_agentic_tool_calls_limit_zero_sentinel(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  zero-budget:
-    env:
-      VDS_AUDIT_LLM_PROTOCOL: openai
-      VDS_AUDIT_LLM__API_KEY: sk-test
-    model:
-      llm:
-        simple: gpt-4o-mini
-        standard: gpt-4o
-        complex: gpt-4.1
-    agentic:
-      tool_calls_limit: 0
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_CALLS_LIMIT", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "zero-budget", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_CALLS_LIMIT") == "0"
-
-
-def test_runtime_profile_supports_agentic_strict_no_fallback_route_caps_and_code_review_budget(
-    monkeypatch, tmp_path: Path
-) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  codex-policy:
-    model:
-      llm:
-        type: openai-codex
-        base_url: https://chatgpt.com/backend-api/codex
-        api_key: sk-codex
-        simple: gpt-5.3-codex
-        standard: gpt-5.3-codex
-        complex: gpt-5.3-codex
-        code_review_max_total_chars: 210000
-    agentic:
-      strict_no_fallback: true
-      tool_first_max_route_transitions: 6
-      tool_first_max_route_transitions_per_pair: 2
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_STRICT_NO_FALLBACK", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS_PER_PAIR", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS", raising=False)
-
-    result = runner.invoke(cli.app, ["--profile", "codex-policy", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_AGENTIC_STRICT_NO_FALLBACK") == "true"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS") == "6"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS_PER_PAIR") == "2"
-    assert os.environ.get("VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS") == "210000"
-
-
-def test_codex_chatgpt_profile_applies_deterministic_baseline_defaults(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  codex-chatgpt:
-    model:
-      llm:
-        type: openai-codex
-        base_url: https://chatgpt.com/backend-api/codex
-        api_key: sk-codex
-        simple: gpt-5.3-codex
-        standard: gpt-5.3-codex
-        complex: gpt-5.3-codex
-      dspy:
-        type: openai
-        model: openai/gpt-5.3-codex
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "codex-chatgpt", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__SKILLS_TOOLSET_ENABLED") == "false"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_ENABLE_SKILLS_TOOLSET") == "false"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_SECURITY_ENABLE_SKILLS_TOOLSET") == "false"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_STRICT_REQUIRE_EFFECTIVE_SKILL") == "false"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_STRICT_NO_FALLBACK") == "true"
-    assert os.environ.get("VDS_AUDIT_LLM__ROW_EVALUATION_BACKEND") == "prompt_evaluator"
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_RETRIES") == "2"
-    assert os.environ.get("VDS_AUDIT_LLM__OUTPUT_RETRIES") == "4"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS") == "6"
-    assert os.environ.get("VDS_AUDIT_AGENTIC_TOOL_FIRST_MAX_ROUTE_TRANSITIONS_PER_PAIR") == "2"
-    assert os.environ.get("VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS") == "200000"
-    assert os.environ.get("VDS_AUDIT_DSPY_BASE_URL") is None
-
-
-def test_codex_chatgpt_profile_keeps_explicit_overrides_over_baseline_defaults(monkeypatch, tmp_path: Path) -> None:
-    profiles_file = tmp_path / "audit.profiles.yaml"
-    profiles_file.write_text(
-        """
-profiles:
-  codex-chatgpt:
-    model:
-      llm:
-        type: openai-codex
-        base_url: https://chatgpt.com/backend-api/codex
-        api_key: sk-codex
-        simple: gpt-5.3-codex
-        standard: gpt-5.3-codex
-        complex: gpt-5.3-codex
-    env:
-      VDS_AUDIT_LLM__AGENT_RETRIES: "5"
-      VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS: "150000"
-""".strip()
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setenv("VDS_AUDIT_RUNTIME_PROFILES_FILE", str(profiles_file))
-
-    result = runner.invoke(cli.app, ["--profile", "codex-chatgpt", "--json-only", "status"])
-    assert result.exit_code == 0
-    assert os.environ.get("VDS_AUDIT_LLM__AGENT_RETRIES") == "5"
-    assert os.environ.get("VDS_AUDIT_LLM__CODE_REVIEW_MAX_TOTAL_CHARS") == "150000"