Skip to content

try-works/role-model / .agents/skills/recursive-mode

recursive-mode

Unverified

Repository workflow orchestration skill for staged implementation, locked artifacts, late-phase receipts, and durable memory maintenance. Use when executing recursive-mode runs, resuming a run, locking a phase, or verifying locks.

FileKindSize
.agent/PLANS.mdmarkdown2.6 KB
.codex/AGENTS.mdmarkdown7.5 KB
.gitattributesother522 B
.gitignoreother553 B
.recursive/AGENTS.mdmarkdown3.3 KB
.recursive/DECISIONS.mdmarkdown1.1 KB
.recursive/README.mdmarkdown8.5 KB
.recursive/RECURSIVE.mdmarkdown107.5 KB
.recursive/STATE.mdmarkdown1.6 KB
.recursive/config/recursive-router.jsonconfig1.4 KB
.recursive/memory/MEMORY.mdmarkdown3.3 KB
.recursive/memory/archive/.gitkeepother1 B
.recursive/memory/domains/.gitkeepother1 B
.recursive/memory/episodes/.gitkeepother1 B
.recursive/memory/incidents/.gitkeepother1 B
.recursive/memory/patterns/.gitkeepother1 B
.recursive/memory/skills/SKILLS.mdmarkdown4.3 KB
.recursive/memory/skills/availability/.gitkeepother1 B
.recursive/memory/skills/issues/.gitkeepother1 B
.recursive/memory/skills/patterns/.gitkeepother1 B
.recursive/memory/skills/patterns/delegated-verification-and-refresh.mdmarkdown1.7 KB
.recursive/memory/skills/patterns/phase8-skill-memory-promotion.mdmarkdown1.4 KB
.recursive/memory/skills/usage/.gitkeepother1 B
.recursive/memory/skills/usage/skill-discovery-and-evaluation.mdmarkdown1.6 KB
.recursive/run/.gitkeepother1 B
AGENTS.mdmarkdown7.8 KB
LICENSEother11.1 KB
README.mdmarkdown17.8 KB
SKILL.mdskill md13.1 KB
agents/code-reviewer.mdmarkdown6.1 KB
agents/implementer.mdmarkdown6.3 KB
agents/openai.yamlconfig202 B
docs/templates/commands/check-reusable-repo-hygiene.mdmarkdown1.3 KB
docs/templates/commands/recursive-closeout.mdmarkdown2.8 KB
docs/templates/commands/recursive-init.mdmarkdown2.2 KB
docs/templates/commands/recursive-lock.mdmarkdown1.3 KB
docs/templates/commands/recursive-review-bundle.mdmarkdown3.6 KB
docs/templates/commands/recursive-status.mdmarkdown2.0 KB
docs/templates/commands/recursive-subagent-action.mdmarkdown4.2 KB
docs/templates/commands/test-recursive-mode-smoke.mdmarkdown3.4 KB
docs/templates/hooks/hooks.jsonconfig400 B
docs/templates/hooks/run-hook.cmdscript1.2 KB
docs/templates/hooks/session-start.ps1script3.6 KB
docs/templates/hooks/session-start.shscript3.5 KB
references/agents-block.mdmarkdown7.4 KB
references/artifact-template.mdmarkdown70.7 KB
references/benchmark-addon/recursive-benchmark/BENCHMARK-ADDON.mdmarkdown6.7 KB
references/benchmark-addon/recursive-benchmark/recursive-benchmark/BENCHMARK-ADDON.mdmarkdown6.7 KB
references/benchmark-addon/recursive-benchmark/recursive-benchmark/references/patterns.mdmarkdown4.9 KB
references/benchmark-addon/recursive-benchmark/references/patterns.mdmarkdown4.9 KB
references/benchmarks/README.mdmarkdown1.5 KB
references/benchmarks/local-first-planner/00-requirements.mdmarkdown3.3 KB
references/benchmarks/local-first-planner/README.mdmarkdown1.1 KB
references/benchmarks/local-first-planner/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/local-first-planner/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/local-first-planner/scoring-rubric.mdmarkdown1.3 KB
references/benchmarks/local-first-planner/starter/.gitignoreother30 B
references/benchmarks/local-first-planner/starter/README.mdmarkdown264 B
references/benchmarks/local-first-planner/starter/index.htmlother316 B
references/benchmarks/local-first-planner/starter/package.jsonmanifest628 B
references/benchmarks/local-first-planner/starter/src/App.test.tsxother334 B
references/benchmarks/local-first-planner/starter/src/App.tsxother971 B
references/benchmarks/local-first-planner/starter/src/main.tsxother238 B
references/benchmarks/local-first-planner/starter/src/styles.cssother976 B
references/benchmarks/local-first-planner/starter/src/test-setup.tsscript43 B
references/benchmarks/local-first-planner/starter/src/vite-env.d.tsscript38 B
references/benchmarks/local-first-planner/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/local-first-planner/starter/tsconfig.jsonconfig89 B
references/benchmarks/local-first-planner/starter/vite.config.tsscript214 B
references/benchmarks/release-readiness-dashboard/00-requirements.mdmarkdown5.9 KB
references/benchmarks/release-readiness-dashboard/README.mdmarkdown1.2 KB
references/benchmarks/release-readiness-dashboard/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/release-readiness-dashboard/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/release-readiness-dashboard/scoring-rubric.mdmarkdown1.8 KB
references/benchmarks/release-readiness-dashboard/starter/.gitignoreother30 B
references/benchmarks/release-readiness-dashboard/starter/README.mdmarkdown272 B
references/benchmarks/release-readiness-dashboard/starter/index.htmlother324 B
references/benchmarks/release-readiness-dashboard/starter/package.jsonmanifest628 B
references/benchmarks/release-readiness-dashboard/starter/src/App.test.tsxother342 B
references/benchmarks/release-readiness-dashboard/starter/src/App.tsxother979 B
references/benchmarks/release-readiness-dashboard/starter/src/main.tsxother238 B
references/benchmarks/release-readiness-dashboard/starter/src/styles.cssother976 B
references/benchmarks/release-readiness-dashboard/starter/src/test-setup.tsscript43 B
references/benchmarks/release-readiness-dashboard/starter/src/vite-env.d.tsscript38 B
references/benchmarks/release-readiness-dashboard/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/release-readiness-dashboard/starter/tsconfig.jsonconfig89 B
references/benchmarks/release-readiness-dashboard/starter/vite.config.tsscript214 B
references/benchmarks/scientific-calculator-rust/00-requirements.mdmarkdown4.1 KB
references/benchmarks/scientific-calculator-rust/README.mdmarkdown1.4 KB
references/benchmarks/scientific-calculator-rust/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/scientific-calculator-rust/prompt-recursive-on.mdmarkdown16.6 KB
references/benchmarks/scientific-calculator-rust/scoring-rubric.mdmarkdown1.5 KB
references/benchmarks/scientific-calculator-rust/starter/.gitignoreother14 B
references/benchmarks/scientific-calculator-rust/starter/Cargo.lockmanifest25.7 KB
references/benchmarks/scientific-calculator-rust/starter/Cargo.tomlmanifest226 B
references/benchmarks/team-capacity-board/00-requirements.mdmarkdown3.6 KB
references/benchmarks/team-capacity-board/README.mdmarkdown1.0 KB
references/benchmarks/team-capacity-board/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/team-capacity-board/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/team-capacity-board/scoring-rubric.mdmarkdown1.4 KB
references/benchmarks/team-capacity-board/starter/.gitignoreother30 B
references/benchmarks/team-capacity-board/starter/README.mdmarkdown264 B
references/benchmarks/team-capacity-board/starter/index.htmlother316 B
references/benchmarks/team-capacity-board/starter/package.jsonmanifest628 B
references/benchmarks/team-capacity-board/starter/src/App.test.tsxother334 B
references/benchmarks/team-capacity-board/starter/src/App.tsxother971 B
references/benchmarks/team-capacity-board/starter/src/main.tsxother238 B
references/benchmarks/team-capacity-board/starter/src/styles.cssother976 B
references/benchmarks/team-capacity-board/starter/src/test-setup.tsscript43 B
references/benchmarks/team-capacity-board/starter/src/vite-env.d.tsscript38 B
references/benchmarks/team-capacity-board/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/team-capacity-board/starter/tsconfig.jsonconfig89 B
references/benchmarks/team-capacity-board/starter/vite.config.tsscript214 B
references/bootstrap/RECURSIVE.mdmarkdown109.9 KB
references/fixtures/tiny-tasks-smoke-recipe.mdmarkdown2.6 KB
references/local-first-web-app-checklist.mdmarkdown1.6 KB
references/plans-canonical.mdmarkdown10.8 KB
scripts/check-reusable-repo-hygiene.ps1script625 B
scripts/check-reusable-repo-hygiene.pyscript6.3 KB
scripts/install-recursive-mode.ps1script36.0 KB
scripts/install-recursive-mode.pyscript31.8 KB
scripts/install-recursive-mode.shscript363 B
scripts/lint-recursive-run.ps1script739 B
scripts/lint-recursive-run.pyscript127.4 KB
scripts/recursive-closeout.ps1script1015 B
scripts/recursive-closeout.pyscript24.0 KB
scripts/recursive-init.ps1script18.7 KB
scripts/recursive-init.pyscript12.6 KB
scripts/recursive-lock.ps1script677 B
scripts/recursive-lock.pyscript12.6 KB
scripts/recursive-review-bundle.ps1script2.9 KB
scripts/recursive-review-bundle.pyscript22.1 KB
scripts/recursive-router-cli-configure.ps1script86 B
scripts/recursive-router-cli-configure.pyscript230 B
scripts/recursive-router-cli-init.ps1script81 B
scripts/recursive-router-cli-init.pyscript225 B
scripts/recursive-router-cli-invoke.ps1script83 B
scripts/recursive-router-cli-invoke.pyscript227 B
scripts/recursive-router-cli-probe.ps1script82 B
scripts/recursive-router-cli-probe.pyscript226 B
scripts/recursive-router-cli-resolve.ps1script84 B
scripts/recursive-router-cli-resolve.pyscript228 B
scripts/recursive-router-cli-validate.ps1script85 B
scripts/recursive-router-cli-validate.pyscript229 B
scripts/recursive-router-configure.ps1script798 B
scripts/recursive-router-configure.pyscript2.8 KB
scripts/recursive-router-init.ps1script490 B
scripts/recursive-router-init.pyscript925 B
scripts/recursive-router-invoke.ps1script1.5 KB
scripts/recursive-router-invoke.pyscript4.4 KB
scripts/recursive-router-probe.ps1script735 B
scripts/recursive-router-probe.pyscript1.6 KB
scripts/recursive-router-resolve.ps1script803 B
scripts/recursive-router-resolve.pyscript1.6 KB
scripts/recursive-router-validate.ps1script494 B
scripts/recursive-router-validate.pyscript804 B
scripts/recursive-status.ps1script674 B
scripts/recursive-status.pyscript97.7 KB
scripts/recursive-subagent-action.ps1script5.8 KB
scripts/recursive-subagent-action.pyscript12.4 KB
scripts/recursive-training-extract.ps1script586 B
scripts/recursive-training-extract.pyscript1.0 KB
scripts/recursive-training-grpo.ps1script1.2 KB
scripts/recursive-training-grpo.pyscript47.2 KB
scripts/recursive-training-loader.ps1script2.3 KB
scripts/recursive-training-loader.pyscript20.1 KB
scripts/recursive-training-mcp.ps1script721 B
scripts/recursive-training-mcp.pyscript10.1 KB
scripts/recursive-training-phase8-trigger.ps1script1.4 KB
scripts/recursive-training-phase8-trigger.pyscript4.0 KB
scripts/recursive-training-sync.ps1script735 B
scripts/recursive-training-sync.pyscript6.9 KB
scripts/recursive_phase_rules.pyscript12.7 KB
scripts/recursive_router_cli_lib.pyscript77 B
scripts/recursive_router_lib.pyscript84.5 KB
scripts/run-recursive-benchmark.ps1script2.1 KB
scripts/run-recursive-benchmark.pyscript376.1 KB
scripts/test-recursive-mode-smoke.ps1script1.0 KB
scripts/test-recursive-mode-smoke.pyscript121.0 KB
scripts/test_install_recursive_mode.pyscript38.4 KB
scripts/test_lint_recursive_run.pyscript4.1 KB
scripts/test_recursive_phase_rules.pyscript21.4 KB
scripts/test_recursive_review_bundle.pyscript5.8 KB
scripts/test_recursive_router.pyscript53.3 KB
scripts/test_recursive_subagent_action.pyscript3.2 KB
scripts/test_recursive_training.pyscript12.0 KB
scripts/test_run_recursive_benchmark.pyscript160.0 KB
scripts/verify-locks.ps1script733 B
scripts/verify-locks.pyscript13.8 KB

scripts/test_recursive_router.py

View on GitHub
#!/usr/bin/env python3
from __future__ import annotations

import json
import os
import shutil
import subprocess
import sys
import tempfile
import textwrap
import unittest
from pathlib import Path


REPO_ROOT = Path(__file__).resolve().parent.parent
SCRIPTS_ROOT = REPO_ROOT / "scripts"


def write_text(path: Path, content: str) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content.rstrip() + "\n", encoding="utf-8", newline="\n")


class RecursiveRouterTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = Path(tempfile.mkdtemp(prefix="recursive-router-test-"))
        self.repo_root = self.temp_dir / "repo"
        self.repo_root.mkdir(parents=True, exist_ok=True)
        self.home_dir = self.temp_dir / "home"
        self.home_dir.mkdir(parents=True, exist_ok=True)
        self.bin_dir = self.temp_dir / "bin"
        self.bin_dir.mkdir(parents=True, exist_ok=True)
        python_dir = str(Path(sys.executable).resolve().parent)
        self.env = os.environ.copy()
        self.env["PATH"] = os.pathsep.join([str(self.bin_dir), python_dir])
        self.env["HOME"] = str(self.home_dir)
        self.env["USERPROFILE"] = str(self.home_dir)
        self.env["PYTHONDONTWRITEBYTECODE"] = "1"

    def tearDown(self) -> None:
        shutil.rmtree(self.temp_dir, ignore_errors=True)

    def run_repo_script(
        self,
        script_name: str,
        *args: str,
        allowed_returncodes: tuple[int, ...] = (0,),
    ) -> subprocess.CompletedProcess[str]:
        completed = subprocess.run(
            [sys.executable, str(SCRIPTS_ROOT / script_name), *args],
            cwd=str(REPO_ROOT),
            text=True,
            capture_output=True,
            env=self.env,
            check=False,
        )
        if completed.returncode not in allowed_returncodes:
            self.fail(
                f"{script_name} failed with code {completed.returncode}\n"
                f"STDOUT:\n{completed.stdout}\nSTDERR:\n{completed.stderr}"
            )
        return completed

    def load_json(self, path: Path) -> object:
        return json.loads(path.read_text(encoding="utf-8"))

    def policy_path(self) -> Path:
        return self.repo_root / ".recursive" / "config" / "recursive-router.json"

    def discovery_path(self) -> Path:
        return self.repo_root / ".recursive" / "config" / "recursive-router-discovered.json"

    def install_bootstrap(self) -> None:
        self.run_repo_script("install-recursive-mode.py", "--repo-root", str(self.repo_root))

    def initialize_router(self) -> None:
        self.run_repo_script("recursive-router-init.py", "--repo-root", str(self.repo_root))

    def run_repo_powershell_script(
        self,
        script_name: str,
        *args: str,
        allowed_returncodes: tuple[int, ...] = (0,),
    ) -> subprocess.CompletedProcess[str]:
        powershell = shutil.which("pwsh") or shutil.which("powershell")
        if powershell is None:
            self.skipTest("PowerShell is required for router PowerShell wrapper tests")
        completed = subprocess.run(
            [powershell, "-NoProfile", "-File", str(SCRIPTS_ROOT / script_name), *args],
            cwd=str(REPO_ROOT),
            text=True,
            capture_output=True,
            env=self.env,
            check=False,
        )
        if completed.returncode not in allowed_returncodes:
            self.fail(
                f"{script_name} failed with code {completed.returncode}\n"
                f"STDOUT:\n{completed.stdout}\nSTDERR:\n{completed.stderr}"
            )
        return completed

    def write_policy(self, payload: dict[str, object]) -> None:
        write_text(self.policy_path(), json.dumps(payload, indent=2))

    def write_home_file(self, relative_path: str, content: str) -> Path:
        path = self.home_dir / relative_path
        write_text(path, content)
        return path

    def make_fake_cli(
        self,
        name: str,
        *,
        version: str = "1.2.3",
        models: list[str] | None = None,
        app_server_models: list[str] | None = None,
        invoke_echo: bool = True,
        invoke_exit: int = 0,
        probe_exit: int = 0,
        model_exit: int = 0,
        probe_sleep_seconds: float = 0.0,
        require_structured_run: bool = False,
        record_invocations_path: Path | None = None,
        emit_output_before_failure: bool = False,
    ) -> Path:
        runner_path = self.bin_dir / f"{name}-runner.py"
        model_lines = "\\n".join(models or [])
        app_server_payload = json.dumps(list(app_server_models or []))
        script = textwrap.dedent(
            f"""
            import json
            import pathlib
            import sys
            import time

            invoke_echo = {invoke_echo!r}
            invoke_exit = {invoke_exit!r}
            emit_output_before_failure = {emit_output_before_failure!r}
            record_invocations_path = {str(record_invocations_path) if record_invocations_path else None!r}
            args = sys.argv[1:]

            def emit_prompt(prompt: str) -> None:
                if record_invocations_path:
                    with pathlib.Path(record_invocations_path).open("a", encoding="utf-8") as handle:
                        handle.write(json.dumps(args) + "\\n")
                if invoke_exit != 0:
                    print("invocation failed", file=sys.stderr)
                    raise SystemExit(invoke_exit)
                if invoke_echo:
                    print(prompt)
                else:
                    print("verification failed")
                raise SystemExit(0)

            def emit_stream_json(prompt: str) -> None:
                if record_invocations_path:
                    with pathlib.Path(record_invocations_path).open("a", encoding="utf-8") as handle:
                        handle.write(json.dumps(args) + "\\n")
                message = prompt if invoke_echo else "verification failed"
                if emit_output_before_failure:
                    print(json.dumps({{"role": "assistant", "content": message}}))
                if invoke_exit != 0:
                    print("invocation failed", file=sys.stderr)
                    raise SystemExit(invoke_exit)
                print(json.dumps({{"role": "assistant", "content": message}}))
                print("<choice>STOP</choice>")
                raise SystemExit(0)

            if args == ["--version"]:
                if {probe_sleep_seconds!r}:
                    time.sleep({probe_sleep_seconds!r})
                if {probe_exit} != 0:
                    print("probe failed", file=sys.stderr)
                    raise SystemExit({probe_exit})
                print({version!r})
                raise SystemExit(0)
            if args == ["models", "list"]:
                if {model_exit} != 0:
                    print("model list failed", file=sys.stderr)
                    raise SystemExit({model_exit})
                output = {model_lines!r}
                if output:
                    print(output)
                raise SystemExit(0)
            if args == ["models"]:
                if {model_exit} != 0:
                    print("model list failed", file=sys.stderr)
                    raise SystemExit({model_exit})
                output = {model_lines!r}
                if output:
                    print(output)
                raise SystemExit(0)
            if (
                len(args) >= 11
                and args[0] == "--model"
                and args[2:10] == [
                    "--allow-all",
                    "--no-ask-user",
                    "--output-format",
                    "json",
                    "--stream",
                    "off",
                    "--no-color",
                    "-p",
                ]
            ):
                emit_prompt(args[10])
            if args[:2] == ["--model", args[1]] and "--output-format" in args and args[args.index("--output-format") + 1] == "stream-json" and "--work-dir" in args and "--prompt" in args:
                emit_stream_json(args[args.index("--prompt") + 1])
            if args[:2] == ["--model", args[1]] and "--prompt" in args:
                emit_prompt(args[args.index("--prompt") + 1])
            if args == ["app-server", "--listen", "stdio://"]:
                app_models = json.loads({app_server_payload!r})
                if not app_models:
                    print("app-server disabled", file=sys.stderr)
                    raise SystemExit(2)
                for raw_line in sys.stdin:
                    line = raw_line.strip()
                    if not line:
                        continue
                    message = json.loads(line)
                    method = message.get("method")
                    if method == "initialize":
                        print(
                            json.dumps(
                                {{
                                    "id": message["id"],
                                    "result": {{
                                        "userAgent": "fake-codex/0.0.0",
                                        "platformFamily": "windows",
                                        "platformOs": "windows",
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        continue
                    if method == "initialized":
                        continue
                    if method == "model/list":
                        print(
                            json.dumps(
                                {{
                                    "id": message["id"],
                                    "result": {{
                                        "data": [
                                            {{
                                                "id": model,
                                                "model": model,
                                                "displayName": model,
                                                "hidden": False,
                                                "isDefault": index == 0,
                                            }}
                                            for index, model in enumerate(app_models)
                                        ],
                                        "nextCursor": None,
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        continue
                    if method == "thread/start":
                        model = message.get("params", {{}}).get("model")
                        print(
                            json.dumps(
                                {{
                                    "id": message["id"],
                                    "result": {{
                                        "thread": {{"id": "00000000-0000-0000-0000-000000000001", "status": {{"type": "idle"}}}},
                                        "model": model,
                                        "modelProvider": "openai",
                                        "cwd": "D:\\\\repo",
                                        "approvalPolicy": "never",
                                        "approvalsReviewer": "user",
                                        "sandbox": {{"type": "readOnly", "access": {{"type": "fullAccess"}}, "networkAccess": False}},
                                        "reasoningEffort": "high",
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        continue
                    if method == "turn/start":
                        params = message.get("params", {{}})
                        prompt = params.get("input", [{{}}])[0].get("text", "")
                        turn_id = "00000000-0000-0000-0000-000000000002"
                        print(
                            json.dumps(
                                {{
                                    "id": message["id"],
                                    "result": {{
                                        "turn": {{"id": turn_id, "items": [], "status": "inProgress", "error": None}}
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        print(
                            json.dumps(
                                {{
                                    "method": "item/completed",
                                    "params": {{
                                        "threadId": params.get("threadId"),
                                        "turnId": turn_id,
                                        "item": {{
                                            "type": "agentMessage",
                                            "id": "msg-1",
                                            "text": prompt if invoke_echo else "verification failed",
                                            "phase": "final_answer",
                                        }},
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        print(
                            json.dumps(
                                {{
                                    "method": "turn/completed",
                                    "params": {{
                                        "threadId": params.get("threadId"),
                                        "turn": {{"id": turn_id, "items": [], "status": "completed", "error": None}},
                                    }},
                                }}
                            ),
                            flush=True,
                        )
                        continue
                    print(
                        json.dumps(
                            {{
                                "id": message.get("id"),
                                "error": {{"code": -32601, "message": f"unsupported method: {{method}}"}},
                            }}
                        ),
                        flush=True,
                    )
                raise SystemExit(0)
            if args[:1] == ["exec"] and "--input-file" in args:
                prompt_file = pathlib.Path(args[args.index("--input-file") + 1])
                emit_prompt(prompt_file.read_text(encoding="utf-8"))
            if (
                len(args) >= 6
                and args[:3] == ["exec", "--model", args[2]]
                and "--json" in args
                and "-C" in args
                and args[-1]
            ):
                emit_prompt(args[-1])
            if args[:1] == ["run"]:
                if "--prompt-file" in args:
                    prompt_file = pathlib.Path(args[args.index("--prompt-file") + 1])
                    emit_prompt(prompt_file.read_text(encoding="utf-8"))
                if "--model" in args and args[-1]:
                    if {require_structured_run!r}:
                        if "--format" not in args or args[args.index("--format") + 1] != "json":
                            print("missing json format", file=sys.stderr)
                            raise SystemExit(2)
                        if "--dir" not in args:
                            print("missing explicit dir", file=sys.stderr)
                            raise SystemExit(2)
                    emit_prompt(args[-1])
                if "-m" in args and args[-1]:
                    if {require_structured_run!r}:
                        print("legacy -m invocation rejected", file=sys.stderr)
                        raise SystemExit(2)
                    emit_prompt(args[-1])
            if "--prompt" in args:
                emit_prompt(args[args.index("--prompt") + 1])
            print("unexpected args", args, file=sys.stderr)
            raise SystemExit(2)
            """
        ).strip()
        write_text(runner_path, script)

        if os.name == "nt":
            wrapper_path = self.bin_dir / f"{name}.cmd"
            wrapper = f'@echo off\r\n"{sys.executable}" "{runner_path}" %*\r\n'
            wrapper_path.write_text(wrapper, encoding="utf-8", newline="\r\n")
            ps1_path = self.bin_dir / f"{name}.ps1"
            ps1_wrapper = f'& "{sys.executable}" "{runner_path}" @args\r\nexit $LASTEXITCODE\r\n'
            ps1_path.write_text(ps1_wrapper, encoding="utf-8", newline="\r\n")
        else:
            wrapper_path = self.bin_dir / name
            wrapper = f'#!/bin/sh\n"{sys.executable}" "{runner_path}" "$@"\n'
            wrapper_path.write_text(wrapper, encoding="utf-8", newline="\n")
            wrapper_path.chmod(0o755)
        return wrapper_path

    def test_install_bootstrap_creates_router_policy_and_gitignores_local_discovery(self) -> None:
        self.install_bootstrap()

        policy = self.load_json(self.policy_path())
        gitignore = (self.repo_root / ".gitignore").read_text(encoding="utf-8")

        self.assertEqual(policy["version"], 1)
        self.assertIn("role_routes", policy)
        self.assertEqual(policy["defaults"]["probe_timeout_ms"], 50000)
        self.assertEqual(policy["role_routes"]["orchestrator"]["mode"], "local-only")
        self.assertEqual(policy["role_routes"]["orchestrator"]["fallback"], "local-controller")
        self.assertIsNone(policy["role_routes"]["analyst"]["cli"])
        self.assertIsNone(policy["role_routes"]["analyst"]["model"])
        self.assertFalse(self.discovery_path().exists())
        self.assertIn("/.recursive/config/recursive-router-discovered.json", gitignore)

    def test_init_does_not_overwrite_existing_policy(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        policy["defaults"]["when_role_unconfigured"] = "block"
        policy["role_routes"]["code-reviewer"]["cli"] = "codex"
        policy["role_routes"]["code-reviewer"]["model"] = "gpt-5"
        self.write_policy(policy)

        self.initialize_router()

        updated = self.load_json(self.policy_path())
        self.assertEqual(updated["defaults"]["when_role_unconfigured"], "block")
        self.assertEqual(updated["role_routes"]["code-reviewer"]["cli"], "codex")
        self.assertEqual(updated["role_routes"]["code-reviewer"]["model"], "gpt-5")

    def test_cli_init_python_wrapper_bootstraps_router_policy(self) -> None:
        self.run_repo_script("recursive-router-cli-init.py", "--repo-root", str(self.repo_root))

        policy = self.load_json(self.policy_path())
        self.assertEqual(policy["version"], 1)
        self.assertIn("role_routes", policy)

    def test_cli_init_powershell_wrapper_bootstraps_router_policy(self) -> None:
        self.run_repo_powershell_script("recursive-router-cli-init.ps1", "-RepoRoot", str(self.repo_root))

        policy = self.load_json(self.policy_path())
        self.assertEqual(policy["version"], 1)
        self.assertIn("role_routes", policy)

    def test_validate_rejects_unsupported_version(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        policy["version"] = 2
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-validate.py",
            "--repo-root",
            str(self.repo_root),
            allowed_returncodes=(1,),
        )

        self.assertIn("Unsupported config version", completed.stdout + completed.stderr)

    def test_validate_rejects_invalid_custom_cli_schema(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        policy["custom_clis"] = [
            {
                "id": "custom-one",
                "command": "custom-one",
                "probe_args": ["--version"],
                "invoke_template": ["run", "--model", "{model}"],
            }
        ]
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-validate.py",
            "--repo-root",
            str(self.repo_root),
            allowed_returncodes=(1,),
        )

        self.assertIn("invoke_template", completed.stdout + completed.stderr)

    def test_validate_accepts_legacy_policy_without_invoke_timeout(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        del policy["defaults"]["invoke_timeout_ms"]
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-validate.py",
            "--repo-root",
            str(self.repo_root),
        )

        self.assertEqual(completed.returncode, 0)

    def test_validate_rejects_invalid_cli_override_schema(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        policy["cli_overrides"]["codex"] = {
            "invoke_template": ["--model", "{model}"],
        }
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-validate.py",
            "--repo-root",
            str(self.repo_root),
            allowed_returncodes=(1,),
        )

        self.assertIn("cli_overrides.codex.invoke_template", completed.stdout + completed.stderr)

    def test_probe_discovers_builtin_codex_models_from_local_cache(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9")
        self.write_home_file(
            ".codex/models_cache.json",
            json.dumps(
                {
                    "fetched_at": "2026-04-17T00:00:00Z",
                    "client_version": "0.115.0",
                    "models": [
                        {"slug": "gpt-5.4"},
                        {"slug": "gpt-5.4-mini"},
                        {"slug": "gpt-5.2"},
                    ],
                }
            ),
        )

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
        )
        payload = json.loads(completed.stdout)
        codex = next(entry for entry in payload["clis"] if entry["id"] == "codex")

        self.assertTrue(codex["available"])
        self.assertEqual(codex["version"], "9.9.9")
        self.assertEqual(codex["models"], ["gpt-5.4", "gpt-5.4-mini", "gpt-5.2"])
        self.assertEqual(codex["model_source"], "cache-file")
        self.assertEqual(self.load_json(self.discovery_path())["version"], 1)

    def test_probe_prefers_builtin_codex_app_server_model_list(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9", app_server_models=["gpt-5.4-mini", "gpt-5.4"])
        self.write_home_file(
            ".codex/models_cache.json",
            json.dumps(
                {
                    "fetched_at": "2026-04-17T00:00:00Z",
                    "client_version": "0.115.0",
                    "models": [{"slug": "stale-cache-model"}],
                }
            ),
        )

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
        )
        payload = json.loads(completed.stdout)
        codex = next(entry for entry in payload["clis"] if entry["id"] == "codex")

        self.assertTrue(codex["available"])
        self.assertEqual(codex["models"], ["gpt-5.4-mini", "gpt-5.4"])
        self.assertEqual(codex["model_source"], "app-server-model-list")
        self.assertEqual(codex["transport"], "app-server")

    def test_probe_discovers_builtin_kimi_models_from_config_file(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("kimi", version="1.32.0")
        self.write_home_file(
            ".kimi/config.toml",
            """
default_model = "kimi-code/kimi-for-coding"

[models."kimi-code/kimi-for-coding"]
provider = "managed:kimi-code"
model = "kimi-for-coding"

[models."preview"]
provider = "managed:kimi-code"
model = "kimi-k2.6-code-previews"
""",
        )

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
        )
        payload = json.loads(completed.stdout)
        kimi = next(entry for entry in payload["clis"] if entry["id"] == "kimi")

        self.assertTrue(kimi["available"])
        self.assertEqual(kimi["version"], "1.32.0")
        self.assertEqual(kimi["models"], ["kimi-code/kimi-for-coding", "preview"])
        self.assertEqual(kimi["model_source"], "config-file")

    def test_probe_handles_broken_probe_and_timeout(self) -> None:
        self.install_bootstrap()
        broken_wrapper = self.make_fake_cli("broken-cli", probe_exit=3)
        slow_wrapper = self.make_fake_cli("slow-cli", probe_sleep_seconds=1.0)
        policy = self.load_json(self.policy_path())
        policy["custom_clis"] = [
            {
                "id": "broken-cli",
                "command": str(broken_wrapper),
                "probe_args": ["--version"],
                "invoke_template": ["run", "--model", "{model}", "--prompt-file", "{prompt_file}"],
            },
            {
                "id": "slow-cli",
                "command": str(slow_wrapper),
                "probe_args": ["--version"],
                "invoke_template": ["run", "--model", "{model}", "--prompt-file", "{prompt_file}"],
            },
        ]
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
            "--timeout-ms",
            "500",
        )
        payload = json.loads(completed.stdout)
        broken_cli = next(entry for entry in payload["clis"] if entry["id"] == "broken-cli")
        slow_cli = next(entry for entry in payload["clis"] if entry["id"] == "slow-cli")

        self.assertFalse(broken_cli["available"])
        self.assertEqual(broken_cli["model_source"], "unknown")
        self.assertTrue(any("probe failed" in note.lower() for note in broken_cli["notes"]))
        self.assertFalse(slow_cli["available"])
        self.assertTrue(any("timed out" in note.lower() for note in slow_cli["notes"]))

    def test_probe_records_launcher_start_failure_without_aborting_inventory(self) -> None:
        self.install_bootstrap()
        blocked_command = self.temp_dir / "not-an-executable"
        blocked_command.mkdir()
        self.make_fake_cli("kimi", version="1.32.0")
        policy = self.load_json(self.policy_path())
        policy["custom_clis"] = [
            {
                "id": "blocked-cli",
                "command": str(blocked_command),
                "probe_args": ["--version"],
                "invoke_template": ["run", "--model", "{model}", "--prompt", "{prompt}"],
            }
        ]
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
        )
        payload = json.loads(completed.stdout)
        blocked = next(entry for entry in payload["clis"] if entry["id"] == "blocked-cli")
        kimi = next(entry for entry in payload["clis"] if entry["id"] == "kimi")

        self.assertFalse(blocked["available"])
        self.assertIn("Failed to start command", blocked["notes"][0])
        self.assertTrue(kimi["available"])

    def test_probe_discovers_custom_cli_with_model_listing(self) -> None:
        self.install_bootstrap()
        custom_wrapper = self.make_fake_cli("custom-router", models=["alpha", "beta"])
        policy = self.load_json(self.policy_path())
        policy["custom_clis"] = [
            {
                "id": "custom-router",
                "command": str(custom_wrapper),
                "probe_args": ["--version"],
                "invoke_template": ["run", "--model", "{model}", "--prompt-file", "{prompt_file}"],
                "model_list_template": ["models", "list"],
            }
        ]
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-probe.py",
            "--repo-root",
            str(self.repo_root),
            "--json",
        )
        payload = json.loads(completed.stdout)
        custom_cli = next(entry for entry in payload["clis"] if entry["id"] == "custom-router")

        self.assertTrue(custom_cli["available"])
        self.assertEqual(custom_cli["models"], ["alpha", "beta"])
        self.assertEqual(custom_cli["model_source"], "cli-list")

    def test_resolve_uses_builtin_codex_cached_models(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9")
        self.write_home_file(
            ".codex/models_cache.json",
            json.dumps(
                {
                    "fetched_at": "2026-04-17T00:00:00Z",
                    "client_version": "0.115.0",
                    "models": [{"slug": "gpt-5.4"}, {"slug": "gpt-5.4-mini"}],
                }
            ),
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["code-reviewer"]["cli"] = "codex"
        policy["role_routes"]["code-reviewer"]["model"] = "gpt-5.4-mini"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "code-reviewer",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "codex")
        self.assertEqual(payload["model"], "gpt-5.4-mini")

    def test_resolve_reports_codex_app_server_transport(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9", app_server_models=["gpt-5.4-mini"])
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["code-reviewer"]["cli"] = "codex"
        policy["role_routes"]["code-reviewer"]["model"] = "gpt-5.4-mini"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "code-reviewer",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "codex")
        self.assertEqual(payload["model"], "gpt-5.4-mini")
        self.assertEqual(payload["transport"], "app-server")

    def test_resolve_uses_builtin_kimi_configured_models(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("kimi", version="1.32.0")
        self.write_home_file(
            ".kimi/config.toml",
            """
default_model = "kimi-code/kimi-for-coding"

[models."kimi-code/kimi-for-coding"]
provider = "managed:kimi-code"
model = "kimi-for-coding"

[models."preview"]
provider = "managed:kimi-code"
model = "kimi-k2.6-code-previews"
""",
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["analyst"]["cli"] = "kimi"
        policy["role_routes"]["analyst"]["model"] = "preview"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "kimi")
        self.assertEqual(payload["model"], "preview")

    def test_resolve_uses_builtin_opencode_configured_models(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("opencode", version="1.3.3", models=["github-copilot/gpt-5.4-mini", "opencode/gpt-5-nano"])
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["analyst"]["cli"] = "opencode"
        policy["role_routes"]["analyst"]["model"] = "github-copilot/gpt-5.4-mini"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)
        discovery = self.load_json(self.discovery_path())
        opencode = next(entry for entry in discovery["clis"] if entry["id"] == "opencode")

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "opencode")
        self.assertEqual(payload["model"], "github-copilot/gpt-5.4-mini")
        self.assertEqual(opencode["models"], ["github-copilot/gpt-5.4-mini", "opencode/gpt-5-nano"])
        self.assertEqual(opencode["model_source"], "cli-list")

    def test_default_probe_timeout_allows_slower_builtin_opencode_probe(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli(
            "opencode",
            version="1.3.3",
            models=["github-copilot/gpt-5.4-mini"],
            probe_sleep_seconds=3.0,
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["analyst"]["cli"] = "opencode"
        policy["role_routes"]["analyst"]["model"] = "github-copilot/gpt-5.4-mini"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "opencode")
        self.assertEqual(payload["model"], "github-copilot/gpt-5.4-mini")

    def test_resolve_returns_external_cli_when_configured_model_is_literal(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex")
        policy = self.load_json(self.policy_path())
        policy["defaults"]["when_model_unknown"] = "use-as-literal"
        policy["role_routes"]["code-reviewer"]["cli"] = "codex"
        policy["role_routes"]["code-reviewer"]["model"] = "gpt-5"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "code-reviewer",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "external-cli")
        self.assertEqual(payload["cli"], "codex")
        self.assertEqual(payload["model"], "gpt-5")
        self.assertFalse(payload["fallback_used"])

    def test_resolve_asks_when_role_is_unconfigured(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="1.0.0")

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "ask-user")
        self.assertIn("analyst", payload["prompt"])
        self.assertIn("codex", payload["prompt"])
        self.assertIn("/.recursive/config/recursive-router.json", payload["prompt"])
        self.assertIn("/.recursive/config/recursive-router-discovered.json", payload["prompt"])

    def test_resolve_auto_assigns_single_cli_but_still_asks_for_null_model(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex")
        policy = self.load_json(self.policy_path())
        policy["defaults"]["allow_auto_assign_if_single_cli"] = True
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "ask-user")
        self.assertEqual(payload["cli"], "codex")
        self.assertIsNone(payload["model"])
        self.assertIn("auto-assigned the only discovered CLI", payload["reason"])

    def test_resolve_falls_back_locally_when_selected_cli_is_unavailable(self) -> None:
        self.install_bootstrap()
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["analyst"]["cli"] = "codex"
        policy["role_routes"]["analyst"]["model"] = "gpt-5"
        self.write_policy(policy)

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "fallback-local")
        self.assertTrue(payload["fallback_used"])
        self.assertEqual(payload["fallback"], "self-audit")
        self.assertIn("unavailable", payload["reason"])

    def test_resolve_keeps_orchestrator_local_by_default(self) -> None:
        self.install_bootstrap()

        completed = self.run_repo_script(
            "recursive-router-resolve.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "orchestrator",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertEqual(payload["decision"], "local-only")
        self.assertEqual(payload["fallback"], "local-controller")
        self.assertEqual(payload["role"], "orchestrator")
        self.assertIn("local-only execution", payload["reason"])

    def test_configure_saves_only_after_codex_verification(self) -> None:
        self.install_bootstrap()
        invocation_log = self.temp_dir / "codex-invocations.jsonl"
        self.make_fake_cli(
            "codex",
            version="9.9.9",
            app_server_models=["gpt-5.4-mini"],
            record_invocations_path=invocation_log,
        )

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "analyst=codex:gpt-5.4-mini",
            "--json",
        )
        payload = json.loads(completed.stdout)
        policy = self.load_json(self.policy_path())

        self.assertTrue(payload["saved"])
        self.assertTrue(payload["verification_results"]["analyst"]["verified"])
        self.assertEqual(payload["verification_results"]["analyst"]["transport"], "app-server")
        self.assertEqual(policy["role_routes"]["analyst"]["cli"], "codex")
        self.assertEqual(policy["role_routes"]["analyst"]["model"], "gpt-5.4-mini")
        invocation = json.loads(invocation_log.read_text(encoding="utf-8").splitlines()[0])
        self.assertIn("--skip-git-repo-check", invocation)
        self.assertIn("--ephemeral", invocation)
        self.assertIn("mcp_servers.playwright.enabled=false", invocation)
        self.assertIn('mcp_servers["subframe-docs"].enabled=false', invocation)

    def test_configure_accepts_legacy_role_alias_and_saves_canonical_stage_role(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9", app_server_models=["gpt-5.4-mini"])

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "phase-auditor=codex:gpt-5.4-mini",
            "--json",
        )
        payload = json.loads(completed.stdout)
        policy = self.load_json(self.policy_path())

        self.assertTrue(payload["saved"])
        self.assertIn("analyst", payload["verification_results"])
        self.assertNotIn("phase-auditor", policy["role_routes"])
        self.assertEqual(policy["role_routes"]["analyst"]["cli"], "codex")
        self.assertEqual(policy["role_routes"]["analyst"]["model"], "gpt-5.4-mini")

    def test_configure_does_not_save_when_verification_fails(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("opencode", version="1.3.3", models=["github-copilot/gpt-5.4-mini"], invoke_echo=False)

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "planner=opencode:github-copilot/gpt-5.4-mini",
            "--json",
            allowed_returncodes=(1,),
        )
        payload = json.loads(completed.stdout)
        policy = self.load_json(self.policy_path())

        self.assertFalse(payload["saved"])
        self.assertFalse(payload["verification_results"]["planner"]["verified"])
        self.assertIsNone(policy["role_routes"]["planner"]["cli"])
        self.assertIsNone(policy["role_routes"]["planner"]["model"])

    def test_configure_verifies_opencode_with_structured_ping(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli(
            "opencode",
            version="1.3.3",
            models=["github-copilot/gpt-5.4-mini"],
            require_structured_run=True,
        )

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "memory-auditor=opencode:github-copilot/gpt-5.4-mini",
            "--json",
        )
        payload = json.loads(completed.stdout)
        policy = self.load_json(self.policy_path())

        self.assertTrue(payload["saved"])
        self.assertTrue(payload["verification_results"]["memory-auditor"]["verified"])
        self.assertEqual(policy["role_routes"]["memory-auditor"]["cli"], "opencode")
        self.assertEqual(policy["role_routes"]["memory-auditor"]["model"], "github-copilot/gpt-5.4-mini")

    def test_configure_reuses_verification_for_duplicate_cli_model_pairs(self) -> None:
        self.install_bootstrap()
        invocation_log = self.temp_dir / "opencode-invocations.jsonl"
        self.make_fake_cli(
            "opencode",
            version="1.3.3",
            models=["github-copilot/gpt-5.4-mini"],
            require_structured_run=True,
            record_invocations_path=invocation_log,
        )

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "memory-auditor=opencode:github-copilot/gpt-5.4-mini",
            "--set",
            "tester=opencode:github-copilot/gpt-5.4-mini",
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertTrue(payload["saved"])
        lines = invocation_log.read_text(encoding="utf-8").splitlines()
        self.assertEqual(len(lines), 1)

    def test_configure_verifies_kimi_alias_before_save(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("kimi", version="1.32.0")
        self.write_home_file(
            ".kimi/config.toml",
            """
default_model = "kimi-code/kimi-for-coding"

[models."kimi-code/kimi-for-coding"]
provider = "managed:kimi-code"
model = "kimi-for-coding"
""",
        )

        completed = self.run_repo_script(
            "recursive-router-configure.py",
            "--repo-root",
            str(self.repo_root),
            "--set",
            "code-reviewer=kimi:kimi-code/kimi-for-coding",
            "--json",
        )
        payload = json.loads(completed.stdout)
        policy = self.load_json(self.policy_path())

        self.assertTrue(payload["saved"])
        self.assertTrue(payload["verification_results"]["code-reviewer"]["verified"])
        self.assertEqual(policy["role_routes"]["code-reviewer"]["model"], "kimi-code/kimi-for-coding")

    def test_invoke_dispatches_prompt_bundle_through_kimi_stream_json(self) -> None:
        self.install_bootstrap()
        invocation_log = self.temp_dir / "kimi-invocations.jsonl"
        self.make_fake_cli("kimi", version="1.32.0", record_invocations_path=invocation_log)
        self.write_home_file(
            ".kimi/config.toml",
            """
default_model = "kimi-code/kimi-for-coding"

[models."kimi-code/kimi-for-coding"]
provider = "managed:kimi-code"
model = "kimi-for-coding"
""",
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["tester"]["cli"] = "kimi"
        policy["role_routes"]["tester"]["model"] = "kimi-code/kimi-for-coding"
        self.write_policy(policy)

        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "tester.txt"
        prompt_text = "Review Phase 4 evidence and return only the tester verdict."
        write_text(prompt_path, prompt_text)

        completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "tester",
            "--prompt-file",
            str(prompt_path),
            "--json",
        )
        payload = json.loads(completed.stdout)
        invocation_args = json.loads(invocation_log.read_text(encoding="utf-8").splitlines()[0])

        self.assertTrue(payload["success"])
        self.assertEqual(payload["cli"], "kimi")
        self.assertEqual(payload["output_text"], prompt_text)
        self.assertIn("<choice>STOP</choice>", payload["raw_stdout"])
        self.assertIn("--work-dir", invocation_args)
        self.assertEqual(invocation_args[invocation_args.index("--work-dir") + 1], str(self.repo_root))
        self.assertIn("--output-format", invocation_args)
        self.assertEqual(invocation_args[invocation_args.index("--output-format") + 1], "stream-json")
        self.assertIn("--max-ralph-iterations", invocation_args)
        self.assertEqual(invocation_args[invocation_args.index("--max-ralph-iterations") + 1], "0")
        self.assertNotIn("--final-message-only", invocation_args)

    def test_invoke_marks_kimi_nonzero_exit_unsuccessful_even_with_output(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli(
            "kimi",
            version="1.32.0",
            invoke_exit=1,
            emit_output_before_failure=True,
        )
        self.write_home_file(
            ".kimi/config.toml",
            """
default_model = "kimi-code/kimi-for-coding"

[models."kimi-code/kimi-for-coding"]
provider = "managed:kimi-code"
model = "kimi-for-coding"
""",
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["tester"]["cli"] = "kimi"
        policy["role_routes"]["tester"]["model"] = "kimi-code/kimi-for-coding"
        self.write_policy(policy)

        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "tester.txt"
        prompt_text = "Return TESTER_VERDICT: PASS."
        write_text(prompt_path, prompt_text)

        completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "tester",
            "--prompt-file",
            str(prompt_path),
            "--json",
            allowed_returncodes=(1,),
        )
        payload = json.loads(completed.stdout)

        self.assertFalse(payload["success"])
        self.assertEqual(payload["exit_code"], 1)
        self.assertEqual(payload["output_text"], prompt_text)
        self.assertIn("exit code 1", payload["reason"])

    def test_invoke_dispatches_prompt_bundle_through_opencode_route(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli(
            "opencode",
            version="1.3.3",
            models=["github-copilot/gpt-5.4-mini"],
            require_structured_run=True,
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["planner"]["cli"] = "opencode"
        policy["role_routes"]["planner"]["model"] = "github-copilot/gpt-5.4-mini"
        self.write_policy(policy)

        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "planner.txt"
        output_path = self.repo_root / ".recursive" / "run" / "run-123" / "evidence" / "router" / "planner.md"
        metadata_path = self.repo_root / ".recursive" / "run" / "run-123" / "evidence" / "router" / "planner.json"
        prompt_text = "## Covered\n- benchmark/00-requirements.md\n- src/App.tsx"
        write_text(prompt_path, prompt_text)

        completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "planner",
            "--prompt-file",
            str(prompt_path),
            "--output-file",
            str(output_path),
            "--metadata-file",
            str(metadata_path),
            "--json",
        )
        payload = json.loads(completed.stdout)
        metadata = self.load_json(metadata_path)

        self.assertTrue(payload["success"])
        self.assertEqual(payload["decision"]["decision"], "external-cli")
        self.assertEqual(payload["cli"], "opencode")
        self.assertEqual(payload["output_text"], prompt_text)
        self.assertEqual(payload["prompt_bundle_path"], "/.recursive/run/run-123/router-prompts/planner.txt")
        self.assertEqual(output_path.read_text(encoding="utf-8").strip(), prompt_text)
        self.assertEqual(metadata["cli"], "opencode")
        self.assertEqual(metadata["output_text"], prompt_text)

    def test_invoke_rejects_raw_output_under_subagents_directory(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli(
            "opencode",
            version="1.3.3",
            models=["github-copilot/gpt-5.4-mini"],
            require_structured_run=True,
        )
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["planner"]["cli"] = "opencode"
        policy["role_routes"]["planner"]["model"] = "github-copilot/gpt-5.4-mini"
        self.write_policy(policy)

        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "planner.txt"
        raw_output_path = self.repo_root / ".recursive" / "run" / "run-123" / "subagents" / "raw-kimi.md"
        metadata_path = self.repo_root / ".recursive" / "run" / "run-123" / "subagents" / "raw-kimi.json"
        write_text(prompt_path, "Planner prompt")
        raw_output_path.parent.mkdir(parents=True, exist_ok=True)

        output_completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "planner",
            "--prompt-file",
            str(prompt_path),
            "--output-file",
            str(raw_output_path),
            "--json",
            allowed_returncodes=(1,),
        )
        metadata_completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "planner",
            "--prompt-file",
            str(prompt_path),
            "--metadata-file",
            str(metadata_path),
            "--json",
            allowed_returncodes=(1,),
        )

        self.assertIn("not under subagents", output_completed.stdout + output_completed.stderr)
        self.assertIn("not under subagents", metadata_completed.stdout + metadata_completed.stderr)
        self.assertFalse(raw_output_path.exists())
        self.assertFalse(metadata_path.exists())

    def test_invoke_dispatches_prompt_bundle_through_codex_app_server(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="9.9.9", app_server_models=["gpt-5.4-mini"])
        policy = self.load_json(self.policy_path())
        policy["role_routes"]["analyst"]["cli"] = "codex"
        policy["role_routes"]["analyst"]["model"] = "gpt-5.4-mini"
        self.write_policy(policy)

        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "analyst.txt"
        prompt_text = "Review Bundle Path: /.recursive/run/run-123/evidence/review-bundles/analyst.md"
        write_text(prompt_path, prompt_text)

        completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--prompt-file",
            str(prompt_path),
            "--json",
        )
        payload = json.loads(completed.stdout)

        self.assertTrue(payload["success"])
        self.assertEqual(payload["cli"], "codex")
        self.assertEqual(payload["transport"], "app-server")
        self.assertEqual(payload["output_text"], prompt_text)

    def test_invoke_fails_when_route_is_not_external_cli(self) -> None:
        self.install_bootstrap()
        self.make_fake_cli("codex", version="1.0.0")
        prompt_path = self.repo_root / ".recursive" / "run" / "run-123" / "router-prompts" / "analyst.txt"
        write_text(prompt_path, "Prompt bundle that should not be dispatched.")

        completed = self.run_repo_script(
            "recursive-router-invoke.py",
            "--repo-root",
            str(self.repo_root),
            "--role",
            "analyst",
            "--prompt-file",
            str(prompt_path),
            "--json",
            allowed_returncodes=(1,),
        )
        payload = json.loads(completed.stdout)

        self.assertFalse(payload["success"])
        self.assertEqual(payload["decision"]["decision"], "ask-user")
        self.assertIn("analyst", payload["decision"]["prompt"])


if __name__ == "__main__":
    unittest.main()
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 467kUpdated Claude CodeCodexVerifiedInstall
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 467kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 319kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 319kUpdated Claude CodeCodexVerifiedInstall