chore: import upstream snapshot with attribution

tests/test_opencode_native.py

@@ -0,0 +1,672 @@
+"""Unit tests for the ``omni opencode`` launcher helpers (``opencode_native.py``).
+
+Covers the pure spec/payload/tmux helpers plus the httpx-backed session and
+terminal helpers over a fake ``AsyncClient`` — the daemon/tmux attach plumbing
+itself stays for the live host e2e.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+import httpx
+import pytest
+import yaml
+
+from omnigent.opencode_native import (
+    LaunchedOpenCodeTerminal,
+    PreparedOpenCodeTerminal,
+    _create_opencode_session,
+    _direct_tmux_unavailable_reason,
+    _ensure_opencode_terminal_on_runner,
+    _fetch_opencode_session,
+    _find_running_opencode_terminal,
+    _launched_opencode_terminal_from_payload,
+    _materialize_opencode_agent_spec,
+    _resolve_session_id_for_resume,
+    opencode_terminal_resource_id,
+)
+
+
+class _FakeClient:
+    """Async httpx stand-in returning one preset response per call."""
+
+    def __init__(self, response: httpx.Response) -> None:
+        self._response = response
+        self.requests: list[tuple[str, str, dict[str, Any]]] = []
+
+    async def post(self, url: str, **kwargs: Any) -> httpx.Response:
+        self.requests.append(("POST", url, kwargs))
+        return self._response
+
+    async def get(self, url: str, **kwargs: Any) -> httpx.Response:
+        self.requests.append(("GET", url, kwargs))
+        return self._response
+
+
+# ── _materialize_opencode_agent_spec ────────────────────────────────────────
+
+
+def test_materialize_spec_defaults_no_model(tmp_path: Path, monkeypatch) -> None:
+    # Pin the host shells so the declared terminals are deterministic.
+    monkeypatch.setattr("shutil.which", lambda name: f"/usr/bin/{name}")
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+    spec = yaml.safe_load(_materialize_opencode_agent_spec(tmp_path).read_text())
+    assert spec["executor"] == {"harness": "opencode-native"}
+    assert spec["spawn"] is True
+    # One terminal per installed shell, $SHELL first — a non-empty block gates
+    # the relay's sys_terminal_* advertisement.
+    assert list(spec["terminals"]) == ["zsh", "bash", "fish"]
+    assert spec["terminals"]["zsh"]["command"] == "zsh"
+
+
+def test_materialize_spec_pins_model(tmp_path: Path) -> None:
+    spec = yaml.safe_load(
+        _materialize_opencode_agent_spec(tmp_path, model="anthropic/claude-opus-4").read_text()
+    )
+    assert spec["executor"] == {"harness": "opencode-native", "model": "anthropic/claude-opus-4"}
+
+
+def test_terminal_resource_id_is_deterministic() -> None:
+    assert opencode_terminal_resource_id() == opencode_terminal_resource_id()
+
+
+# ── _launched_opencode_terminal_from_payload ────────────────────────────────
+
+
+def test_launched_terminal_parses_tmux_metadata() -> None:
+    launched = _launched_opencode_terminal_from_payload(
+        {"id": "term_1", "metadata": {"tmux_socket": "/tmp/s.sock", "tmux_target": "sess:0.0"}}
+    )
+    assert launched.terminal_id == "term_1"
+    assert launched.tmux_socket == Path("/tmp/s.sock")
+    assert launched.tmux_target == "sess:0.0"
+
+
+def test_launched_terminal_without_metadata_has_no_tmux() -> None:
+    launched = _launched_opencode_terminal_from_payload({"id": "term_1"})
+    assert launched.tmux_socket is None and launched.tmux_target is None
+
+
+def test_launched_terminal_missing_id_raises() -> None:
+    with pytest.raises(click.ClickException):
+        _launched_opencode_terminal_from_payload({"metadata": {}})
+    with pytest.raises(click.ClickException):
+        _launched_opencode_terminal_from_payload("not-a-dict")
+
+
+# ── _direct_tmux_unavailable_reason ─────────────────────────────────────────
+
+
+def _prepared(socket: Path | None, target: str | None) -> PreparedOpenCodeTerminal:
+    return PreparedOpenCodeTerminal(
+        session_id="conv_1",
+        terminal_id="term_1",
+        tmux_socket=socket,
+        tmux_target=target,
+        reattached=False,
+    )
+
+
+def test_tmux_reason_missing_socket() -> None:
+    assert "tmux socket" in (_direct_tmux_unavailable_reason(_prepared(None, "t")) or "")
+
+
+def test_tmux_reason_missing_target() -> None:
+    assert "tmux target" in (_direct_tmux_unavailable_reason(_prepared(Path("/x"), None)) or "")
+
+
+def test_tmux_reason_socket_not_reachable(tmp_path: Path) -> None:
+    reason = _direct_tmux_unavailable_reason(_prepared(tmp_path / "missing.sock", "t"))
+    assert reason is not None and "not reachable" in reason
+
+
+# ── _resolve_session_id_for_resume ──────────────────────────────────────────
+
+
+def test_resolve_session_id_passthrough() -> None:
+    assert (
+        _resolve_session_id_for_resume(
+            base_url="http://x", headers={}, session_id="conv_9", resume_picker=False
+        )
+        == "conv_9"
+    )
+
+
+def test_resolve_session_id_none_without_picker() -> None:
+    assert (
+        _resolve_session_id_for_resume(
+            base_url="http://x", headers={}, session_id=None, resume_picker=False
+        )
+        is None
+    )
+
+
+# ── httpx-backed session/terminal helpers ───────────────────────────────────
+
+
+async def test_create_session_returns_id() -> None:
+    client = _FakeClient(httpx.Response(200, json={"session_id": "conv_new"}))
+    sid = await _create_opencode_session(client, b"bundle", terminal_launch_args=["--foo"])  # type: ignore[arg-type]
+    assert sid == "conv_new"
+    assert client.requests[0][1] == "/v1/sessions"
+
+
+async def test_create_session_errors_on_http_failure() -> None:
+    client = _FakeClient(httpx.Response(500, json={"error": "boom"}))
+    with pytest.raises(click.ClickException):
+        await _create_opencode_session(client, b"bundle")  # type: ignore[arg-type]
+
+
+async def test_create_session_errors_without_session_id() -> None:
+    client = _FakeClient(httpx.Response(200, json={}))
+    with pytest.raises(click.ClickException):
+        await _create_opencode_session(client, b"bundle")  # type: ignore[arg-type]
+
+
+async def test_fetch_session_returns_payload() -> None:
+    client = _FakeClient(httpx.Response(200, json={"id": "conv_1", "title": "t"}))
+    assert (await _fetch_opencode_session(client, "conv_1"))["id"] == "conv_1"  # type: ignore[arg-type]
+
+
+async def test_fetch_session_404_raises() -> None:
+    client = _FakeClient(httpx.Response(404, json={"error": "nope"}))
+    with pytest.raises(click.ClickException):
+        await _fetch_opencode_session(client, "conv_1")  # type: ignore[arg-type]
+
+
+async def test_ensure_terminal_ok_then_error() -> None:
+    ok = _FakeClient(httpx.Response(200, json={}))
+    await _ensure_opencode_terminal_on_runner(ok, "conv_1")  # type: ignore[arg-type]
+    assert ok.requests[0][0] == "POST"
+    bad = _FakeClient(httpx.Response(503, json={"error": "x"}))
+    with pytest.raises(click.ClickException):
+        await _ensure_opencode_terminal_on_runner(bad, "conv_1")  # type: ignore[arg-type]
+
+
+async def test_find_terminal_404_returns_none() -> None:
+    client = _FakeClient(httpx.Response(404, json={}))
+    assert await _find_running_opencode_terminal(client, "conv_1") is None  # type: ignore[arg-type]
+
+
+async def test_find_terminal_not_running_returns_none() -> None:
+    client = _FakeClient(
+        httpx.Response(200, json={"id": "term_1", "metadata": {"running": False}})
+    )
+    assert await _find_running_opencode_terminal(client, "conv_1") is None  # type: ignore[arg-type]
+
+
+async def test_find_terminal_returns_launched() -> None:
+    client = _FakeClient(
+        httpx.Response(200, json={"id": "term_1", "metadata": {"tmux_target": "s:0.0"}})
+    )
+    launched = await _find_running_opencode_terminal(client, "conv_1")  # type: ignore[arg-type]
+    assert isinstance(launched, LaunchedOpenCodeTerminal)
+    assert launched.tmux_target == "s:0.0"
+
+
+async def test_find_terminal_offline_runner_returns_none() -> None:
+    client = _FakeClient(httpx.Response(409, text="session not bound to a runner"))
+    assert await _find_running_opencode_terminal(client, "conv_1") is None  # type: ignore[arg-type]
+
+
+# ── launcher local-preflight / progress / tmux-reason / wait helpers ─────────
+
+
+def test_preflight_local_tools_ok(monkeypatch: pytest.MonkeyPatch) -> None:
+    import omnigent.opencode_native as on
+
+    monkeypatch.setattr(on.shutil, "which", lambda _x: "/usr/bin/tmux")
+    on._preflight_local_tools()  # tmux present → no raise
+
+
+def test_preflight_local_tools_missing_tmux_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+    import omnigent.opencode_native as on
+
+    monkeypatch.setattr(on.shutil, "which", lambda _x: None)
+    with pytest.raises(click.ClickException):
+        on._preflight_local_tools()
+
+
+def test_update_startup_progress_handles_none_and_active() -> None:
+    from unittest.mock import Mock
+
+    from omnigent.opencode_native import _update_startup_progress
+
+    _update_startup_progress(None, "boot")  # no renderer → no-op branch
+    _update_startup_progress(Mock(), "boot")  # active renderer → update branch
+
+
+def test_tmux_reason_tmux_not_on_path(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    import omnigent.opencode_native as on
+
+    sock = tmp_path / "s.sock"
+    sock.write_text("")
+    monkeypatch.setattr(on.shutil, "which", lambda _x: None)
+    reason = on._direct_tmux_unavailable_reason(_prepared(sock, "t"))
+    assert reason is not None and "tmux is not available" in reason
+
+
+def test_tmux_reason_none_when_socket_and_tmux_present(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    import omnigent.opencode_native as on
+
+    sock = tmp_path / "s.sock"
+    sock.write_text("")
+    monkeypatch.setattr(on.shutil, "which", lambda _x: "/usr/bin/tmux")
+    assert on._direct_tmux_unavailable_reason(_prepared(sock, "t")) is None
+
+
+async def test_wait_for_terminal_returns_when_found(monkeypatch: pytest.MonkeyPatch) -> None:
+    import omnigent.opencode_native as on
+
+    term = on.LaunchedOpenCodeTerminal(terminal_id="t", tmux_socket=None, tmux_target=None)
+
+    async def _fake_find(_client: object, _sid: str) -> on.LaunchedOpenCodeTerminal:
+        return term
+
+    monkeypatch.setattr(on, "_find_running_opencode_terminal", _fake_find)
+    got = await on._wait_for_opencode_terminal_ready(object(), "conv_1", timeout_s=5)  # type: ignore[arg-type]
+    assert got is term
+
+
+async def test_wait_for_terminal_times_out(monkeypatch: pytest.MonkeyPatch) -> None:
+    import omnigent.opencode_native as on
+
+    async def _never(_client: object, _sid: str) -> None:
+        return None
+
+    monkeypatch.setattr(on, "_find_running_opencode_terminal", _never)
+    with pytest.raises(click.ClickException):
+        await on._wait_for_opencode_terminal_ready(object(), "conv_1", timeout_s=0)  # type: ignore[arg-type]
+
+
+# --- Resume workspace alignment (launch.json record + cwd realign) ---
+def test_record_launch_for_fresh_session_persists_current_cwd(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    A fresh session records its launch cwd for later resumes.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+    from omnigent.opencode_native_state import read_launch_state
+
+    workspace = tmp_path / "workspace"
+    workspace.mkdir()
+    monkeypatch.chdir(workspace)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+
+    on._record_launch_for_fresh_session("conv_abc")
+
+    state = read_launch_state("conv_abc")
+    assert state is not None
+    assert state.working_directory == str(workspace.resolve())
+
+
+def test_record_launch_for_fresh_session_swallows_oserror(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    A failed launch-state write warns rather than breaking the launch.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+
+    monkeypatch.chdir(tmp_path)
+
+    def _raise(*_args: object, **_kwargs: object) -> None:
+        raise OSError("disk full")
+
+    monkeypatch.setattr(on, "write_launch_state", _raise)
+
+    # Best-effort recording: a write failure must not propagate.
+    on._record_launch_for_fresh_session("conv_abc")
+
+
+def test_align_no_recorded_state_is_noop(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    Resume with no recorded launch state neither prompts nor moves cwd.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+
+    def _fail_prompt(**_kwargs: object) -> str:
+        raise AssertionError("absent launch state should not prompt")
+
+    monkeypatch.setattr(on, "_prompt_opencode_resume_workspace_action", _fail_prompt)
+
+    on._align_working_directory_with_session("conv_missing")
+
+    assert Path.cwd().resolve() == tmp_path.resolve()
+
+
+def test_align_matching_cwd_is_noop(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    Resume from the recorded cwd must not prompt or move cwd.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+    from omnigent.opencode_native_state import write_launch_state
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+    write_launch_state("conv_abc", str(tmp_path.resolve()))
+
+    def _fail_prompt(**_kwargs: object) -> str:
+        raise AssertionError("matching cwd should not prompt")
+
+    monkeypatch.setattr(on, "_prompt_opencode_resume_workspace_action", _fail_prompt)
+
+    on._align_working_directory_with_session("conv_abc")
+
+    assert Path.cwd().resolve() == tmp_path.resolve()
+
+
+def test_align_switches_to_recorded_cwd(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    Choosing ``switch`` changes cwd to the recorded directory.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+    from omnigent.opencode_native_state import write_launch_state
+
+    recorded = tmp_path / "recorded"
+    current = tmp_path / "current"
+    recorded.mkdir()
+    current.mkdir()
+    monkeypatch.chdir(current)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+    write_launch_state("conv_abc", str(recorded.resolve()))
+    monkeypatch.setattr(
+        on,
+        "_prompt_opencode_resume_workspace_action",
+        lambda **_kwargs: "switch",
+    )
+
+    on._align_working_directory_with_session("conv_abc")
+
+    assert Path.cwd().resolve() == recorded.resolve()
+
+
+def test_align_cancel_raises(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    Choosing ``cancel`` aborts the resume without moving cwd.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+    from omnigent.opencode_native_state import write_launch_state
+
+    recorded = tmp_path / "recorded"
+    current = tmp_path / "current"
+    recorded.mkdir()
+    current.mkdir()
+    monkeypatch.chdir(current)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+    write_launch_state("conv_abc", str(recorded.resolve()))
+    monkeypatch.setattr(
+        on,
+        "_prompt_opencode_resume_workspace_action",
+        lambda **_kwargs: "cancel",
+    )
+
+    with pytest.raises(click.ClickException) as excinfo:
+        on._align_working_directory_with_session("conv_abc")
+
+    assert "cancel" in excinfo.value.message.lower()
+    assert Path.cwd().resolve() == current.resolve()
+
+
+def test_align_missing_recorded_cwd_raises(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    A recorded-but-missing cwd fails loud instead of resuming wrong.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace and state root.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+    from omnigent.opencode_native_state import write_launch_state
+
+    current = tmp_path / "current"
+    missing = tmp_path / "missing"
+    current.mkdir()
+    monkeypatch.chdir(current)
+    monkeypatch.setenv("OMNIGENT_OPENCODE_NATIVE_STATE_DIR", str(tmp_path / "state"))
+    write_launch_state("conv_abc", str(missing))
+
+    def _fail_prompt(**_kwargs: object) -> str:
+        raise AssertionError("missing recorded dir should raise before prompting")
+
+    monkeypatch.setattr(on, "_prompt_opencode_resume_workspace_action", _fail_prompt)
+
+    with pytest.raises(click.ClickException) as excinfo:
+        on._align_working_directory_with_session("conv_abc")
+
+    assert "conv_abc" in excinfo.value.message
+    assert str(missing.resolve()) in excinfo.value.message
+
+
+def test_prompt_offers_switch_and_cancel_choices(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    The cwd-mismatch prompt offers ``switch``/``cancel`` and defaults to switch.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary recorded/current paths.
+    :returns: None.
+    """
+    import omnigent.opencode_native as on
+
+    captured: dict[str, Any] = {}
+
+    def _fake_prompt(text: str, **kwargs: Any) -> str:
+        captured["text"] = text
+        captured["kwargs"] = kwargs
+        return "switch"
+
+    monkeypatch.setattr(click, "prompt", _fake_prompt)
+
+    result = on._prompt_opencode_resume_workspace_action(
+        recorded_path=tmp_path / "recorded",
+        current=tmp_path / "current",
+    )
+
+    assert result == "switch"
+    choice = captured["kwargs"]["type"]
+    assert isinstance(choice, click.Choice)
+    assert list(choice.choices) == ["switch", "cancel"]
+    assert captured["kwargs"]["default"] == "switch"
+
+
+# --- _run_with_remote_server control-flow (daemon/server mocked) ---
+def test_run_with_remote_server_aligns_cwd_before_daemon_prepare(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    Remote resume aligns cwd before the daemon prepare samples it.
+
+    Drives the real ``_run_with_remote_server`` with the daemon/server
+    mocked: asserts ``align`` runs first and the aligned cwd is the
+    workspace handed to prepare.
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary start/aligned dirs.
+    :returns: None.
+    """
+    import os
+    from types import SimpleNamespace
+
+    import omnigent.chat as chat_mod
+    import omnigent.cli as cli_mod
+    import omnigent.host.identity as identity_mod
+    import omnigent.opencode_native as on
+    from omnigent._runner_startup import RunnerStartupProgress
+
+    start_dir = tmp_path / "start"
+    aligned_dir = tmp_path / "aligned"
+    start_dir.mkdir()
+    aligned_dir.mkdir()
+    monkeypatch.chdir(start_dir)
+
+    order: list[str] = []
+
+    def fake_align(_session_id: str) -> None:
+        order.append("align")
+        os.chdir(aligned_dir)
+
+    async def fake_prepare(**kwargs: Any) -> PreparedOpenCodeTerminal:
+        assert kwargs["host_id"] == "host_local"
+        assert kwargs["session_id"] == "conv_abc"
+        assert kwargs["workspace"] == str(aligned_dir.resolve())
+        assert isinstance(kwargs["startup_progress"], RunnerStartupProgress)
+        order.append("prepare")
+        return PreparedOpenCodeTerminal(
+            session_id="conv_abc",
+            terminal_id="term_main",
+            tmux_socket=None,
+            tmux_target=None,
+            reattached=True,
+        )
+
+    async def fake_attach(_prepared: object) -> None:
+        order.append("attach")
+
+    monkeypatch.setattr(chat_mod, "_remote_headers", lambda *_a, **_k: {})
+    monkeypatch.setattr(
+        cli_mod, "_ensure_host_daemon", lambda *_a, **_k: order.append("ensure-daemon")
+    )
+    monkeypatch.setattr(
+        identity_mod,
+        "load_or_create_host_identity",
+        lambda: SimpleNamespace(host_id="host_local"),
+    )
+    monkeypatch.setattr(on, "_resolve_session_id_for_resume", lambda **_k: "conv_abc")
+    monkeypatch.setattr(on, "_align_working_directory_with_session", fake_align)
+    monkeypatch.setattr(on, "_prepare_opencode_terminal_via_daemon", fake_prepare)
+    monkeypatch.setattr(on, "_attach_terminal_resource", fake_attach)
+    monkeypatch.setattr(on, "open_conversation_link_if_enabled", lambda **_k: None)
+
+    on._run_with_remote_server(
+        "http://server",
+        tmp_path / "spec.yaml",
+        session_id="conv_abc",
+        resume_picker=False,
+        opencode_args=(),
+    )
+
+    assert order == ["align", "ensure-daemon", "prepare", "attach"]
+
+
+def test_run_with_remote_server_records_launch_after_create(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """
+    A fresh remote session records its launch cwd after prepare (no align).
+
+    :param monkeypatch: Pytest monkeypatch fixture.
+    :param tmp_path: Temporary workspace.
+    :returns: None.
+    """
+    from types import SimpleNamespace
+
+    import omnigent.chat as chat_mod
+    import omnigent.cli as cli_mod
+    import omnigent.host.identity as identity_mod
+    import omnigent.opencode_native as on
+
+    monkeypatch.chdir(tmp_path)
+    order: list[str] = []
+
+    async def fake_prepare(**_k: Any) -> PreparedOpenCodeTerminal:
+        order.append("prepare")
+        return PreparedOpenCodeTerminal(
+            session_id="conv_new",
+            terminal_id="term_main",
+            tmux_socket=None,
+            tmux_target=None,
+            reattached=False,
+        )
+
+    async def fake_attach(_prepared: object) -> None:
+        order.append("attach")
+
+    def fake_record(session_id: str) -> None:
+        assert session_id == "conv_new"
+        order.append("record")
+
+    def fail_align(_session_id: str) -> None:
+        raise AssertionError("create path must not align cwd")
+
+    monkeypatch.setattr(chat_mod, "_remote_headers", lambda *_a, **_k: {})
+    monkeypatch.setattr(chat_mod, "_bundle_agent", lambda _spec: b"bundle")
+    monkeypatch.setattr(
+        cli_mod, "_ensure_host_daemon", lambda *_a, **_k: order.append("ensure-daemon")
+    )
+    monkeypatch.setattr(
+        identity_mod,
+        "load_or_create_host_identity",
+        lambda: SimpleNamespace(host_id="host_local"),
+    )
+    monkeypatch.setattr(on, "_resolve_session_id_for_resume", lambda **_k: None)
+    monkeypatch.setattr(on, "_align_working_directory_with_session", fail_align)
+    monkeypatch.setattr(on, "_prepare_opencode_terminal_via_daemon", fake_prepare)
+    monkeypatch.setattr(on, "_attach_terminal_resource", fake_attach)
+    monkeypatch.setattr(on, "_record_launch_for_fresh_session", fake_record)
+    monkeypatch.setattr(on, "open_conversation_link_if_enabled", lambda **_k: None)
+    monkeypatch.setattr(on, "echo_native_resume_hint", lambda **_k: None)
+
+    on._run_with_remote_server(
+        "http://server",
+        tmp_path / "spec.yaml",
+        session_id=None,
+        resume_picker=False,
+        opencode_args=(),
+    )
+
+    assert order == ["ensure-daemon", "prepare", "record", "attach"]