Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

77.2 KB
Raw Blame
from __future__ import annotations

import errno
from types import SimpleNamespace

import click
import pytest

import headroom.cli.wrap as wrap_cli
import headroom.install.health as install_health
import headroom.install.runtime as install_runtime


@pytest.fixture(autouse=True)
def _no_attached_wrappers(monkeypatch: pytest.MonkeyPatch) -> None:
    """Default: no other wrap clients attached, so restart paths are hermetic.

    The ephemeral restart guards consult ``_live_proxy_clients``; without this, a
    real ``headroom wrap`` session on the dev's machine could make these tests
    flaky. Individual tests override this to simulate attached wrappers.
    """
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [])
    # These recovery tests control readiness through the health probe; process
    # identity and launchd ownership have their own runtime-level coverage.
    monkeypatch.setattr(
        install_runtime,
        "runtime_ready",
        lambda manifest: install_health.probe_ready(manifest.health_url),
    )
    for name in (
        "ANTHROPIC_TARGET_API_URL",
        "OPENAI_TARGET_API_URL",
        "GEMINI_TARGET_API_URL",
        "CLOUDCODE_TARGET_API_URL",
        "VERTEX_TARGET_API_URL",
        "AUGMENT_TARGET_API_URL",
        "FACTORY_TARGET_API_URL",
        "HEADROOM_BACKEND",
    ):
        monkeypatch.delenv(name, raising=False)


class _Manifest:
    profile = "default"
    preset = "persistent-service"
    supervisor_kind = "service"
    health_url = "http://127.0.0.1:8787/readyz"
    runtime_kind = "python"


@pytest.fixture(params=["darwin", "linux", "win32"])
def runtime_platform(monkeypatch: pytest.MonkeyPatch, request) -> None:
    # Replace only this module's sys reference, never the process-wide object.
    monkeypatch.setattr(install_runtime, "sys", SimpleNamespace(platform=request.param))


def test_ensure_proxy_recovers_matching_persistent_deployment(
    monkeypatch, runtime_platform
) -> None:
    calls: list[str] = []

    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: False)
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(
        "headroom.install.supervisors.start_supervisor",
        lambda manifest: calls.append(f"start:{manifest.profile}"),
    )
    monkeypatch.setattr(
        "headroom.install.runtime.wait_ready",
        lambda manifest, timeout_seconds=45, require_identity=False: True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("ephemeral proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls == ["start:default"]


def test_ensure_proxy_recovers_persistent_deployment_when_socket_is_bound(
    monkeypatch, runtime_platform
) -> None:
    calls: list[str] = []

    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    # A bare TCP accept no longer proves the listener is Headroom;
    # identify it via /health so the recovery path still applies.
    monkeypatch.setattr(
        wrap_cli, "_query_proxy_health", lambda port: {"version": "0.0.0-test", "config": {}}
    )
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(
        "headroom.install.supervisors.start_supervisor",
        lambda manifest: calls.append(f"start:{manifest.profile}"),
    )
    monkeypatch.setattr(
        "headroom.install.runtime.wait_ready",
        lambda manifest, timeout_seconds=45, require_identity=False: True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_query_proxy_health",
        lambda port: {"version": wrap_cli._HEADROOM_VERSION, "config": {"backend": "anthropic"}},
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("matching recovered proxy should be reused")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls == ["start:default"]


def test_ensure_proxy_rejects_unhealthy_persistent_deployment(monkeypatch) -> None:
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    # Headroom-identified listener: a foreign squatter would fall
    # through to a fresh port instead of raising.
    monkeypatch.setattr(
        wrap_cli, "_query_proxy_health", lambda port: {"version": "0.0.0-test", "config": {}}
    )
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: False)

    try:
        wrap_cli._ensure_proxy(8787, False)
    except click.ClickException as exc:
        assert "is not healthy" in str(exc)
    else:
        raise AssertionError("expected unhealthy persistent deployment to raise")


def test_ensure_proxy_falls_back_when_persistent_manifest_is_stale(monkeypatch) -> None:
    calls: list[str] = []

    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: False)
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: False)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_find_available_port", lambda port, **kw: port)
    monkeypatch.setattr(wrap_cli, "_start_proxy", lambda *args, **kwargs: calls.append("start"))

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls == ["start"]


def test_ensure_proxy_reports_unbindable_port_before_starting_subprocess(monkeypatch) -> None:
    calls: list[str] = []

    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: False)
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda port, **kw: (_ for _ in ()).throw(
            OSError(errno.EADDRNOTAVAIL, "address not available")
        ),
    )
    monkeypatch.setattr(wrap_cli, "_start_proxy", lambda *args, **kwargs: calls.append("start"))

    try:
        wrap_cli._ensure_proxy(8787, False, agent_type="cursor")
    except click.ClickException as exc:
        message = str(exc)
    else:
        raise AssertionError("expected unbindable port to raise before starting proxy")

    assert "Port 8787 is unavailable" in message
    assert calls == []


def test_ensure_proxy_restarts_idle_stale_persistent_deployment(monkeypatch) -> None:
    calls: list[str] = []
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": 12345},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda manifest, port: calls.append(f"restart:{manifest.profile}:{port}") or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("ephemeral proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls == ["restart:default:8787"]


def test_ensure_proxy_restarts_stale_proxy_from_dev_build(monkeypatch) -> None:
    """A source (-dev) CLI still restarts a stale proxy: the -dev marker is
    display-only and must not disable a real version-mismatch restart."""
    calls: list[str] = []
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": 12345},
    }
    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "0.32.0-dev")
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda manifest, port: calls.append(f"restart:{manifest.profile}:{port}") or True,
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls == ["restart:default:8787"]


def test_ensure_proxy_leaves_active_stale_persistent_deployment_running(monkeypatch) -> None:
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 1, "active_relay_tasks": 2}},
        "config": {"pid": 12345},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("active deployment should not restart")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_defers_persistent_restart_when_http_wrapper_attached(
    monkeypatch,
) -> None:
    """A stale persistent proxy is left running while marker-tracked HTTP
    wrappers are attached, even when WebSocket session count is zero."""
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": 12345},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [999])
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("attached persistent proxy should not restart")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787


def test_find_persistent_manifest_prefers_default_profile(monkeypatch) -> None:
    class DefaultManifest:
        profile = "default"
        port = 8787

    class OtherManifest:
        profile = "custom"
        port = 8787

    monkeypatch.setattr(
        "headroom.install.state.list_manifests",
        lambda: [OtherManifest(), DefaultManifest()],
    )

    manifest = wrap_cli._find_persistent_manifest(8787)

    assert manifest.profile == "default"


def test_recover_persistent_proxy_reuses_healthy_deployment(monkeypatch, runtime_platform) -> None:
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)

    assert wrap_cli._recover_persistent_proxy(8787) is True


def test_recover_persistent_proxy_warns_for_task_deployment(monkeypatch, runtime_platform) -> None:
    class TaskManifest(_Manifest):
        supervisor_kind = "task"

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: TaskManifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)

    assert wrap_cli._recover_persistent_proxy(8787) is False


def test_recover_persistent_proxy_routes_docker_task_to_docker_supervisor(monkeypatch) -> None:
    calls: list[str] = []

    class DockerTaskManifest(_Manifest):
        preset = "persistent-task"
        runtime_kind = "docker"

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: DockerTaskManifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr("headroom.install.runtime.runtime_ready", lambda manifest: False)
    monkeypatch.setattr(
        "headroom.install.runtime.start_persistent_docker",
        lambda manifest: calls.append("docker"),
    )
    waits: list[dict[str, object]] = []
    monkeypatch.setattr(
        "headroom.install.runtime.wait_ready",
        lambda manifest, **kwargs: waits.append(kwargs) or True,
    )

    assert wrap_cli._recover_persistent_proxy(8787) is True
    assert calls == ["docker"]
    assert waits == [{"timeout_seconds": 45, "require_identity": True}]


def test_ensure_proxy_restarts_idle_stale_ephemeral_proxy(monkeypatch) -> None:
    calls: list[object] = []
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"


def test_proxy_version_restart_ignores_non_release_source_labels(monkeypatch) -> None:
    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "0.29.0")
    assert wrap_cli._proxy_needs_version_restart({"version": "source-build+g6266a1d774b5"}) is False
    assert (
        wrap_cli._proxy_needs_version_restart({"version": "source-build+sha.abcdef123456"}) is False
    )
    assert wrap_cli._proxy_needs_version_restart({"version": "6266a1d"}) is False
    assert wrap_cli._proxy_needs_version_restart({"version": "0.29.0+gabcdef0"}) is False

    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "source-build+sha.abcdef123456")
    assert wrap_cli._proxy_needs_version_restart({"version": "0.29.0"}) is False

    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "0.29.1")
    assert wrap_cli._proxy_needs_version_restart({"version": "0.29.0"}) is True


def test_proxy_version_restart_strips_dev_suffix_on_both_sides(monkeypatch) -> None:
    """A dev-built proxy must be compared by its base release, like the CLI is.

    Regression: "0.34.0-dev" failed the release regex, normalized to None, and
    the check never fired, so a stale source-built proxy was silently reused
    forever (observed: a 21-day-old 0.34.0-dev proxy reused by a 0.37.0-dev
    wrap).
    """
    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "0.37.0-dev")
    assert wrap_cli._proxy_needs_version_restart({"version": "0.34.0-dev"}) is True
    assert wrap_cli._proxy_needs_version_restart({"version": "0.37.0-dev"}) is False
    assert wrap_cli._proxy_needs_version_restart({"version": "0.36.4"}) is True

    monkeypatch.setattr(wrap_cli, "_HEADROOM_VERSION", "0.37.0")
    assert wrap_cli._proxy_needs_version_restart({"version": "0.36.4-dev"}) is True

    # Unparseable running versions still never trigger a restart.
    assert wrap_cli._proxy_needs_version_restart({"version": "unknown"}) is False
    assert wrap_cli._proxy_needs_version_restart(None) is False
    assert wrap_cli._proxy_needs_version_restart({}) is False


def test_ensure_proxy_restarts_ephemeral_proxy_for_openai_api_url_mismatch(monkeypatch) -> None:
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "memory": False,
            "learn": False,
            "code_graph": False,
            "openai_api_url": "https://api.githubcopilot.com",
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        openai_api_url="https://api.individual.githubcopilot.com",
    )

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"
    assert calls[1][2]["openai_api_url"] == "https://api.individual.githubcopilot.com"


def test_proxy_routing_mismatches_detects_backend_and_urls(monkeypatch) -> None:
    monkeypatch.delenv("HEADROOM_BACKEND", raising=False)
    check = wrap_cli._proxy_routing_mismatches

    # Stock proxy vs stock request: compatible.
    assert check({"backend": "anthropic"}, backend=None) == []
    # Running non-default backend vs default request: mismatch.
    assert check({"backend": "anyllm"}, backend=None) == ["backend"]
    # Requested backend vs different running backend: mismatch.
    assert check({"backend": "anthropic"}, backend="anyllm") == ["backend"]
    # HEADROOM_BACKEND env feeds the effective requested backend.
    monkeypatch.setenv("HEADROOM_BACKEND", "anyllm")
    assert check({"backend": "anyllm"}, backend=None) == []
    monkeypatch.delenv("HEADROOM_BACKEND")

    # Running proxy carries an upstream the caller never requested (the
    # 2026-08-22 incident: a wrap-auggie proxy reused by wrap codex).
    assert check(
        {"backend": "anthropic", "augment_api_url": "https://xlb.api.augmentcode.com"},
        backend=None,
    ) == ["augment_api_url"]
    # Requested upstream the running proxy does not have: mismatch.
    assert check(
        {"backend": "anthropic"},
        backend=None,
        requested_api_urls={"openai_api_url": "https://api.githubcopilot.com"},
    ) == ["openai_api_url"]
    # Same upstream on both sides, modulo normalization noise: compatible.
    assert (
        check(
            {"backend": "anthropic", "openai_api_url": "https://api.githubcopilot.com/v1/"},
            backend=None,
            requested_api_urls={"openai_api_url": "https://api.githubcopilot.com"},
        )
        == []
    )
    # Captive provider paths are semantic; /v1 is not a removable transport
    # convention for their REST catch-all routing.
    assert check(
        {"backend": "anthropic", "factory_api_url": "https://factory.example/v1"},
        backend=None,
        requested_api_urls={"factory_api_url": "https://factory.example"},
    ) == ["factory_api_url"]
    # Missing backend key (older proxy): treated as unknown, not a mismatch.
    assert check({"openai_api_url": None}, backend=None) == []


def test_effective_requested_proxy_routing_uses_startup_precedence(monkeypatch) -> None:
    monkeypatch.setenv("HEADROOM_BACKEND", "anyllm")
    monkeypatch.setenv("OPENAI_TARGET_API_URL", "https://env.openai.test")
    monkeypatch.setenv("VERTEX_TARGET_API_URL", "https://env.vertex.test")
    monkeypatch.setenv("AUGMENT_TARGET_API_URL", "https://env.augment.test/v1")
    monkeypatch.setenv("FACTORY_TARGET_API_URL", "https://env.factory.test/v1")

    backend, api_urls = wrap_cli._effective_requested_proxy_routing(
        backend=None,
        openai_api_url="https://explicit.openai.test",
        anthropic_api_url=None,
        vertex_api_url=None,
        clear_vertex_api_url=True,
    )

    assert backend == "anyllm"
    assert api_urls["openai_api_url"] == "https://explicit.openai.test"
    assert api_urls["vertex_api_url"] is None
    assert api_urls["augment_api_url"] == "https://env.augment.test/v1"
    assert api_urls["factory_api_url"] == "https://env.factory.test/v1"


def test_ensure_proxy_restarts_idle_proxy_for_routing_mismatch(monkeypatch) -> None:
    """A clientless proxy with captive routing (augment upstream) is restarted."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "memory": False,
            "learn": False,
            "code_graph": False,
            "backend": "anthropic",
            "augment_api_url": "https://xlb.api.augmentcode.com",
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [])
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"


def _routing_mismatch_health(config_overrides: dict) -> dict:
    """Shared fixture: running proxy with captive augment routing (mismatch)."""
    config = {
        "pid": "12345",
        "memory": False,
        "learn": False,
        "code_graph": False,
        "backend": "anthropic",
        "augment_api_url": "https://xlb.api.augmentcode.com",
    }
    config.update(config_overrides)
    return {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": config,
    }


def test_ensure_proxy_routing_mismatch_without_pid_raises(monkeypatch) -> None:
    """Incompatible proxy that exposes no PID cannot be restarted: fail loud."""
    health = _routing_mismatch_health({})
    del health["config"]["pid"]

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *a, **kw: (_ for _ in ()).throw(AssertionError("must not start")),
    )

    with pytest.raises(click.ClickException, match="did not expose a PID"):
        wrap_cli._ensure_proxy(8787, False)


def test_ensure_proxy_routing_mismatch_kill_failure_raises(monkeypatch) -> None:
    """When the incompatible proxy survives the kill attempt: fail loud."""
    health = _routing_mismatch_health({})

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_kill_proxy_by_pid", lambda pid, port: False)
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *a, **kw: (_ for _ in ()).throw(AssertionError("must not start")),
    )

    with pytest.raises(click.ClickException, match="Failed to stop incompatible proxy"):
        wrap_cli._ensure_proxy(8787, False)


def test_ensure_proxy_bumps_port_for_routing_mismatch_with_attached_clients(
    monkeypatch,
) -> None:
    """With live clients attached, an incompatible proxy is neither reused
    nor restarted: the wrap starts a dedicated proxy on a free port."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "backend": "anthropic",
            "augment_api_url": "https://xlb.api.augmentcode.com",
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [999])
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("incompatible proxy with live clients must not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8799
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"
    assert calls[1][1][0] == 8799


def test_ensure_proxy_reuses_proxy_with_matching_routing_config(monkeypatch) -> None:
    """Happy path: identical routing config reuses the running proxy."""
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "memory": False,
            "learn": False,
            "code_graph": False,
            "backend": "anthropic",
            "openai_api_url": None,
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("must not kill")),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("must not start")),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_restarts_idle_proxy_for_backend_mismatch(monkeypatch) -> None:
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "backend": "anyllm"},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [])
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_never_reuses_configless_proxy(monkeypatch) -> None:
    """A proxy exposing no config block cannot be compatibility-checked; it
    must not be silently reused (the persistent branch already treats
    config-unavailable as fall-through). No PID is known, so the wrap starts
    a dedicated proxy on a free port instead of killing blindly."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_query_proxy_config", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("configless proxy exposes no PID; must not kill")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8799
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_routing_mismatch_on_persistent_deployment_uses_dedicated_port(
    monkeypatch,
) -> None:
    """A persistent deployment's routing comes from its manifest; a wrap with
    different routing must not reuse it AND must not let the ephemeral path
    kill it (the manifest would point at a hijacked port). The wrap starts a
    dedicated proxy on a free port and the deployment keeps running."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "backend": "anthropic",
            "augment_api_url": "https://xlb.api.augmentcode.com",
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not restart the deployment")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not kill the deployment's proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8799
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"
    assert calls[1][1][0] == 8799


def test_ensure_proxy_healthy_persistent_uses_config_fallback(monkeypatch) -> None:
    config = {"pid": 12345, "backend": "anthropic"}

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(
        wrap_cli,
        "_query_proxy_health",
        lambda port: {"version": wrap_cli._HEADROOM_VERSION},
    )
    monkeypatch.setattr(wrap_cli, "_query_proxy_config", lambda port: config)
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("matching persistent proxy should be reused")
        ),
    )

    assert wrap_cli._ensure_proxy(8787, False) == (None, 8787)


def test_ensure_proxy_healthy_configless_persistent_uses_dedicated_port(monkeypatch) -> None:
    calls: list[object] = []

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(
        wrap_cli,
        "_query_proxy_health",
        lambda port: {"version": wrap_cli._HEADROOM_VERSION},
    )
    monkeypatch.setattr(wrap_cli, "_query_proxy_config", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("configless persistent proxy must not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    assert wrap_cli._ensure_proxy(8787, False) == (None, 8799)
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


@pytest.mark.parametrize(
    ("env_name", "config_key"),
    [
        ("ANTHROPIC_TARGET_API_URL", "anthropic_api_url"),
        ("OPENAI_TARGET_API_URL", "openai_api_url"),
        ("GEMINI_TARGET_API_URL", "gemini_api_url"),
        ("CLOUDCODE_TARGET_API_URL", "cloudcode_api_url"),
        ("VERTEX_TARGET_API_URL", "vertex_api_url"),
        ("AUGMENT_TARGET_API_URL", "augment_api_url"),
        ("FACTORY_TARGET_API_URL", "factory_api_url"),
    ],
)
def test_ensure_proxy_reuses_matching_inherited_routing_target(
    monkeypatch,
    env_name: str,
    config_key: str,
) -> None:
    target = "https://tenant.example/api"
    for name in (
        "ANTHROPIC_TARGET_API_URL",
        "OPENAI_TARGET_API_URL",
        "GEMINI_TARGET_API_URL",
        "CLOUDCODE_TARGET_API_URL",
        "VERTEX_TARGET_API_URL",
        "AUGMENT_TARGET_API_URL",
        "FACTORY_TARGET_API_URL",
    ):
        monkeypatch.delenv(name, raising=False)
    monkeypatch.setenv(env_name, target)
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": 12345, "backend": "anthropic", config_key: target},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("matching inherited routing must reuse the proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("matching inherited routing must not kill the proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("matching inherited routing must not start another proxy")
        ),
    )

    assert wrap_cli._ensure_proxy(8787, False) == (None, 8787)


@pytest.mark.parametrize(
    ("ensure_kwargs", "config_overrides", "env_override"),
    [
        (
            {"anthropic_api_url": "https://expected.anthropic.test"},
            {"anthropic_api_url": "https://running.anthropic.test"},
            None,
        ),
        (
            {"vertex_api_url": "https://expected.vertex.test"},
            {"vertex_api_url": "https://running.vertex.test"},
            None,
        ),
        (
            {"backend": "anyllm"},
            {"backend": "anthropic"},
            None,
        ),
        (
            {},
            {"factory_api_url": "https://running.factory.test"},
            ("FACTORY_TARGET_API_URL", "https://expected.factory.test"),
        ),
    ],
)
def test_ensure_proxy_recovered_routing_mismatch_uses_dedicated_port(
    monkeypatch,
    ensure_kwargs: dict[str, object],
    config_overrides: dict[str, object],
    env_override: tuple[str, str] | None,
) -> None:
    calls: list[object] = []
    if env_override is not None:
        monkeypatch.setenv(*env_override)
    config = {"pid": 12345, "backend": "anthropic"}
    config.update(config_overrides)
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": config,
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not restart the persistent proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not kill the persistent proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    assert wrap_cli._ensure_proxy(8787, False, **ensure_kwargs) == (None, 8799)
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_stale_attached_persistent_routing_mismatch_uses_dedicated_port(
    monkeypatch,
) -> None:
    calls: list[object] = []
    health = _routing_mismatch_health({})
    health["version"] = "0.0.1"

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *args, **kwargs: [999])
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("active persistent proxy must not restart")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("active persistent proxy must not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    assert wrap_cli._ensure_proxy(8787, False, memory=True) == (None, 8799)
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_stale_attached_ephemeral_routing_mismatch_uses_dedicated_port(
    monkeypatch,
) -> None:
    calls: list[object] = []
    health = _routing_mismatch_health({})
    health["version"] = "0.0.1"
    health["runtime"]["websocket_sessions"]["active_sessions"] = 1

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *args, **kwargs: [])
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("active proxy must not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    assert wrap_cli._ensure_proxy(8787, False, memory=True) == (None, 8799)
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


@pytest.mark.parametrize(
    ("pid", "kill_result", "message"),
    [
        (None, True, "did not expose a PID"),
        (12345, False, "Failed to stop stale proxy"),
    ],
)
def test_ensure_proxy_stale_idle_restart_failures_are_actionable(
    monkeypatch,
    pid: int | None,
    kill_result: bool,
    message: str,
) -> None:
    config: dict[str, object] = {"backend": "anthropic"}
    if pid is not None:
        config["pid"] = pid
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": config,
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_kill_proxy_by_pid", lambda found_pid, port: kill_result)
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("failed stale restart must not start another proxy")
        ),
    )

    with pytest.raises(click.ClickException, match=message):
        wrap_cli._ensure_proxy(8787, False)


def test_ensure_proxy_starts_isolated_ephemeral_proxy_for_copilot_subscription_seed(
    monkeypatch,
) -> None:
    calls: list[object] = []

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8788,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("subscription-seeded session should not restart the shared proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        copilot_api_token="tid-session-token",
        copilot_refresh_oauth_token="gho-refresh",
        copilot_api_token_expires_at=456.5,
    )

    assert proc is None
    assert actual_port == 8788
    assert calls[0] == ("find_port", 8788)
    assert calls[1][0] == "start"
    assert calls[1][1][0] == 8788
    assert calls[1][2]["copilot_api_token"] == "tid-session-token"
    assert calls[1][2]["copilot_refresh_oauth_token"] == "gho-refresh"
    assert calls[1][2]["copilot_api_token_expires_at"] == 456.5


def test_ensure_proxy_isolates_copilot_subscription_seed_with_api_token_only(monkeypatch) -> None:
    calls: list[object] = []

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8788,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        copilot_api_token="direct-token-only",
    )

    assert proc is None
    assert actual_port == 8788
    assert calls[0] == ("find_port", 8788)
    assert calls[1][0] == "start"
    assert calls[1][2]["copilot_api_token"] == "direct-token-only"


def test_ensure_proxy_starts_isolated_ephemeral_proxy_when_subscription_seed_targets_persistent_port(
    monkeypatch,
) -> None:
    calls: list[object] = []

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr(
        "headroom.install.health.probe_ready",
        lambda url: (_ for _ in ()).throw(
            AssertionError("subscription-seeded session should skip persistent probing")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("subscription-seeded session should not restart the persistent proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8788,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        copilot_api_token="tid-session-token",
        copilot_refresh_oauth_token="gho-refresh",
        copilot_api_token_expires_at=456.5,
    )

    assert proc is None
    assert actual_port == 8788
    assert calls[0] == ("find_port", 8788)
    assert calls[1][0] == "start"
    assert calls[1][1][0] == 8788
    assert calls[1][2]["copilot_api_token"] == "tid-session-token"
    assert calls[1][2]["copilot_refresh_oauth_token"] == "gho-refresh"
    assert calls[1][2]["copilot_api_token_expires_at"] == 456.5


def test_ensure_proxy_reuses_agent_proxy_without_savings_profile(monkeypatch) -> None:
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.delenv("HEADROOM_SAVINGS_PROFILE", raising=False)
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("default agent proxy should not restart for savings profile")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, agent_type="codex")

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_restarts_for_explicit_agent_savings_profile(monkeypatch) -> None:
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setenv("HEADROOM_SAVINGS_PROFILE", "agent-90")
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, agent_type="codex")

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_reuses_agent_proxy_with_savings_profile(monkeypatch) -> None:
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "memory": False,
            "learn": False,
            "code_graph": False,
            "savings_profile": "agent-90",
            "target_ratio": 0.10,
            "compress_user_messages": True,
            "compress_system_messages": True,
            "protect_recent": 2,
            "protect_analysis_context": True,
            "min_tokens_to_crush": 120,
            "max_items_after_crush": 8,
            "smart_crusher_with_compaction": False,
            "accuracy_guard": "strict",
        },
    }

    monkeypatch.setenv("HEADROOM_SAVINGS_PROFILE", "agent-90")
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("configured proxy should not restart")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, agent_type="cursor")

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_leaves_active_stale_ephemeral_proxy_running(monkeypatch) -> None:
    health = {
        "version": "0.0.1",
        "runtime": {"websocket_sessions": {"active_sessions": 2, "active_relay_tasks": 2}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("active proxy should not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_defers_version_restart_when_http_wrapper_attached(monkeypatch) -> None:
    """A stale-version proxy is NOT restarted while a marker-tracked HTTP
    wrapper is attached, even though the WebSocket session count is zero."""
    health = {
        "version": "0.0.1",  # stale → version restart wanted
        # No WebSocket relay sessions — the gap that let the old code kill it.
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    # Another HTTP wrapper (PID 999) is attached per the marker registry.
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [999])
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("attached proxy must not be killed for a version restart")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy must not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_defers_flag_restart_when_other_wrapper_attached(monkeypatch) -> None:
    """Requesting --memory must not restart the proxy out from under another
    attached wrapper; reuse the running proxy as-is instead."""
    health = {
        "version": wrap_cli._HEADROOM_VERSION,  # same version → no version restart
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        # Running proxy lacks `memory`; this session asks for it.
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [999])
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("attached proxy must not be killed to add flags")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("replacement proxy must not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, memory=True)

    assert proc is None
    assert actual_port == 8787


def test_ensure_proxy_restarts_for_flags_when_no_other_wrapper(monkeypatch) -> None:
    """Control: with no other wrapper attached, a missing-flag restart still
    happens — the guard must not block the single-client upgrade path."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {"pid": "12345", "memory": False, "learn": False, "code_graph": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: len(calls) == 0)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [])
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, memory=True)

    assert proc is None
    assert actual_port == 8787
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_diverts_persistent_deployment_for_routing_mismatch(
    monkeypatch,
) -> None:
    """A routing-URL mismatch against a persistent deployment starts a
    dedicated proxy on a free port. Killing the deployment's proxy and
    starting an ephemeral one with the requested routing (the old behavior)
    orphaned the manifest: it still pointed at the port while the routing it
    declares no longer matched what served it."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": 12345,
            "memory": False,
            "learn": False,
            "code_graph": False,
            "openai_api_url": None,
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    # Persistent proxy is running, so _check_proxy returns True
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kw: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not kill the deployment's proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    # Request openai_api_url that differs from running config (None)
    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        openai_api_url="https://api.githubcopilot.com",
    )

    assert proc is None
    assert actual_port == 8799
    # Deployment left running; dedicated proxy started on the free port with
    # the requested routing.
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"
    assert calls[1][1][0] == 8799
    assert calls[1][2]["openai_api_url"] == "https://api.githubcopilot.com"


def test_ensure_proxy_restarts_persistent_deployment_for_memory_mismatch(monkeypatch) -> None:
    """Persistent deployment should restart when memory is requested but not enabled."""
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": 12345,
            "memory": False,
            "learn": False,
            "code_graph": False,
            "openai_api_url": None,
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    # Persistent proxy is running, so _check_proxy returns True
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_port_bind_error", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda pid, port: calls.append(("kill", pid, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    # Request memory that differs from running config (False)
    proc, actual_port = wrap_cli._ensure_proxy(8787, False, memory=True)

    assert proc is None
    assert actual_port == 8787
    # Proxy should be killed and restarted due to memory mismatch
    assert calls[0] == ("kill", 12345, 8787)
    assert calls[1][0] == "start"
    assert calls[1][2]["memory"] is True


def test_ensure_proxy_restarts_recovered_persistent_for_openai_api_url_mismatch(
    monkeypatch,
) -> None:
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": 12345,
            "memory": False,
            "learn": False,
            "code_graph": False,
            "openai_api_url": None,
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not restart the persistent proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("routing mismatch must not kill the persistent proxy")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        openai_api_url="https://api.business.githubcopilot.com",
    )

    assert proc is None
    assert actual_port == 8799
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_restarts_recovered_persistent_when_config_unavailable(monkeypatch) -> None:
    calls: list[object] = []

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: {"version": "x"})
    monkeypatch.setattr(wrap_cli, "_query_proxy_config", lambda port: None)
    monkeypatch.setattr(
        wrap_cli,
        "_find_available_port",
        lambda start_port, **kwargs: calls.append(("find_port", start_port)) or 8799,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("configless recovered proxy must not restart")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("configless recovered proxy must not be killed")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: calls.append(("start", args, kwargs)),
    )

    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        openai_api_url="https://api.business.githubcopilot.com",
    )

    assert proc is None
    assert actual_port == 8799
    assert calls[0] == ("find_port", 8787)
    assert calls[1][0] == "start"


def test_ensure_proxy_reuses_persistent_deployment_when_features_match(monkeypatch) -> None:
    """Persistent deployment should be reused when all requested features match."""
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": 12345,
            "memory": True,
            "learn": False,
            "code_graph": False,
            "openai_api_url": "https://api.githubcopilot.com",
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("should not restart when features match")
        ),
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("should not start ephemeral proxy when features match")
        ),
    )

    # Request same features as running config
    proc, actual_port = wrap_cli._ensure_proxy(
        8787,
        False,
        memory=True,
        openai_api_url="https://api.githubcopilot.com",
    )

    assert proc is None
    assert actual_port == 8787


@pytest.mark.parametrize(
    "ensure_kwargs",
    [
        {"memory": True},
        {"learn": True},
        {"code_graph": True},
    ],
)
def test_ensure_proxy_recovered_persistent_deployment_checks_feature_mismatch(
    monkeypatch,
    ensure_kwargs: dict[str, bool],
) -> None:
    """Recovered persistent deployments must still restart on feature mismatch.

    Regression guard for the recover path: when wrap requests memory, do not
    early-return right after recover; restart the deployment if needed.
    """

    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "memory": False,
            "learn": False,
            "code_graph": False,
            "openai_api_url": None,
        },
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(
        wrap_cli,
        "_restart_persistent_proxy",
        lambda manifest, port: calls.append(("restart", manifest.profile, port)) or True,
    )
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("ephemeral proxy should not start")
        ),
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False, **ensure_kwargs)

    assert proc is None
    assert actual_port == 8787
    assert calls == [("restart", "default", 8787)]


def test_ensure_proxy_recovered_feature_restart_failure_raises(monkeypatch) -> None:
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "config": {"pid": 12345, "backend": "anthropic", "memory": False},
    }

    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: _Manifest())
    monkeypatch.setattr("headroom.install.health.probe_ready", lambda url: False)
    monkeypatch.setattr(wrap_cli, "_recover_persistent_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: True)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_restart_persistent_proxy", lambda manifest, port: False)
    monkeypatch.setattr(
        wrap_cli,
        "_start_proxy",
        lambda *args, **kwargs: (_ for _ in ()).throw(
            AssertionError("failed persistent restart must not start an ephemeral proxy")
        ),
    )

    with pytest.raises(click.ClickException, match="could not be restarted"):
        wrap_cli._ensure_proxy(8787, False, memory=True)


def _dedicated_start(monkeypatch, *, health, manifest=None):
    """Drive a Copilot-seeded wrap that must start a dedicated proxy beside port 8787."""
    calls: list[object] = []
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: manifest)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_find_available_port", lambda start_port, **kw: 8788)
    monkeypatch.setattr(
        wrap_cli, "_start_proxy", lambda *args, **kwargs: calls.append(("start", args, kwargs))
    )
    wrap_cli._ensure_proxy(8787, False, copilot_api_token="tid-session-token")
    assert calls and calls[0][0] == "start"
    return calls[0][2]


def test_dedicated_copilot_proxy_carries_the_shared_proxys_extensions(monkeypatch, capsys) -> None:
    """An enterprise shared proxy enables its savings sinks with --proxy-extension;
    the dedicated proxy a Copilot seed forces must keep reporting through them."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)
    health = {"config": {"pid": "1", "proxy_extensions": ["routemegood", "observability"]}}

    kwargs = _dedicated_start(monkeypatch, health=health)

    assert kwargs["proxy_extensions"] == ["observability", "routemegood"]
    assert "Extensions carried over from the proxy on port 8787: observability,routemegood" in (
        capsys.readouterr().out
    )


@pytest.mark.parametrize("configured", ["teams", ""])
def test_dedicated_copilot_proxy_env_extensions_win(monkeypatch, capsys, configured) -> None:
    """The env var is inherited by the subprocess and outranks the carry-over;
    an empty value is the documented way to start a bare dedicated proxy."""
    monkeypatch.setenv("HEADROOM_PROXY_EXTENSIONS", configured)
    health = {"config": {"pid": "1", "proxy_extensions": ["observability"]}}

    kwargs = _dedicated_start(monkeypatch, health=health)

    assert kwargs["proxy_extensions"] is None
    out = capsys.readouterr().out
    assert "carried over" not in out
    assert "could not read the extensions" not in out


def test_dedicated_copilot_proxy_ignores_a_foreign_port_holder(monkeypatch, capsys) -> None:
    """A non-Headroom service on the port ran no extensions: nothing to carry, no warning."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    kwargs = _dedicated_start(monkeypatch, health={"status": "ok"})

    assert not kwargs["proxy_extensions"]
    assert "could not read the extensions" not in capsys.readouterr().out


def test_dedicated_copilot_proxy_warns_when_the_shared_proxy_hides_its_extensions(
    monkeypatch, capsys
) -> None:
    """A proxy that predates the /health field cannot be read; say so instead of
    silently starting bare."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    kwargs = _dedicated_start(monkeypatch, health={"config": {"pid": "1"}})

    assert kwargs["proxy_extensions"] is None
    out = capsys.readouterr().out
    assert "Warning: could not read the extensions of the proxy on port 8787" in out
    assert "HEADROOM_PROXY_EXTENSIONS=<names>" in out


def test_dedicated_copilot_proxy_reads_extensions_from_the_manifest(monkeypatch) -> None:
    """With no reachable /health, the manifest's recorded environment says what ran."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    class _ExtManifest(_Manifest):
        base_env = {"HEADROOM_PROXY_EXTENSIONS": "observability, lossless_guard"}

    kwargs = _dedicated_start(monkeypatch, health=None, manifest=_ExtManifest())

    assert kwargs["proxy_extensions"] == ["lossless_guard", "observability"]


def test_dedicated_copilot_proxy_reads_extensions_from_the_manifest_proxy_args(monkeypatch) -> None:
    """A manifest edited by hand can enable extensions as ``--proxy-extension``
    flags in ``proxy_args``; the runtime passes them to the proxy verbatim, so
    they count, in both flag forms. Click lets the flag outrank
    ``HEADROOM_PROXY_EXTENSIONS``, so a ``base_env`` value next to the flags is
    not something the shared proxy ran and must not be carried."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    class _ArgsManifest(_Manifest):
        base_env = {"HEADROOM_PROXY_EXTENSIONS": "skill_search"}
        proxy_args = [
            "--host",
            "127.0.0.1",
            "--proxy-extension",
            "observability,control_plane",
            "--proxy-extension=lossless_guard",
        ]

    kwargs = _dedicated_start(monkeypatch, health=None, manifest=_ArgsManifest())

    assert kwargs["proxy_extensions"] == ["control_plane", "lossless_guard", "observability"]


def test_dedicated_copilot_proxy_falls_back_to_the_manifest_for_an_older_proxy(
    monkeypatch, capsys
) -> None:
    """A running proxy that predates the /health field is not the last word when
    the deployment's manifest records what it was installed with."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    class _ExtManifest(_Manifest):
        base_env = {"HEADROOM_PROXY_EXTENSIONS": "control_plane"}

    kwargs = _dedicated_start(monkeypatch, health={"config": {"pid": "1"}}, manifest=_ExtManifest())

    assert kwargs["proxy_extensions"] == ["control_plane"]
    assert "could not read the extensions" not in capsys.readouterr().out


def test_dedicated_copilot_proxy_warns_for_an_older_proxy_whose_manifest_is_silent(
    monkeypatch, capsys
) -> None:
    """A manifest without HEADROOM_PROXY_EXTENSIONS does not prove the running
    proxy has none (its runtime env layers on the launch environment), so an
    older proxy plus a silent manifest is unknown and warns."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    class _SilentManifest(_Manifest):
        base_env = {"ANTHROPIC_API_KEY": "sk-ant-redacted"}

    kwargs = _dedicated_start(
        monkeypatch, health={"config": {"pid": "1"}}, manifest=_SilentManifest()
    )

    assert kwargs["proxy_extensions"] is None
    assert "Warning: could not read the extensions of the proxy on port 8787" in (
        capsys.readouterr().out
    )


def test_dedicated_copilot_proxy_trusts_an_explicitly_empty_manifest_value(
    monkeypatch, capsys
) -> None:
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)

    class _BareManifest(_Manifest):
        base_env = {"HEADROOM_PROXY_EXTENSIONS": ""}

    kwargs = _dedicated_start(monkeypatch, health=None, manifest=_BareManifest())

    assert not kwargs["proxy_extensions"]
    assert "could not read the extensions" not in capsys.readouterr().out


def test_attached_routing_mismatch_carries_the_shared_proxys_extensions(
    monkeypatch, capsys
) -> None:
    """The non-persistent shared proxy with live clients and other routing is
    left running; the dedicated proxy started beside it keeps its extensions."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)
    calls: list[object] = []
    health = {
        "version": wrap_cli._HEADROOM_VERSION,
        "runtime": {"websocket_sessions": {"active_sessions": 0, "active_relay_tasks": 0}},
        "config": {
            "pid": "12345",
            "backend": "anthropic",
            "augment_api_url": "https://xlb.api.augmentcode.com",
            "proxy_extensions": ["control_plane", "observability"],
        },
    }
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: port == 8787)
    monkeypatch.setattr(wrap_cli, "_query_proxy_health", lambda port: health)
    monkeypatch.setattr(wrap_cli, "_live_proxy_clients", lambda *a, **kw: [999])
    monkeypatch.setattr(wrap_cli, "_find_available_port", lambda start_port, **kw: 8799)
    monkeypatch.setattr(
        wrap_cli,
        "_kill_proxy_by_pid",
        lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("must not be killed")),
    )
    monkeypatch.setattr(
        wrap_cli, "_start_proxy", lambda *args, **kwargs: calls.append(("start", args, kwargs))
    )

    proc, actual_port = wrap_cli._ensure_proxy(8787, False)

    assert (proc, actual_port) == (None, 8799)
    assert calls[0][2]["proxy_extensions"] == ["control_plane", "observability"]
    assert "Extensions carried over from the proxy on port 8787" in capsys.readouterr().out


def test_plain_start_passes_no_extensions(monkeypatch) -> None:
    """Nothing owns the port: the proxy starts from the shell env as before."""
    monkeypatch.delenv("HEADROOM_PROXY_EXTENSIONS", raising=False)
    calls: list[object] = []
    monkeypatch.setattr(wrap_cli, "_find_persistent_manifest", lambda port: None)
    monkeypatch.setattr(wrap_cli, "_check_proxy", lambda port: False)
    monkeypatch.setattr(
        wrap_cli,
        "_query_proxy_health",
        lambda port: (_ for _ in ()).throw(AssertionError("no proxy to ask")),
    )
    monkeypatch.setattr(wrap_cli, "_find_available_port", lambda start_port, **kw: 8787)
    monkeypatch.setattr(
        wrap_cli, "_start_proxy", lambda *args, **kwargs: calls.append(("start", args, kwargs))
    )

    wrap_cli._ensure_proxy(8787, False)

    assert calls[0][2]["proxy_extensions"] is None