#Multi-Tool Intake Implementation Plan

"""Coverage for the canonical --tool normalizer (spec §4.3)."""

from __future__ import annotations

import io

import pytest

from coding_scaffold.errors import CliError
from coding_scaffold.intake import (
    DEFAULT_TOOLS,
    normalize_tools,
    reset_deprecation_state,
)


@pytest.fixture(autouse=True)
def _reset_deprecation():
    # The "both" warning only fires once per process; reset between tests.
    reset_deprecation_state()
    yield
    reset_deprecation_state()


def test_none_returns_default_tools() -> None:
    assert normalize_tools(None) == list(DEFAULT_TOOLS)


def test_empty_list_returns_default_tools() -> None:
    assert normalize_tools([]) == list(DEFAULT_TOOLS)


def test_single_string_returns_singleton_list() -> None:
    assert normalize_tools("codex") == ["codex"]


def test_list_of_strings_passes_through() -> None:
    assert normalize_tools(["codex", "claude-code"]) == ["codex", "claude-code"]


def test_comma_separated_string_is_split() -> None:
    assert normalize_tools("codex,claude-code") == ["codex", "claude-code"]


def test_mixed_repeats_and_commas_are_flattened() -> None:
    assert normalize_tools(["codex,opencode", "claude-code"]) == [
        "codex", "opencode", "claude-code",
    ]


def test_duplicates_are_removed_preserving_order() -> None:
    assert normalize_tools(["codex", "codex", "claude-code", "codex"]) == [
        "codex", "claude-code",
    ]


def test_both_expands_to_opencode_openclaude_and_warns(capsys: pytest.CaptureFixture[str]) -> None:
    result = normalize_tools(["both"])
    assert result == ["opencode", "openclaude"]
    err = capsys.readouterr().err
    assert "deprecated" in err.lower()
    assert "0.7.0" in err
    assert "opencode,openclaude" in err


def test_both_deprecation_warning_fires_once_per_process(
    capsys: pytest.CaptureFixture[str],
) -> None:
    normalize_tools(["both"])
    normalize_tools(["both"])
    err = capsys.readouterr().err
    # Single "deprecated" line even across two calls.
    assert err.count("deprecated") == 1


def test_manual_with_real_tool_raises_clierror() -> None:
    with pytest.raises(CliError) as excinfo:
        normalize_tools(["manual", "codex"])
    assert "manual" in excinfo.value.cause.lower()
    assert "next" in excinfo.value.next_step.lower() or "pick" in excinfo.value.next_step.lower()


def test_manual_alone_is_accepted() -> None:
    assert normalize_tools("manual") == ["manual"]


def test_whitespace_around_comma_is_trimmed() -> None:
    assert normalize_tools(" codex , claude-code ") == ["codex", "claude-code"]

import sys

from .errors import CliError

DEFAULT_TOOLS: tuple[str, ...] = ("opencode",)
# Legacy `--tool both` literal expansion. Removed in 0.7.0 alongside the value
# itself; see docs/docs/wiki/Upgrading.md.
_BOTH_EXPANSION: tuple[str, ...] = ("opencode", "openclaude")

# Single-fire deprecation warning state. Reset between tests via
# `reset_deprecation_state()`.
_BOTH_WARNING_FIRED: bool = False


def reset_deprecation_state() -> None:
    """Reset the once-per-process deprecation warning latch. Test-only."""

    global _BOTH_WARNING_FIRED
    _BOTH_WARNING_FIRED = False


def normalize_tools(value: str | list[str] | None) -> list[str]:
    """Return a canonical deduped tool list from any accepted input shape.

    Accepts: None, "", "codex", "codex,claude-code", ["codex"],
    ["codex", "claude-code"], ["codex,opencode", "claude-code"], ["both"].

    Expands the deprecated `both` literal to `opencode,openclaude` with a
    one-line stderr warning that fires at most once per process.

    Raises `CliError` when `manual` appears alongside any real tool — `manual`
    means "no adapter," which is incompatible with also picking a real one.
    """

    if value is None or value == "":
        return list(DEFAULT_TOOLS)
    if isinstance(value, str):
        raw_parts = [value]
    else:
        raw_parts = list(value)
    if not raw_parts:
        return list(DEFAULT_TOOLS)

    # Flatten commas + trim whitespace.
    flat: list[str] = []
    for part in raw_parts:
        for chunk in str(part).split(","):
            chunk = chunk.strip()
            if chunk:
                flat.append(chunk)
    if not flat:
        return list(DEFAULT_TOOLS)

    # Expand `both` with a one-fire deprecation warning.
    global _BOTH_WARNING_FIRED
    expanded: list[str] = []
    for chunk in flat:
        if chunk == "both":
            if not _BOTH_WARNING_FIRED:
                print(
                    "warning: '--tool both' is deprecated; "
                    "using '--tool opencode,openclaude' instead.\n"
                    "         Will be removed in 0.7.0. "
                    "See https://jrs1986.github.io/CodingScaffold/wiki/Upgrading.",
                    file=sys.stderr,
                )
                _BOTH_WARNING_FIRED = True
            expanded.extend(_BOTH_EXPANSION)
            continue
        expanded.append(chunk)

    # Dedupe, preserve first-seen order.
    seen: set[str] = set()
    canonical: list[str] = []
    for chunk in expanded:
        if chunk in seen:
            continue
        seen.add(chunk)
        canonical.append(chunk)

    # `manual` is exclusive — it means "no adapter."
    if "manual" in canonical and len(canonical) > 1:
        others = [t for t in canonical if t != "manual"]
        raise CliError(
            cause=f"`--tool manual` excludes other tools; got manual + {', '.join(others)}",
            next_step="pick one of: `--tool manual` OR `--tool <real-tool>...`",
            link="https://jrs1986.github.io/CodingScaffold/wiki/Glossary",
        )

    return canonical

import json
from pathlib import Path

from coding_scaffold.intake import (
    IntakeAnswers,
    _normalize_persisted_intake,
)


def test_intake_answers_carries_tools_list() -> None:
    answers = IntakeAnswers(tools=["codex", "claude-code"])
    assert answers.tools == ["codex", "claude-code"]
    # Agent property still returns the first tool.
    assert answers.agent == "codex"


def test_intake_answers_to_dict_emits_tools_only() -> None:
    answers = IntakeAnswers(tools=["codex"])
    payload = answers.to_dict()
    assert payload["tools"] == ["codex"]
    assert "tool" not in payload, "singular `tool` must be gone from persisted form"


def test_normalize_persisted_intake_back_fills_legacy_tool_key() -> None:
    legacy = {"language": "python", "tool": "opencode"}
    normalized = _normalize_persisted_intake(legacy)
    assert normalized["tools"] == ["opencode"]
    assert "tool" not in normalized, "back-fill must strip the legacy key after migrating"


def test_normalize_persisted_intake_passes_through_modern_payload() -> None:
    modern = {"language": "python", "tools": ["codex", "claude-code"]}
    assert _normalize_persisted_intake(modern) == modern


def test_normalize_persisted_intake_handles_missing_tool(tmp_path: Path) -> None:
    # Some very old project.json files may have neither `tool` nor `tools`.
    no_tool = {"language": "python"}
    normalized = _normalize_persisted_intake(no_tool)
    assert normalized["tools"] == ["opencode"]


def test_intake_answers_default_tools_is_opencode() -> None:
    answers = IntakeAnswers()
    assert answers.tools == ["opencode"]

@dataclass(frozen=True)
class IntakeAnswers:
    language: str | None = None
    project_target: str | None = None
    existing_codebase: bool | None = None
    privacy: str | None = None
    tools: list[str] = field(default_factory=lambda: list(DEFAULT_TOOLS))
    preferred_local_model: str | None = None
    mode: str | None = None

    def to_dict(self) -> dict[str, object]:
        payload = asdict(self)
        return payload

    @property
    def agent(self) -> str | None:
        """First tool, or None if the list is empty.

        Adapter selection elsewhere reads `.agent`; preserving the property keeps
        those call-sites stable while the migration to `.tools` lands across the
        rest of the codebase.
        """

        return self.tools[0] if self.tools else None


def _normalize_persisted_intake(payload: dict[str, object]) -> dict[str, object]:
    """Migrate a persisted intake payload to the canonical `tools` shape.

    Legacy `.coding-scaffold/project.json` files written before 0.6.0 carry
    `tool: "opencode"` (singular). New files carry `tools: ["opencode", ...]`.
    This helper accepts either and returns a payload with only `tools` populated.

    Removed in 0.7.0 once the migration window closes; see Upgrading.md.
    """

    result = dict(payload)
    legacy = result.pop("tool", None)
    if "tools" in result:
        return result
    if legacy:
        result["tools"] = [str(legacy)]
    else:
        result["tools"] = list(DEFAULT_TOOLS)
    return result

from dataclasses import asdict, dataclass, field

def collect_intake(target: Path, provided: IntakeAnswers, interactive: bool) -> IntakeAnswers:
    detected_language = _detect_language(target) if provided.language is None else None
    # `provided.tools` is the upstream-supplied list (from CLI or programmatic call).
    # If absent (default factory empty? — no, the dataclass default is ["opencode"]),
    # the interactive prompt can edit it.
    raw_tool_answer = _value(
        ",".join(provided.tools) if provided.tools else None,
        "Coding tools to set up (comma-separated, e.g. `codex,claude-code`)",
        "opencode",
        interactive,
    )
    return IntakeAnswers(
        language=_value(
            provided.language,
            "Primary language",
            detected_language or "python",
            interactive,
        ),
        project_target=_value(provided.project_target, "Project target", "CLI/tooling", interactive),
        existing_codebase=(
            provided.existing_codebase
            if provided.existing_codebase is not None
            else _bool_value("Existing codebase", _has_code(target), interactive)
        ),
        privacy=_value(provided.privacy, "Privacy mode", "local-first", interactive),
        tools=normalize_tools(raw_tool_answer),
        preferred_local_model=_value(
            provided.preferred_local_model,
            "Preferred local model",
            "auto",
            interactive,
        ),
        mode=_value(provided.mode, "Guidance mode", "standard", interactive),
    )

def _getting_started_md(intake: IntakeAnswers, routing: RoutingPlan) -> str:
    selected_tool = intake.tools[0] if intake.tools else "opencode"
    setup_hint = (
        "Validate or install the selected coding environment with "
        f"`coding-scaffold setup tool --tool {selected_tool}`."
        if selected_tool != "manual"
        else "Use your manually selected coding environment and keep its config next to this scaffold."
    )
    return render_template(
        "writers/getting-started.md",
        setup_hint=setup_hint,
        language=intake.language,
        project_target=intake.project_target,
        privacy=intake.privacy,
        tool=selected_tool,
        mode=intake.mode,
        weak_model=routing.weak_model,
        strong_model=routing.strong_model,
    )

        manifest = write_scaffold(temp_root, intake, hardware, providers, routing)
        primary_tool = intake.tools[0] if intake.tools else "manual"
        adapter = (
            write_tool_adapter(temp_root, intake.tools)
            if primary_tool and primary_tool != "manual"
            else None
        )

def _load_project_intake(target: Path) -> IntakeAnswers:
    from .intake import _normalize_persisted_intake

    path = target / ".coding-scaffold" / "project.json"
    try:
        payload = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return collect_intake(target, IntakeAnswers(), interactive=False)
    if not isinstance(payload, dict):
        return collect_intake(target, IntakeAnswers(), interactive=False)
    # Back-fill: legacy `tool` becomes modern `tools`; modern files pass through.
    payload = _normalize_persisted_intake(payload)
    # Also accept the historical `agent` alias for `tool`.
    tools_value = payload.get("tools") or (
        [_string_or_none(payload.get("agent"))] if payload.get("agent") else None
    )
    return collect_intake(
        target,
        IntakeAnswers(
            language=_string_or_none(payload.get("language")),
            project_target=_string_or_none(payload.get("project_target")),
            existing_codebase=_bool_or_none(payload.get("existing_codebase")),
            privacy=_string_or_none(payload.get("privacy")),
            tools=[t for t in (tools_value or []) if t] or list(DEFAULT_TOOLS),
            preferred_local_model=_string_or_none(payload.get("preferred_local_model")),
            mode=_string_or_none(payload.get("mode")),
        ),
        interactive=False,
    )

def test_routing_plan_to_dict_includes_tools_list_only() -> None:
    from coding_scaffold.intake import IntakeAnswers
    from coding_scaffold.hardware import HardwareProfile
    from coding_scaffold.providers import Provider
    from coding_scaffold.router import build_routing_plan

    intake = IntakeAnswers(tools=["codex", "claude-code"], language="python")
    hardware = HardwareProfile(
        os_name="macos", arch="arm64", cpu="apple", ram_gb=16,
        gpu=None, accelerators=[], is_wsl=False, llmfit_available=False,
    )
    providers: list[Provider] = []
    plan = build_routing_plan(intake, hardware, providers)
    payload = plan.to_dict()
    assert payload["tools"] == ["codex", "claude-code"]
    assert "tool" not in payload, "singular `tool` must be gone from routing.json"

@dataclass(frozen=True)
class RoutingPlan:
    ...
    tools: list[str]
    ...

    def to_dict(self) -> dict[str, object]:
        return {
            ...
            "tools": list(self.tools),
            ...
        }


def build_routing_plan(intake, hardware, providers) -> RoutingPlan:
    return RoutingPlan(
        ...
        tools=list(intake.tools),
        ...
    )

def test_write_tool_adapter_accepts_list_of_tools(tmp_path: Path) -> None:
    from coding_scaffold.adapters import write_tool_adapter
    from coding_scaffold.writers import write_scaffold
    from coding_scaffold.intake import IntakeAnswers
    # ... bootstrap a scaffold dir with routing.json so adapters can read it
    # Use the existing fixture/factory if present; otherwise inline:
    intake = IntakeAnswers(tools=["codex", "claude-code"], language="python")
    # write_scaffold needs hardware, providers, routing — reuse a factory if
    # tests/conftest.py defines one. Otherwise:
    from tests.conftest import sample_hardware, sample_routing  # adapt to actual fixture names
    write_scaffold(tmp_path, intake, sample_hardware(), [], sample_routing(intake))

    result = write_tool_adapter(tmp_path, ["codex", "claude-code"])
    written_paths = {p.name for p in result.files}
    # Codex writes AGENTS.md at root + codex template files; Claude writes CLAUDE.md + .claude/
    assert "AGENTS.md" in written_paths
    assert "CLAUDE.md" in written_paths


def test_write_tool_adapter_string_argument_still_works(tmp_path: Path) -> None:
    """Backward-compat: existing ad-hoc callers still pass a string."""

    from coding_scaffold.adapters import write_tool_adapter
    # ... bootstrap as above ...
    result = write_tool_adapter(tmp_path, "codex")
    assert any(p.name == "AGENTS.md" for p in result.files)

def write_tool_adapter(target: Path, tool: str | list[str]) -> AdapterResult:
    from .intake import normalize_tools

    root = target.expanduser().resolve()
    files: list[Path] = []
    skipped: list[Path] = []
    routing = load_routing_payload(root)
    tools = normalize_tools(tool)   # accepts str | list, deduped, with `both` expansion
    for selected in tools:
        if selected == "opencode":
            result = _write_opencode(root, routing)
        elif selected == "claude-code":
            result = _write_claude_code(root, routing)
        elif selected == "codex":
            result = _write_codex(root, routing)
        elif selected == "openclaude":
            result = _write_openclaude(root, routing)
        elif selected == "hermes":
            ...   # keep existing branches

def test_cli_setup_run_accepts_repeatable_tool_flag() -> None:
    from coding_scaffold.cli import build_parser
    args = build_parser().parse_args(
        ["setup", "run", "--tool", "codex", "--tool", "claude-code"]
    )
    # action="append" puts each value into a list; normalization happens later.
    assert args.tool_raw == ["codex", "claude-code"]


def test_cli_setup_run_accepts_comma_separated_tool() -> None:
    from coding_scaffold.cli import build_parser
    args = build_parser().parse_args(
        ["setup", "run", "--tool", "codex,claude-code"]
    )
    assert args.tool_raw == ["codex,claude-code"]


def test_cli_main_normalizes_tools_into_args_tools(
    tmp_path, monkeypatch, capsys
) -> None:
    """`main()` runs normalize_tools on args.tool_raw and stashes args.tools."""

    from coding_scaffold.cli import build_parser, main
    # Use a flag-only command that doesn't actually do filesystem work, e.g.,
    # `setup tool` with a list — or assert via a custom dispatch fixture if
    # appropriate. Simplest path: invoke through main with `--help`-like
    # dry-run support, or test the normalization wrapper directly:
    from coding_scaffold.cli import _normalize_args_tools_in_place
    import argparse
    ns = argparse.Namespace(tool_raw=["codex,claude-code"])
    _normalize_args_tools_in_place(ns)
    assert ns.tools == ["codex", "claude-code"]


def test_cli_setup_tool_install_accepts_list_of_tools() -> None:
    from coding_scaffold.cli import build_parser
    args = build_parser().parse_args(
        ["setup", "tool", "--tool", "codex", "--tool", "claude-code", "--install"]
    )
    assert args.tool_raw == ["codex", "claude-code"]


def test_cli_tools_adapt_accepts_repeatable_tool_flag() -> None:
    from coding_scaffold.cli import build_parser
    args = build_parser().parse_args(
        ["tools", "adapt", "--tool", "codex", "--tool", "claude-code"]
    )
    assert args.tool_raw == ["codex", "claude-code"]


def test_cli_main_rejects_manual_with_real_tool(capsys) -> None:
    from coding_scaffold.cli import main
    rc = main(["setup", "run", "--tool", "manual", "--tool", "codex", "--target", "."])
    err = capsys.readouterr().err
    assert rc == 1
    assert "manual" in err.lower()
    assert "next:" in err

parser.add_argument("--tool", choices=CODING_TOOLS, ...)

parser.add_argument(
    "--tool",
    choices=CODING_TOOLS,
    action="append",
    dest="tool_raw",
    default=None,
    help="Coding tool to set up. Repeat or comma-separate for multi-tool projects.",
)

def _normalize_args_tools_in_place(args: argparse.Namespace) -> None:
    """If args carries a `tool_raw` from `action="append"`, normalize it into
    a canonical `tools` list. Surfaces that don't use --tool leave args
    untouched.
    """

    raw = getattr(args, "tool_raw", None)
    if raw is None and not hasattr(args, "tools"):
        # Nothing to do for surfaces that don't take --tool.
        return
    try:
        from .intake import normalize_tools
        args.tools = normalize_tools(raw)
    except CliError as exc:
        from .errors import fail_with
        fail_with(cause=exc.cause, next_step=exc.next_step, link=exc.link)

def main(argv: list[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    _normalize_args_tools_in_place(args)
    ...

def test_pilot_accepts_multi_tool_list(tmp_path: Path) -> None:
    from coding_scaffold.pilot import run_pilot
    report = run_pilot(tmp_path, tools=["codex", "claude-code"])
    assert report.tools == ["codex", "claude-code"]
    # Setup step is shared
    assert "--tool codex,claude-code" in report.steps[0]
    # One agent step per tool at the tail
    agent_steps = [s for s in report.steps if "/first-session" in s]
    assert len(agent_steps) == 2


def test_pilot_environment_ok_requires_all_tools_installed(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    """AND across selected tools — if any is missing, environment_ok is False."""

    import coding_scaffold.pilot as pilot_module
    monkeypatch.setattr(pilot_module.shutil, "which", lambda name: f"/usr/bin/{name}" if name in {"git", "codex", "ollama"} else None)
    from coding_scaffold.pilot import run_pilot
    report = run_pilot(tmp_path, tools=["codex", "claude-code"])
    assert report.environment_ok is False
    # Per-tool entries record individual status
    per_tool = report.environment["tools"]
    by_name = {entry["name"]: entry["installed"] for entry in per_tool}
    assert by_name["codex"] is True
    assert by_name["claude-code"] is False


def test_pilot_json_emits_tools_list_only(
    tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
    from coding_scaffold.cli import main
    rc = main(["pilot", "--target", str(tmp_path), "--tool", "codex,claude-code", "--json"])
    assert rc == 0
    payload = json.loads(capsys.readouterr().out)
    assert payload["tools"] == ["codex", "claude-code"]
    assert "tool" not in payload, "pilot JSON must not carry singular tool"
    assert "tool" not in payload["environment"], "environment must not carry singular tool"
    assert len(payload["environment"]["tools"]) == 2


def test_pilot_single_tool_output_is_unchanged(tmp_path: Path) -> None:
    """Golden: single-tool pilot keeps today's text format bit-for-bit."""

    from coding_scaffold.pilot import format_pilot_text, run_pilot
    text = format_pilot_text(run_pilot(tmp_path, tool="opencode"))
    # Today's format has no "Tools:" header for single-tool.
    assert "Tools:" not in text or "Tools: opencode" in text  # Either omit or single line OK
    assert "Run these next" in text
    # Three numbered steps as before.
    assert "  1. " in text and "  2. " in text and "  3. " in text


def test_pilot_text_multi_tool_has_tools_header_and_shared_setup(tmp_path: Path) -> None:
    from coding_scaffold.pilot import format_pilot_text, run_pilot
    text = format_pilot_text(run_pilot(tmp_path, tools=["codex", "claude-code"]))
    assert "Tools: codex, claude-code" in text
    # Shared setup step lives in "Run these once"
    assert "Run these once" in text
    # Per-tool agent steps live in "Then start a session"
    assert "Then start a session" in text
    assert "codex" in text and "claude" in text

@dataclass(frozen=True)
class PilotReport:
    target: str
    tools: list[str]              # was: tool: str
    environment_ok: bool
    environment: dict[str, object]
    steps: list[str]
    ignore_for_now: list[str]
    warnings: list[str] = field(default_factory=list)
    persona: str = DEFAULT_PERSONA

    def to_dict(self) -> dict[str, object]:
        return {
            "target": self.target,
            "tools": list(self.tools),
            "persona": self.persona,
            "environment_ok": self.environment_ok,
            "environment": dict(self.environment),
            "steps": list(self.steps),
            "ignore_for_now": list(self.ignore_for_now),
            "warnings": list(self.warnings),
        }

def run_pilot(
    target: Path | None = None,
    *,
    tool: str | None = None,           # back-compat shim (kwarg)
    tools: list[str] | None = None,
    persona: str = DEFAULT_PERSONA,
) -> PilotReport:
    """Build a structured PilotReport.

    Pass `tools=[...]` for the canonical multi-tool path. The `tool=` kwarg
    is preserved for backward-compatible callers; it is normalized via
    `normalize_tools` (so legacy passes like `tool="opencode"` keep working).
    """

    from .intake import normalize_tools
    if tools is not None:
        canonical = normalize_tools(tools)
    else:
        canonical = normalize_tools(tool if tool is not None else "opencode")
    ...

pilot.add_argument(
    "--tool",
    choices=list(PILOT_SUPPORTED_TOOLS),
    action="append",
    dest="tool_raw",
    default=None,
    help="Coding tool(s) to weave into the recipe (default: opencode). "
         "Repeat or comma-separate for multi-tool projects.",
)

def _cmd_pilot(args: argparse.Namespace) -> int:
    try:
        report = run_pilot(
            args.target,
            tools=getattr(args, "tools", None),
            persona=getattr(args, "persona", DEFAULT_PERSONA),
        )
    except ValueError as exc:
        ...

"""End-to-end coverage for multi-tool intake (spec §9.2)."""

from __future__ import annotations

import json
from pathlib import Path

import pytest

from coding_scaffold.cli import main


def test_setup_run_two_tools_writes_both_adapter_sets(tmp_path: Path) -> None:
    """One setup run with --tool codex --tool claude-code produces both
    AGENTS.md (codex) and CLAUDE.md (claude-code)."""

    rc = main([
        "setup", "run",
        "--target", str(tmp_path),
        "--tool", "codex",
        "--tool", "claude-code",
        "--non-interactive",
    ])
    assert rc == 0
    assert (tmp_path / "AGENTS.md").exists()
    assert (tmp_path / "CLAUDE.md").exists()
    # routing.json carries the tools list, not a singular tool.
    routing = json.loads((tmp_path / ".coding-scaffold" / "routing.json").read_text())
    assert routing["tools"] == ["codex", "claude-code"]
    assert "tool" not in routing


def test_tools_adapt_with_comma_separated_tool_writes_both(tmp_path: Path) -> None:
    # Bootstrap routing.json first by running setup with one tool.
    main(["setup", "run", "--target", str(tmp_path), "--tool", "codex", "--non-interactive"])
    # Then `tools adapt` with comma-separated value.
    rc = main([
        "tools", "adapt",
        "--target", str(tmp_path),
        "--tool", "codex,claude-code",
    ])
    assert rc == 0
    assert (tmp_path / "AGENTS.md").exists()
    assert (tmp_path / "CLAUDE.md").exists()


def test_tools_adapt_is_idempotent_on_rerun(tmp_path: Path) -> None:
    main(["setup", "run", "--target", str(tmp_path), "--tool", "codex,claude-code", "--non-interactive"])
    # Re-running should skip every file (no new writes), report skipped count.
    rc = main(["tools", "adapt", "--target", str(tmp_path), "--tool", "codex,claude-code"])
    assert rc == 0


def test_pilot_json_multi_tool_shape(
    tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
    rc = main([
        "pilot", "--target", str(tmp_path),
        "--tool", "codex,claude-code", "--json",
    ])
    assert rc == 0
    payload = json.loads(capsys.readouterr().out)
    assert payload["tools"] == ["codex", "claude-code"]
    assert "tool" not in payload
    tools_env = payload["environment"]["tools"]
    assert len(tools_env) == 2
    assert {entry["name"] for entry in tools_env} == {"codex", "claude-code"}


def test_both_alias_still_works_with_deprecation_warning(
    tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
    rc = main([
        "setup", "run",
        "--target", str(tmp_path),
        "--tool", "both",
        "--non-interactive",
    ])
    assert rc == 0
    err = capsys.readouterr().err
    assert "deprecated" in err.lower()
    assert "0.7.0" in err
    routing = json.loads((tmp_path / ".coding-scaffold" / "routing.json").read_text())
    assert routing["tools"] == ["opencode", "openclaude"]


def test_manual_plus_real_tool_exits_non_zero(
    tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
    rc = main([
        "setup", "run",
        "--target", str(tmp_path),
        "--tool", "manual",
        "--tool", "codex",
        "--non-interactive",
    ])
    assert rc == 1
    err = capsys.readouterr().err
    assert "manual" in err.lower()
    assert "next:" in err
    assert "see:" in err


def test_legacy_project_json_with_singular_tool_still_updates(tmp_path: Path) -> None:
    """A `project.json` written by 0.5.x (with `tool` instead of `tools`)
    must be readable by `setup update`."""

    # Bootstrap modern, then mutate the file back to legacy shape.
    main(["setup", "run", "--target", str(tmp_path), "--tool", "codex", "--non-interactive"])
    project_json = tmp_path / ".coding-scaffold" / "project.json"
    payload = json.loads(project_json.read_text())
    del payload["tools"]
    payload["tool"] = "codex"
    project_json.write_text(json.dumps(payload))
    # setup update should silently back-fill and run.
    rc = main(["setup", "update", "--target", str(tmp_path)])
    assert rc == 0
    # After the update, the file is rewritten in the modern shape.
    new_payload = json.loads(project_json.read_text())
    assert "tools" in new_payload
    assert new_payload["tools"] == ["codex"]