Spaces:

Erinaldordso
/

Minecraft-Friends-AI-ZeroGPU

Paused

Minecraft-Friends-AI-ZeroGPU / tests /test_altoclef_stack.py

Initialize Naldo controller before joining Minecraft

7837484 verified 29 days ago

12.8 kB

"""Lifecycle and world-scope checks, without launching a Minecraft client."""
import io
import sys
import time
from pathlib import Path
from types import SimpleNamespace

import pytest

sys.path.insert(0, str(Path(__file__).parents[1]))
import altoclef_stack as module

@pytest.fixture
def runner(monkeypatch, tmp_path):
    monkeypatch.setattr(module, "ROOT", tmp_path)
    monkeypatch.delenv("ALTOCLEF_OPENCODE_MODEL", raising=False)
    monkeypatch.delenv("MC_USERNAME", raising=False)
    return module.AltoClefStack()

def response(data):
    return SimpleNamespace(raise_for_status=lambda: None, json=lambda: data)

def test_stale_connected_telemetry_is_an_error(runner, monkeypatch):
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": True, "observed_at": time.time() - 60,
                                  "heartbeat_at": time.time()}))
    with pytest.raises(RuntimeError, match="stopped updating"):
        runner._observe()

def test_loading_heartbeat_accepted_inside_grace(runner, monkeypatch):
    now = time.time()
    runner.last_started_at = now
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": now}))
    assert runner._observe()["loading"] is True

def test_loading_without_heartbeat_is_an_error(runner, monkeypatch):
    runner.last_started_at = time.time()
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": time.time() - 120}))
    with pytest.raises(RuntimeError, match="heartbeat stopped"):
        runner._observe()

def test_exact_initial_payload_accepted_only_in_first_window(runner, monkeypatch):
    # Java's initial /state before the first 2s scheduler tick.
    runner.last_started_at = time.time()
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": 0}))
    assert runner._observe()["loading"] is True
    runner._bridge_seen_at = time.time() - module.FIRST_HEARTBEAT_WINDOW - 1
    with pytest.raises(RuntimeError, match="never published a heartbeat"):
        runner._observe()

def test_reconnect_allowed_bounded_after_play(runner, monkeypatch):
    now = time.time()
    runner.last_started_at = now - module.LOADING_GRACE - 10
    runner._last_connected_at = now - 60
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": now}))
    assert runner._observe()["loading"] is True
    runner._last_connected_at = now - module.RECONNECT_GRACE - 1
    with pytest.raises(RuntimeError, match="did not reconnect"):
        runner._observe()

def test_second_boot_resets_launch_clocks(runner, monkeypatch):
    # Regression: after a crash, the previous launch leaves an old connected
    # timestamp, a stale first-heartbeat clock and an expired grace anchor.
    # The new boot must accept its fresh initial loading payload.
    now = time.time()
    runner._last_connected_at = now - module.RECONNECT_GRACE - 60
    runner._bridge_seen_at = now - module.FIRST_HEARTBEAT_WINDOW - 60
    runner.last_started_at = now - module.LOADING_GRACE - 60
    runner._last_gamer_at = now
    runner._last_mode_set = now
    runner._reset_launch_clocks()
    assert runner._bridge_seen_at is None
    assert runner._last_connected_at is None
    assert runner.last_started_at is None
    assert runner._last_gamer_at == 0.0 and runner._last_mode_set == 0.0
    runner.last_started_at = time.time()
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": 0}))
    assert runner._observe()["loading"] is True

def test_boot_resets_launch_clocks_before_startup():
    import inspect
    source = inspect.getsource(module.AltoClefStack._boot)
    assert "_reset_launch_clocks()" in source
    assert source.index("_reset_launch_clocks()") < source.index("minecraft_ready.wait")

def _bridge_source() -> str:
    return (Path(module.__file__).parents[0] / "altoclef" / "SpaceBridge.java").read_text(encoding="utf-8")

def test_bridge_gates_manual_connect_on_readiness():
    # Pinned Yarn 1.19.4+build.2: TitleScreen class_442, DisconnectedScreen
    # class_419, ConnectScreen class_412, overlay via getOverlay. The manual
    # connect must take the current screen and refuse while a reload overlay
    # is up or vanilla is already connecting.
    source = _bridge_source()
    assert "class_442" in source and "class_419" in source
    # Pinned Yarn 1.19.4+build.2 row: METHOD emh ()Lesx; aJ method_18506
    # getOverlay. The live runtime is intermediary, so the mapped ID (not the
    # Yarn name) must be used.
    assert "method_18506" in source
    assert '"getOverlay"' not in source
    assert "connect(client, currentScreen)" in source
    assert "mc(\"class_412\").isInstance(currentScreen)" in source
    import re
    assert not re.search(r"(?<!, )connect\(client\)", source), \
        "ungated single-arg connect call remains"

def test_bridge_reports_connect_diagnostics():
    source = _bridge_source()
    assert '"connect_state"' in source and '"connect_attempts"' in source

def test_built_bridge_jar_matches_source_version():
    import json as _json
    import zipfile as _zip
    jar = Path(module.__file__).parents[0] / "altoclef" / "space-altoclef-bridge.jar"
    meta = _json.loads(_zip.ZipFile(jar).read("fabric.mod.json").decode())
    assert meta["version"] == "1.0.4"
    assert "space/minecraft/SpaceBridge.class" in _zip.ZipFile(jar).namelist()

def test_client_starts_at_title_without_autojoin_flags(runner, monkeypatch, tmp_path):
    import sys as _sys
    seen: dict = {}
    fake_launcher = SimpleNamespace(
        fabric=SimpleNamespace(install_fabric=lambda *a, **k: None),
        command=SimpleNamespace(
            get_minecraft_command=lambda *a, **k: (seen.update(a[2]), ["java"])[1]),
    )
    monkeypatch.setitem(_sys.modules, "minecraft_launcher_lib", fake_launcher)
    monkeypatch.setattr(module, "CLIENT", tmp_path / "client")
    monkeypatch.setattr(module, "MOD_CACHE", tmp_path / "cache")
    monkeypatch.setattr(module, "_download",
                        lambda url, path, sha=None: (path.parent.mkdir(parents=True, exist_ok=True),
                                                    path.write_bytes(b"x"))[1])
    assert runner._ensure_client(Path("java")) == ["java"]
    # No vanilla --server/--port: autojoin bypasses the TitleScreen, and
    # upstream AltoClef initializes ONLY there (EntryMixin on TitleScreen.init
    # -> TitleScreenEntryEvent -> onInitializeLoad). The bridge's gated
    # fallback connects after resources are done instead.
    assert "server" not in seen and "port" not in seen
    options = (tmp_path / "client" / "options.txt").read_text(encoding="utf-8")
    assert "onboardAccessibility:false" in options
    # Second ensure must not duplicate the key.
    runner._ensure_client(Path("java"))
    options = (tmp_path / "client" / "options.txt").read_text(encoding="utf-8")
    assert options.count("onboardAccessibility:false") == 1

def test_bridge_reports_uninitialized_taskchain_without_npe():
    # A null task chain during loading must surface as initialized=false with
    # diagnostics, never an NPE, and never a fabricated task_active.
    source = _bridge_source()
    assert "chain == null" in source
    assert "taskchain not yet initialized" in source

def test_survival_verified_requires_explicit_survival():
    good = {"connected": True, "error": "", "creative": False}
    assert module.AltoClefStack._survival_verified(good) is True
    # Loading payload without a creative flag is NOT Survival.
    assert module.AltoClefStack._survival_verified({"connected": False, "loading": True}) is False
    assert module.AltoClefStack._survival_verified({"connected": True, "error": "", "creative": True}) is False
    assert module.AltoClefStack._survival_verified({"connected": True, "error": "boom", "creative": False}) is False

def test_loading_past_grace_is_an_error(runner, monkeypatch):
    now = time.time()
    runner.last_started_at = now - module.LOADING_GRACE - 10
    monkeypatch.setattr(module.requests, "get", lambda *a, **k:
                        response({"connected": False, "loading": True, "heartbeat_at": now,
                                  "dispatch_error": "client thread stalled"}))
    with pytest.raises(RuntimeError, match="still not connected"):
        runner._observe()

def test_credits_evidence_survives_restart(runner, monkeypatch):
    state = {"connected": True, "entered_end": True, "credits_observed": True,
             "observed_at": time.time(), "heartbeat_at": time.time()}
    monkeypatch.setattr(module.requests, "get", lambda *a, **k: response(state))
    runner._observe()
    restored = module.AltoClefStack()
    assert restored.status()["state"] == "completed"
    assert restored.status()["goal_completed"]
    assert not restored.status()["running"]

def test_completed_goal_is_not_restarted_by_supervisor(runner, monkeypatch):
    runner.observation = {"entered_end": True, "credits_observed": True}
    runner.state = "stopped"
    monkeypatch.setattr(module.threading, "Thread", lambda *a, **k:
                        pytest.fail("completed goal launched another client"))
    assert runner.start_async()["state"] == "completed"

def test_inactive_task_is_not_completion_after_restart(runner):
    runner.observation = {"entered_end": True, "task_active": False, "dragon_seen": False}
    runner._checkpoint()
    restored = module.AltoClefStack()
    assert restored.status()["state"] == "stopped"
    assert not restored.status()["goal_completed"]

def test_boot_failures_respect_backoff(runner, monkeypatch):
    runner.state = "error"
    runner.next_retry_at = time.time() + 120
    monkeypatch.setattr(module.threading, "Thread", lambda *a, **k:
                        pytest.fail("retry started before its deadline"))
    assert runner.start_async()["state"] == "error"
    assert runner.restart_count == 0

def test_single_username_is_naldo_bot():
    assert module.USERNAME == "Naldo_Bot"

def test_default_coach_model_is_muse_spark_only(runner):
    import opencode_config
    assert runner.opencode_model == "opencode/muse-spark-1.3-contributor-free"
    assert module.COACH_MODEL == runner.opencode_model == opencode_config.MUSE_MODEL

def test_mode_assignment_only_sets_survival_for_this_player(runner, monkeypatch):
    console = io.StringIO()
    server = SimpleNamespace(stdin=console, poll=lambda: None)
    monkeypatch.setattr(module.STACK, "processes", {"minecraft": server})
    runner._ensure_survival_mode()
    written = console.getvalue()
    assert written == f"gamemode survival {module.USERNAME}\n"
    assert "give " not in written and "clear" not in written

def test_existing_inventory_is_never_touched():
    # Assisted run: no give/clear/supply helper may exist on the supervisor.
    assert not hasattr(module.AltoClefStack, "_supply_creative")
    source = Path(module.__file__).read_text(encoding="utf-8")
    assert "minecraft:{name}" not in source
    assert "CREATIVE_LOADOUT" not in source

def test_mode_is_verified_survival_in_status(runner):
    assert "Survival" in runner.status()["world_mode"]
    assert "Normal" in runner.status()["world_mode"]

def test_consult_provides_stdin_eof(runner, monkeypatch):
    seen = {}
    def fake_popen(*a, **k):
        seen.update(k)
        return SimpleNamespace(returncode=1,
                               communicate=lambda input=None, timeout=None: ("", "provider unavailable"))
    monkeypatch.setattr(module.subprocess, "Popen", fake_popen)
    monkeypatch.setattr(module, "stop_runner", lambda p, **k: None)
    client = object()
    runner.client = client
    runner._consult(Path("opencode"), {"connected": True, "task_active": True})
    assert runner.client is client
    assert runner.model_errors == 1
    assert runner.model_checks == 0
    import subprocess as stdlib_subprocess
    assert seen.get("stdin") == stdlib_subprocess.PIPE

def test_provider_failure_does_not_stop_gameplay(runner, monkeypatch):
    process = SimpleNamespace(returncode=1, communicate=lambda **k: ("", "provider unavailable"))
    monkeypatch.setattr(module.subprocess, "Popen", lambda *a, **k: process)
    monkeypatch.setattr(module, "stop_runner", lambda p, **k: None)
    client = object()
    runner.client = client
    runner._consult(Path("opencode"), {"connected": True, "task_active": True})
    assert runner.client is client
    assert runner.model_errors == 1
    assert runner.model_checks == 0

	"""Lifecycle and world-scope checks, without launching a Minecraft client."""
	import io
	import sys
	import time
	from pathlib import Path
	from types import SimpleNamespace

	import pytest

	sys.path.insert(0, str(Path(__file__).parents[1]))
	import altoclef_stack as module

	@pytest.fixture
	def runner(monkeypatch, tmp_path):
	monkeypatch.setattr(module, "ROOT", tmp_path)
	monkeypatch.delenv("ALTOCLEF_OPENCODE_MODEL", raising=False)
	monkeypatch.delenv("MC_USERNAME", raising=False)
	return module.AltoClefStack()

	def response(data):
	return SimpleNamespace(raise_for_status=lambda: None, json=lambda: data)

	def test_stale_connected_telemetry_is_an_error(runner, monkeypatch):
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": True, "observed_at": time.time() - 60,
	"heartbeat_at": time.time()}))
	with pytest.raises(RuntimeError, match="stopped updating"):
	runner._observe()

	def test_loading_heartbeat_accepted_inside_grace(runner, monkeypatch):
	now = time.time()
	runner.last_started_at = now
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": now}))
	assert runner._observe()["loading"] is True

	def test_loading_without_heartbeat_is_an_error(runner, monkeypatch):
	runner.last_started_at = time.time()
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": time.time() - 120}))
	with pytest.raises(RuntimeError, match="heartbeat stopped"):
	runner._observe()

	def test_exact_initial_payload_accepted_only_in_first_window(runner, monkeypatch):
	# Java's initial /state before the first 2s scheduler tick.
	runner.last_started_at = time.time()
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": 0}))
	assert runner._observe()["loading"] is True
	runner._bridge_seen_at = time.time() - module.FIRST_HEARTBEAT_WINDOW - 1
	with pytest.raises(RuntimeError, match="never published a heartbeat"):
	runner._observe()

	def test_reconnect_allowed_bounded_after_play(runner, monkeypatch):
	now = time.time()
	runner.last_started_at = now - module.LOADING_GRACE - 10
	runner._last_connected_at = now - 60
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": now}))
	assert runner._observe()["loading"] is True
	runner._last_connected_at = now - module.RECONNECT_GRACE - 1
	with pytest.raises(RuntimeError, match="did not reconnect"):
	runner._observe()

	def test_second_boot_resets_launch_clocks(runner, monkeypatch):
	# Regression: after a crash, the previous launch leaves an old connected
	# timestamp, a stale first-heartbeat clock and an expired grace anchor.
	# The new boot must accept its fresh initial loading payload.
	now = time.time()
	runner._last_connected_at = now - module.RECONNECT_GRACE - 60
	runner._bridge_seen_at = now - module.FIRST_HEARTBEAT_WINDOW - 60
	runner.last_started_at = now - module.LOADING_GRACE - 60
	runner._last_gamer_at = now
	runner._last_mode_set = now
	runner._reset_launch_clocks()
	assert runner._bridge_seen_at is None
	assert runner._last_connected_at is None
	assert runner.last_started_at is None
	assert runner._last_gamer_at == 0.0 and runner._last_mode_set == 0.0
	runner.last_started_at = time.time()
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": 0}))
	assert runner._observe()["loading"] is True

	def test_boot_resets_launch_clocks_before_startup():
	import inspect
	source = inspect.getsource(module.AltoClefStack._boot)
	assert "_reset_launch_clocks()" in source
	assert source.index("_reset_launch_clocks()") < source.index("minecraft_ready.wait")

	def _bridge_source() -> str:
	return (Path(module.__file__).parents[0] / "altoclef" / "SpaceBridge.java").read_text(encoding="utf-8")

	def test_bridge_gates_manual_connect_on_readiness():
	# Pinned Yarn 1.19.4+build.2: TitleScreen class_442, DisconnectedScreen
	# class_419, ConnectScreen class_412, overlay via getOverlay. The manual
	# connect must take the current screen and refuse while a reload overlay
	# is up or vanilla is already connecting.
	source = _bridge_source()
	assert "class_442" in source and "class_419" in source
	# Pinned Yarn 1.19.4+build.2 row: METHOD emh ()Lesx; aJ method_18506
	# getOverlay. The live runtime is intermediary, so the mapped ID (not the
	# Yarn name) must be used.
	assert "method_18506" in source
	assert '"getOverlay"' not in source
	assert "connect(client, currentScreen)" in source
	assert "mc(\"class_412\").isInstance(currentScreen)" in source
	import re
	assert not re.search(r"(?<!, )connect\(client\)", source), \
	"ungated single-arg connect call remains"

	def test_bridge_reports_connect_diagnostics():
	source = _bridge_source()
	assert '"connect_state"' in source and '"connect_attempts"' in source

	def test_built_bridge_jar_matches_source_version():
	import json as _json
	import zipfile as _zip
	jar = Path(module.__file__).parents[0] / "altoclef" / "space-altoclef-bridge.jar"
	meta = _json.loads(_zip.ZipFile(jar).read("fabric.mod.json").decode())
	assert meta["version"] == "1.0.4"
	assert "space/minecraft/SpaceBridge.class" in _zip.ZipFile(jar).namelist()

	def test_client_starts_at_title_without_autojoin_flags(runner, monkeypatch, tmp_path):
	import sys as _sys
	seen: dict = {}
	fake_launcher = SimpleNamespace(
	fabric=SimpleNamespace(install_fabric=lambda a, *k: None),
	command=SimpleNamespace(
	get_minecraft_command=lambda a, *k: (seen.update(a[2]), ["java"])[1]),
	)
	monkeypatch.setitem(_sys.modules, "minecraft_launcher_lib", fake_launcher)
	monkeypatch.setattr(module, "CLIENT", tmp_path / "client")
	monkeypatch.setattr(module, "MOD_CACHE", tmp_path / "cache")
	monkeypatch.setattr(module, "_download",
	lambda url, path, sha=None: (path.parent.mkdir(parents=True, exist_ok=True),
	path.write_bytes(b"x"))[1])
	assert runner._ensure_client(Path("java")) == ["java"]
	# No vanilla --server/--port: autojoin bypasses the TitleScreen, and
	# upstream AltoClef initializes ONLY there (EntryMixin on TitleScreen.init
	# -> TitleScreenEntryEvent -> onInitializeLoad). The bridge's gated
	# fallback connects after resources are done instead.
	assert "server" not in seen and "port" not in seen
	options = (tmp_path / "client" / "options.txt").read_text(encoding="utf-8")
	assert "onboardAccessibility:false" in options
	# Second ensure must not duplicate the key.
	runner._ensure_client(Path("java"))
	options = (tmp_path / "client" / "options.txt").read_text(encoding="utf-8")
	assert options.count("onboardAccessibility:false") == 1

	def test_bridge_reports_uninitialized_taskchain_without_npe():
	# A null task chain during loading must surface as initialized=false with
	# diagnostics, never an NPE, and never a fabricated task_active.
	source = _bridge_source()
	assert "chain == null" in source
	assert "taskchain not yet initialized" in source

	def test_survival_verified_requires_explicit_survival():
	good = {"connected": True, "error": "", "creative": False}
	assert module.AltoClefStack._survival_verified(good) is True
	# Loading payload without a creative flag is NOT Survival.
	assert module.AltoClefStack._survival_verified({"connected": False, "loading": True}) is False
	assert module.AltoClefStack._survival_verified({"connected": True, "error": "", "creative": True}) is False
	assert module.AltoClefStack._survival_verified({"connected": True, "error": "boom", "creative": False}) is False

	def test_loading_past_grace_is_an_error(runner, monkeypatch):
	now = time.time()
	runner.last_started_at = now - module.LOADING_GRACE - 10
	monkeypatch.setattr(module.requests, "get", lambda a, *k:
	response({"connected": False, "loading": True, "heartbeat_at": now,
	"dispatch_error": "client thread stalled"}))
	with pytest.raises(RuntimeError, match="still not connected"):
	runner._observe()

	def test_credits_evidence_survives_restart(runner, monkeypatch):
	state = {"connected": True, "entered_end": True, "credits_observed": True,
	"observed_at": time.time(), "heartbeat_at": time.time()}
	monkeypatch.setattr(module.requests, "get", lambda a, *k: response(state))
	runner._observe()
	restored = module.AltoClefStack()
	assert restored.status()["state"] == "completed"
	assert restored.status()["goal_completed"]
	assert not restored.status()["running"]

	def test_completed_goal_is_not_restarted_by_supervisor(runner, monkeypatch):
	runner.observation = {"entered_end": True, "credits_observed": True}
	runner.state = "stopped"
	monkeypatch.setattr(module.threading, "Thread", lambda a, *k:
	pytest.fail("completed goal launched another client"))
	assert runner.start_async()["state"] == "completed"

	def test_inactive_task_is_not_completion_after_restart(runner):
	runner.observation = {"entered_end": True, "task_active": False, "dragon_seen": False}
	runner._checkpoint()
	restored = module.AltoClefStack()
	assert restored.status()["state"] == "stopped"
	assert not restored.status()["goal_completed"]

	def test_boot_failures_respect_backoff(runner, monkeypatch):
	runner.state = "error"
	runner.next_retry_at = time.time() + 120
	monkeypatch.setattr(module.threading, "Thread", lambda a, *k:
	pytest.fail("retry started before its deadline"))
	assert runner.start_async()["state"] == "error"
	assert runner.restart_count == 0

	def test_single_username_is_naldo_bot():
	assert module.USERNAME == "Naldo_Bot"

	def test_default_coach_model_is_muse_spark_only(runner):
	import opencode_config
	assert runner.opencode_model == "opencode/muse-spark-1.3-contributor-free"
	assert module.COACH_MODEL == runner.opencode_model == opencode_config.MUSE_MODEL

	def test_mode_assignment_only_sets_survival_for_this_player(runner, monkeypatch):
	console = io.StringIO()
	server = SimpleNamespace(stdin=console, poll=lambda: None)
	monkeypatch.setattr(module.STACK, "processes", {"minecraft": server})
	runner._ensure_survival_mode()
	written = console.getvalue()
	assert written == f"gamemode survival {module.USERNAME}\n"
	assert "give " not in written and "clear" not in written

	def test_existing_inventory_is_never_touched():
	# Assisted run: no give/clear/supply helper may exist on the supervisor.
	assert not hasattr(module.AltoClefStack, "_supply_creative")
	source = Path(module.__file__).read_text(encoding="utf-8")
	assert "minecraft:{name}" not in source
	assert "CREATIVE_LOADOUT" not in source

	def test_mode_is_verified_survival_in_status(runner):
	assert "Survival" in runner.status()["world_mode"]
	assert "Normal" in runner.status()["world_mode"]

	def test_consult_provides_stdin_eof(runner, monkeypatch):
	seen = {}
	def fake_popen(a, *k):
	seen.update(k)
	return SimpleNamespace(returncode=1,
	communicate=lambda input=None, timeout=None: ("", "provider unavailable"))
	monkeypatch.setattr(module.subprocess, "Popen", fake_popen)
	monkeypatch.setattr(module, "stop_runner", lambda p, **k: None)
	client = object()
	runner.client = client
	runner._consult(Path("opencode"), {"connected": True, "task_active": True})
	assert runner.client is client
	assert runner.model_errors == 1
	assert runner.model_checks == 0
	import subprocess as stdlib_subprocess
	assert seen.get("stdin") == stdlib_subprocess.PIPE

	def test_provider_failure_does_not_stop_gameplay(runner, monkeypatch):
	process = SimpleNamespace(returncode=1, communicate=lambda **k: ("", "provider unavailable"))
	monkeypatch.setattr(module.subprocess, "Popen", lambda a, *k: process)
	monkeypatch.setattr(module, "stop_runner", lambda p, **k: None)
	client = object()
	runner.client = client
	runner._consult(Path("opencode"), {"connected": True, "task_active": True})
	assert runner.client is client
	assert runner.model_errors == 1
	assert runner.model_checks == 0