paircode 0.9.1__tar.gz → 0.10.1__tar.gz

{paircode-0.9.1 → paircode-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.9.1
+Version: 0.10.1
 Summary: Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review.
 Project-URL: Homepage, https://github.com/starshipagentic/paircode
 Project-URL: Repository, https://github.com/starshipagentic/paircode
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
-Requires-Dist: cliworker>=0.7.1
+Requires-Dist: cliworker>=0.8.1
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
 Description-Content-Type: text/markdown

{paircode-0.9.1 → paircode-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.9.1"
+version = "0.10.1"
 description = "Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review."
 readme = "README.md"
 license = { text = "MIT" }
@@ -39,7 +39,7 @@ dependencies = [
     "click>=8.1",
     "pyyaml>=6.0",
     "rich>=13.0",
-    "cliworker>=0.7.1",
+    "cliworker>=0.8.1",
 ]
 
 [project.urls]

{paircode-0.9.1 → paircode-0.10.1}/src/paircode/__init__.py

@@ -2,4 +2,4 @@
 
 See README.md and diary/001-step-a-architecture.md for the full design.
 """
-__version__ = "0.9.0"
+__version__ = "0.10.0"

paircode-0.10.1/src/paircode/installer.py

@@ -0,0 +1,322 @@
+"""Install paircode's slash command into detected LLM CLIs.
+
+Strategy per CLI:
+  - Claude Code: file-drop ~/.claude/commands/paircode.md
+                 Claude's native plugin-install requires publishing a marketplace;
+                 overkill for one command. File-drop is first-class + documented.
+  - Codex CLI:   native register via `codex marketplace add starshipagentic/paircode-codex`
+                 (git-clones the satellite repo into ~/.codex/.tmp/marketplaces/).
+                 Satellite contains .agents/plugins/marketplace.json + plugin manifest +
+                 commands/paircode.md. Replaces the v0.9 file-drop at ~/.codex/prompts/.
+  - Gemini CLI:  native register via `gemini extensions install https://github.com/starshipagentic/paircode-gemini --consent`
+                 Git-clones the satellite repo into ~/.gemini/extensions/paircode/.
+                 Satellite contains gemini-extension.json + commands/paircode.toml.
+                 Replaces the v0.9 file-drop at ~/.gemini/commands/.
+
+Native-register subprocess calls go through `cliworker.invoke()` — no LLM semantics,
+stdin=DEVNULL for fail-fast on unexpected prompts, capture stderr for fallback
+messaging.
+
+Also cleans up legacy files from pre-v0.10 paircode versions on every install.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+
+from cliworker import invoke
+
+from paircode.detect import detect_all, CliInfo
+
+
+# Satellite repo coordinates — update here when repos move.
+CODEX_MARKETPLACE = "starshipagentic/paircode-codex"
+GEMINI_EXTENSION_URL = "https://github.com/starshipagentic/paircode-gemini"
+
+# Per-CLI timeouts for the native install commands (git clones + setup).
+NATIVE_INSTALL_TIMEOUT_S = 90
+
+
+@dataclass(frozen=True)
+class InstallResult:
+    cli_name: str
+    action: str  # "installed", "skipped", "failed", "noop", "already"
+    path: Path | None
+    message: str
+
+
+def _read_template(name: str) -> str:
+    return resources.files("paircode.templates").joinpath(name).read_text(encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Per-CLI installers
+# ---------------------------------------------------------------------------
+
+def install_claude(info: CliInfo) -> InstallResult:
+    """Write ~/.claude/commands/paircode.md — file-drop (native for Claude Code)."""
+    if not info.installed:
+        return InstallResult(
+            cli_name="claude", action="skipped", path=None,
+            message=f"claude CLI not on PATH. {info.install_hint}",
+        )
+    commands_dir = info.config_dir / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    target = commands_dir / "paircode.md"
+    target.write_text(_read_template("claude_slash_command.md"), encoding="utf-8")
+    return InstallResult(
+        cli_name="claude", action="installed", path=target,
+        message=f"Wrote /paircode slash command to {target}.",
+    )
+
+
+def _codex_already_installed() -> bool:
+    """Idempotency check: is the paircode marketplace already registered?"""
+    config = Path.home() / ".codex" / "config.toml"
+    if not config.exists():
+        return False
+    try:
+        text = config.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return False
+    return "[marketplaces.paircode]" in text or "paircode-codex" in text
+
+
+def install_codex(info: CliInfo) -> InstallResult:
+    """Native register via `codex marketplace add starshipagentic/paircode-codex`."""
+    if not info.installed:
+        return InstallResult(
+            cli_name="codex", action="skipped", path=None,
+            message=f"codex CLI not on PATH. {info.install_hint}",
+        )
+
+    if _codex_already_installed():
+        return InstallResult(
+            cli_name="codex", action="already", path=None,
+            message="paircode already registered with codex. Skip.",
+        )
+
+    result = invoke(
+        "codex", "marketplace", "add", CODEX_MARKETPLACE,
+        timeout_s=NATIVE_INSTALL_TIMEOUT_S,
+    )
+    if result.ok:
+        return InstallResult(
+            cli_name="codex", action="installed", path=None,
+            message=f"Ran: codex marketplace add {CODEX_MARKETPLACE}",
+        )
+    return InstallResult(
+        cli_name="codex", action="failed", path=None,
+        message=(
+            f"codex marketplace add failed. Run yourself:\n"
+            f"  codex marketplace add {CODEX_MARKETPLACE}\n"
+            f"stderr: {result.stderr.strip()[:200]}"
+        ),
+    )
+
+
+def _gemini_already_installed() -> bool:
+    """Idempotency check: is the paircode extension already installed?"""
+    result = invoke("gemini", "extensions", "list", timeout_s=15)
+    if not result.ok:
+        return False
+    return "paircode-gemini" in result.stdout or "paircode (" in result.stdout
+
+
+def install_gemini(info: CliInfo) -> InstallResult:
+    """Native register via `gemini extensions install <url> --consent`."""
+    if not info.installed:
+        return InstallResult(
+            cli_name="gemini", action="skipped", path=None,
+            message=f"gemini CLI not on PATH. {info.install_hint}",
+        )
+
+    if _gemini_already_installed():
+        return InstallResult(
+            cli_name="gemini", action="already", path=None,
+            message="paircode already installed as gemini extension. Skip.",
+        )
+
+    result = invoke(
+        "gemini", "extensions", "install", GEMINI_EXTENSION_URL, "--consent",
+        timeout_s=NATIVE_INSTALL_TIMEOUT_S,
+    )
+    if result.ok:
+        return InstallResult(
+            cli_name="gemini", action="installed", path=None,
+            message=(
+                f"Ran: gemini extensions install {GEMINI_EXTENSION_URL} --consent. "
+                "Inside gemini, run `/commands reload` (or restart) to pick up /paircode."
+            ),
+        )
+    return InstallResult(
+        cli_name="gemini", action="failed", path=None,
+        message=(
+            f"gemini extensions install failed. Run yourself:\n"
+            f"  gemini extensions install {GEMINI_EXTENSION_URL} --consent\n"
+            f"stderr: {result.stderr.strip()[:200]}"
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Public entry points
+# ---------------------------------------------------------------------------
+
+def install_all() -> list[InstallResult]:
+    """Run every CLI's installer. Also cleans up legacy paths first."""
+    _clean_legacy_paths()
+    detected = detect_all()
+    installers = {
+        "claude": install_claude,
+        "codex": install_codex,
+        "gemini": install_gemini,
+    }
+    results: list[InstallResult] = []
+    for name, info in detected.items():
+        installer = installers.get(name)
+        if not installer:
+            continue
+        try:
+            results.append(installer(info))
+        except Exception as exc:  # pragma: no cover — defensive
+            results.append(InstallResult(
+                cli_name=name, action="failed", path=None,
+                message=f"{type(exc).__name__}: {exc}",
+            ))
+    return results
+
+
+def _clean_legacy_paths() -> None:
+    """Remove files that prior paircode versions installed and which we now
+    know to be broken, misplaced, or replaced by native-register flows."""
+    legacy_files = (
+        # v0.1–v0.7: wrote markdown to codex's Starlark rules dir → broke codex.
+        Path.home() / ".codex" / "rules" / "paircode.rules",
+        # v0.8: wrote a reference file at ~/.gemini/paircode.md (harmless but obsolete).
+        Path.home() / ".gemini" / "paircode.md",
+        # v0.9: wrote file-drop slash commands at these paths. v0.10+ uses native register.
+        Path.home() / ".codex" / "prompts" / "paircode.md",
+        Path.home() / ".gemini" / "commands" / "paircode.toml",
+    )
+    for path in legacy_files:
+        try:
+            if path.exists() and path.is_file():
+                path.unlink()
+        except OSError:
+            pass
+
+
+def uninstall_all() -> list[InstallResult]:
+    """Remove paircode from every CLI. Uses native uninstall where available,
+    file-drop removal where not."""
+    results: list[InstallResult] = []
+
+    # Claude — file-drop, just remove the file.
+    claude_cmd = Path.home() / ".claude" / "commands" / "paircode.md"
+    if claude_cmd.exists():
+        try:
+            claude_cmd.unlink()
+            results.append(InstallResult(
+                cli_name="claude", action="installed",
+                path=claude_cmd, message=f"Removed {claude_cmd}",
+            ))
+        except OSError as exc:
+            results.append(InstallResult(
+                cli_name="claude", action="failed",
+                path=claude_cmd, message=f"Failed to remove {claude_cmd}: {exc}",
+            ))
+    else:
+        results.append(InstallResult(
+            cli_name="claude", action="skipped",
+            path=claude_cmd, message=f"Nothing to remove at {claude_cmd}",
+        ))
+
+    # Codex — no native remove command. Strip the marketplace stanza from config.toml
+    # and rm -rf the cache dir. Fragile but the only option until codex adds a CLI.
+    config = Path.home() / ".codex" / "config.toml"
+    cache_dir = Path.home() / ".codex" / ".tmp" / "marketplaces" / "paircode"
+    removed_codex = False
+    if config.exists():
+        try:
+            text = config.read_text(encoding="utf-8")
+            # Strip the [marketplaces.paircode] section and its key/value lines.
+            new_text = _strip_toml_section(text, "marketplaces.paircode")
+            new_text = _strip_toml_section(new_text, 'plugins."paircode@paircode"')
+            if new_text != text:
+                config.write_text(new_text, encoding="utf-8")
+                removed_codex = True
+        except OSError as exc:
+            results.append(InstallResult(
+                cli_name="codex", action="failed", path=config,
+                message=f"Failed to edit {config}: {exc}",
+            ))
+    if cache_dir.exists():
+        import shutil as _sh
+        try:
+            _sh.rmtree(cache_dir)
+            removed_codex = True
+        except OSError:
+            pass
+    if removed_codex:
+        results.append(InstallResult(
+            cli_name="codex", action="installed", path=None,
+            message="Removed paircode marketplace from ~/.codex/config.toml + cache.",
+        ))
+    else:
+        results.append(InstallResult(
+            cli_name="codex", action="skipped", path=None,
+            message="No paircode marketplace registered with codex.",
+        ))
+
+    # Gemini — native uninstall command exists.
+    result = invoke("gemini", "extensions", "uninstall", "paircode", timeout_s=30)
+    if result.ok:
+        results.append(InstallResult(
+            cli_name="gemini", action="installed", path=None,
+            message="Ran: gemini extensions uninstall paircode",
+        ))
+    else:
+        # May fail if not installed; treat as skipped when stderr mentions that
+        if "not installed" in result.stderr.lower() or "no extension" in result.stderr.lower():
+            results.append(InstallResult(
+                cli_name="gemini", action="skipped", path=None,
+                message="paircode gemini extension not installed; nothing to remove.",
+            ))
+        else:
+            results.append(InstallResult(
+                cli_name="gemini", action="failed", path=None,
+                message=(
+                    f"gemini extensions uninstall failed. Run yourself:\n"
+                    f"  gemini extensions uninstall paircode\n"
+                    f"stderr: {result.stderr.strip()[:200]}"
+                ),
+            ))
+
+    # Legacy cleanup (same as install_all)
+    _clean_legacy_paths()
+
+    return results
+
+
+def _strip_toml_section(text: str, section_name: str) -> str:
+    """Remove `[section_name]` and its following key/value lines from a TOML string.
+
+    Returns the modified text. A section ends at the next `[...]` header or EOF.
+    No-op if the section isn't present.
+    """
+    lines = text.splitlines(keepends=True)
+    out: list[str] = []
+    skipping = False
+    target = f"[{section_name}]"
+    for line in lines:
+        stripped = line.strip()
+        if stripped == target:
+            skipping = True
+            continue
+        if skipping and stripped.startswith("[") and stripped.endswith("]"):
+            skipping = False  # new section started
+        if not skipping:
+            out.append(line)
+    return "".join(out)

{paircode-0.9.1 → paircode-0.10.1}/tests/test_cli_smoke.py

@@ -191,13 +191,29 @@ def test_run_peer_fast_kwarg_passes_through(monkeypatch, tmp_path):
 
 
 # ---------------------------------------------------------------------------
-# Installer: codex no-op + legacy cleanup
+# Installer: native-register for codex + gemini via cliworker.invoke()
 # ---------------------------------------------------------------------------
 
-def test_installer_writes_codex_prompt_never_broken_rules_file(tmp_path, monkeypatch):
-    """Regression of the 'broken codex rules' bug: installer must write to
-    ~/.codex/prompts/paircode.md (the correct path) and NEVER to
-    ~/.codex/rules/paircode.rules (that breaks codex's Starlark rule loader)."""
+def _fake_cliworker_invoke_success(captured):
+    """Return a fake invoke that captures calls and always succeeds."""
+    from cliworker.core import CLIResult
+    from cliworker.registry import CLISpec
+
+    def fake(cli, *args, **kwargs):
+        captured.append((cli, args))
+        stdout = ""
+        # Simulate empty list output for gemini extensions list (idempotency check)
+        return CLIResult(
+            spec=CLISpec(cli=cli), ok=True, stdout=stdout, stderr="",
+            duration_s=0.01, returncode=0, argv=[cli, *args], skipped_reason=None,
+        )
+
+    return fake
+
+
+def test_installer_codex_calls_marketplace_add_via_invoke(tmp_path, monkeypatch):
+    """paircode v0.10 delegates codex install to cliworker.invoke()
+    running `codex marketplace add starshipagentic/paircode-codex`."""
     fake_home = tmp_path / "home"
     fake_home.mkdir()
     monkeypatch.setenv("HOME", str(fake_home))
@@ -210,17 +226,25 @@ def test_installer_writes_codex_prompt_never_broken_rules_file(tmp_path, monkeyp
     importlib.reload(inst)
 
     monkeypatch.setattr("shutil.which", lambda b: f"/fake/{b}")
-    results = inst.install_all()
+    captured: list[tuple] = []
+    monkeypatch.setattr("paircode.installer.invoke", _fake_cliworker_invoke_success(captured))
 
+    results = inst.install_all()
     actions = {r.cli_name: r.action for r in results}
     assert actions["codex"] == "installed"
-    assert (fake_home / ".codex" / "prompts" / "paircode.md").exists()
+
+    codex_calls = [c for c in captured if c[0] == "codex"]
+    assert any(
+        c[1] == ("marketplace", "add", "starshipagentic/paircode-codex")
+        for c in codex_calls
+    ), f"expected `codex marketplace add starshipagentic/paircode-codex`, got {codex_calls}"
+
+    # Never writes the broken legacy rules file
     assert not (fake_home / ".codex" / "rules" / "paircode.rules").exists()
 
 
-def test_installer_writes_gemini_toml_command(tmp_path, monkeypatch):
-    """Gemini slash commands are TOML (not markdown). Path must be
-    ~/.gemini/commands/paircode.toml with description + prompt fields."""
+def test_installer_gemini_calls_extensions_install_via_invoke(tmp_path, monkeypatch):
+    """paircode v0.10 runs `gemini extensions install <url> --consent`."""
     fake_home = tmp_path / "home"
     fake_home.mkdir()
     monkeypatch.setenv("HOME", str(fake_home))
@@ -233,17 +257,90 @@ def test_installer_writes_gemini_toml_command(tmp_path, monkeypatch):
     importlib.reload(inst)
 
     monkeypatch.setattr("shutil.which", lambda b: f"/fake/{b}")
-    results = inst.install_all()
+    captured: list[tuple] = []
+    monkeypatch.setattr("paircode.installer.invoke", _fake_cliworker_invoke_success(captured))
 
+    results = inst.install_all()
     actions = {r.cli_name: r.action for r in results}
     assert actions["gemini"] == "installed"
-    target = fake_home / ".gemini" / "commands" / "paircode.toml"
-    assert target.exists()
-    content = target.read_text()
-    assert 'description' in content
-    assert 'prompt' in content
-    # TOML syntax sanity — triple-quoted prompt
-    assert '"""' in content
+
+    gemini_installs = [
+        c for c in captured
+        if c[0] == "gemini" and c[1][0:2] == ("extensions", "install") and "--consent" in c[1]
+    ]
+    assert gemini_installs, f"expected gemini extensions install --consent; got {captured}"
+
+
+def test_installer_codex_idempotent_when_already_registered(tmp_path, monkeypatch):
+    """If the codex marketplace is already registered, install returns 'already'
+    without re-invoking `codex marketplace add`."""
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    (fake_home / ".codex").mkdir()
+    (fake_home / ".codex" / "config.toml").write_text(
+        '[marketplaces.paircode]\nsource = "https://github.com/starshipagentic/paircode-codex.git"\n'
+    )
+    monkeypatch.setenv("HOME", str(fake_home))
+    import importlib
+
+    import paircode.detect as d
+    import paircode.installer as inst
+
+    importlib.reload(d)
+    importlib.reload(inst)
+
+    monkeypatch.setattr("shutil.which", lambda b: f"/fake/{b}")
+    captured: list[tuple] = []
+    monkeypatch.setattr("paircode.installer.invoke", _fake_cliworker_invoke_success(captured))
+
+    results = inst.install_all()
+    codex_result = next(r for r in results if r.cli_name == "codex")
+    assert codex_result.action == "already", (
+        f"expected action='already'; got {codex_result.action!r} — {codex_result.message}"
+    )
+
+    # Marketplace-add must NOT have been invoked on codex
+    codex_add_calls = [c for c in captured if c[0] == "codex" and "marketplace" in c[1]]
+    assert not codex_add_calls, f"should not re-invoke marketplace add; got {codex_add_calls}"
+
+
+def test_installer_fails_gracefully_with_actionable_message(tmp_path, monkeypatch):
+    """When invoke() returns .ok=False, installer surfaces the command to run
+    manually (copy-paste friendly)."""
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setenv("HOME", str(fake_home))
+    import importlib
+
+    import paircode.detect as d
+    import paircode.installer as inst
+
+    importlib.reload(d)
+    importlib.reload(inst)
+
+    monkeypatch.setattr("shutil.which", lambda b: f"/fake/{b}")
+
+    def failing_invoke(cli, *args, **kwargs):
+        from cliworker.core import CLIResult
+        from cliworker.registry import CLISpec
+
+        return CLIResult(
+            spec=CLISpec(cli=cli), ok=False, stdout="", stderr="simulated failure",
+            duration_s=0.01, returncode=1, argv=[cli, *args], skipped_reason=None,
+        )
+
+    monkeypatch.setattr("paircode.installer.invoke", failing_invoke)
+
+    results = inst.install_all()
+
+    codex_r = next(r for r in results if r.cli_name == "codex")
+    assert codex_r.action == "failed"
+    assert "codex marketplace add starshipagentic/paircode-codex" in codex_r.message
+
+    gemini_r = next(r for r in results if r.cli_name == "gemini")
+    assert gemini_r.action == "failed"
+    assert "gemini extensions install" in gemini_r.message
+    assert "--consent" in gemini_r.message
 
 
 # ---------------------------------------------------------------------------

{paircode-0.9.1 → paircode-0.10.1}/tests/test_smoke.py

@@ -54,12 +54,13 @@ def test_handshake_shows_table(tmp_path, monkeypatch):
         assert name in result.output
 
 
-def test_install_writes_to_tmp_claude(tmp_path, monkeypatch):
-    """Redirect ~/.claude to a tmp dir and verify install writes the slash command."""
+def test_install_writes_claude_and_invokes_native_register(tmp_path, monkeypatch):
+    """v0.10: claude is file-drop, codex + gemini use native-register via
+    cliworker.invoke(). Verify the right file lands AND the right subprocess
+    commands get called."""
     fake_home = tmp_path / "home"
     fake_home.mkdir()
     monkeypatch.setenv("HOME", str(fake_home))
-    # Re-import so Path.home() resolves to the new HOME
     import importlib
 
     import paircode.detect as d
@@ -68,43 +69,62 @@ def test_install_writes_to_tmp_claude(tmp_path, monkeypatch):
     importlib.reload(d)
     importlib.reload(inst)
 
-    # Force all three CLIs "installed" by monkeypatching shutil.which
     def fake_which(binary):
         return f"/fake/bin/{binary}"
 
     monkeypatch.setattr("shutil.which", fake_which)
 
+    # Capture invoke() calls — codex + gemini installs go through it
+    invoked: list[tuple] = []
+
+    def fake_invoke(cli, *args, **kwargs):
+        from cliworker.core import CLIResult
+        from cliworker.registry import CLISpec
+
+        invoked.append((cli, args))
+        # For idempotency check calls (gemini extensions list): return empty stdout
+        # so it's "not installed" and the real install runs.
+        if args and args[0] == "extensions" and "list" in args:
+            return CLIResult(
+                spec=CLISpec(cli=cli), ok=True, stdout="", stderr="",
+                duration_s=0.01, returncode=0, argv=[cli, *args], skipped_reason=None,
+            )
+        # For actual install calls, succeed.
+        return CLIResult(
+            spec=CLISpec(cli=cli), ok=True, stdout="installed", stderr="",
+            duration_s=0.1, returncode=0, argv=[cli, *args], skipped_reason=None,
+        )
+
+    monkeypatch.setattr("paircode.installer.invoke", fake_invoke)
+
     results = inst.install_all()
     actions = {r.cli_name: r.action for r in results}
-    # v0.9: all three CLIs get a real slash command file drop.
+
     assert actions["claude"] == "installed"
     assert actions["codex"] == "installed"
     assert actions["gemini"] == "installed"
 
-    # Correct paths per CLI
+    # Claude: file-drop landed on disk
     claude_cmd = fake_home / ".claude" / "commands" / "paircode.md"
     assert claude_cmd.exists()
     assert "paircode" in claude_cmd.read_text()
 
-    codex_cmd = fake_home / ".codex" / "prompts" / "paircode.md"
-    assert codex_cmd.exists(), (
-        f"v0.9 must write codex slash command to {codex_cmd}"
-    )
-    assert "paircode" in codex_cmd.read_text()
-
-    gemini_cmd = fake_home / ".gemini" / "commands" / "paircode.toml"
-    assert gemini_cmd.exists(), (
-        f"v0.9 must write gemini slash command to {gemini_cmd} (note: TOML, not markdown)"
-    )
-    gemini_content = gemini_cmd.read_text()
-    assert "description" in gemini_content
-    assert "prompt" in gemini_content
-
-    # And verify we still do NOT write the legacy broken codex rules file
-    codex_rules = fake_home / ".codex" / "rules" / "paircode.rules"
-    assert not codex_rules.exists(), (
-        f"paircode must never write {codex_rules} — that file breaks codex's rule loader"
-    )
+    # Codex: the invoke() call ran `codex marketplace add starshipagentic/paircode-codex`
+    codex_calls = [c for c in invoked if c[0] == "codex"]
+    assert any(
+        c[1] == ("marketplace", "add", "starshipagentic/paircode-codex")
+        for c in codex_calls
+    ), f"Expected codex marketplace add call; got {codex_calls}"
+
+    # Gemini: the invoke() call ran `gemini extensions install <url> --consent`
+    gemini_install = [
+        c for c in invoked
+        if c[0] == "gemini" and "install" in c[1] and "--consent" in c[1]
+    ]
+    assert gemini_install, f"Expected gemini extensions install --consent; got {invoked}"
+
+    # We do NOT write the legacy broken codex rules file
+    assert not (fake_home / ".codex" / "rules" / "paircode.rules").exists()
 
 
 def test_install_cleans_legacy_codex_rules_file(tmp_path, monkeypatch):

paircode-0.9.1/src/paircode/installer.py

@@ -1,188 +0,0 @@
-"""Install paircode's slash command into detected LLM CLIs.
-
-Strategy per CLI (all file-drop; see v1.0 roadmap for native register migration):
-  - Claude Code: ~/.claude/commands/paircode.md (Markdown + YAML frontmatter).
-                 First-class documented path.
-  - Codex CLI:   ~/.codex/prompts/paircode.md (Markdown + YAML frontmatter).
-                 Path marked "deprecated" by OpenAI (they're steering toward
-                 marketplaces), but still loads and remains the only file-drop
-                 path for user-typed slash commands in codex.
-  - Gemini CLI:  ~/.gemini/commands/paircode.toml (TOML with description + prompt).
-                 First-class, first-party format. Not Markdown.
-
-Also cleans up legacy broken files from paircode 0.1–0.7 which wrote
-~/.codex/rules/paircode.rules (that file is Starlark-parsed and our markdown
-broke codex's rule loader).
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from importlib import resources
-from pathlib import Path
-
-from paircode.detect import detect_all, CliInfo
-
-
-@dataclass(frozen=True)
-class InstallResult:
-    cli_name: str
-    action: str  # "installed", "skipped", "failed", "noop"
-    path: Path | None
-    message: str
-
-
-def _read_template(name: str) -> str:
-    return resources.files("paircode.templates").joinpath(name).read_text(encoding="utf-8")
-
-
-# ---------------------------------------------------------------------------
-# Per-CLI installers
-# ---------------------------------------------------------------------------
-
-def install_claude(info: CliInfo) -> InstallResult:
-    """Write ~/.claude/commands/paircode.md — a real Claude Code slash command."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="claude", action="skipped", path=None,
-            message=f"claude CLI not on PATH. {info.install_hint}",
-        )
-    commands_dir = info.config_dir / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
-    target = commands_dir / "paircode.md"
-    target.write_text(_read_template("claude_slash_command.md"), encoding="utf-8")
-    return InstallResult(
-        cli_name="claude", action="installed", path=target,
-        message=f"Wrote /paircode slash command to {target}.",
-    )
-
-
-def install_codex(info: CliInfo) -> InstallResult:
-    """Write ~/.codex/prompts/paircode.md — codex's custom-prompt slash command path.
-
-    Codex flags this path as "deprecated" in favor of marketplace plugins, but
-    it's still the only file-drop path for user-typed slash commands. When
-    codex removes this (they haven't yet), paircode will migrate to
-    `codex marketplace add` with a satellite repo.
-    """
-    if not info.installed:
-        return InstallResult(
-            cli_name="codex", action="skipped", path=None,
-            message=f"codex CLI not on PATH. {info.install_hint}",
-        )
-    prompts_dir = info.config_dir / "prompts"
-    prompts_dir.mkdir(parents=True, exist_ok=True)
-    target = prompts_dir / "paircode.md"
-    target.write_text(_read_template("codex_slash_command.md"), encoding="utf-8")
-    return InstallResult(
-        cli_name="codex", action="installed", path=target,
-        message=f"Wrote /paircode slash command to {target}. Inside codex interactive, /paircode will appear.",
-    )
-
-
-def install_gemini(info: CliInfo) -> InstallResult:
-    """Write ~/.gemini/commands/paircode.toml — gemini's first-class custom command path.
-
-    Gemini uses TOML (not Markdown) with `description` and `prompt` fields.
-    After install, run `/commands reload` inside gemini or restart the session.
-    """
-    if not info.installed:
-        return InstallResult(
-            cli_name="gemini", action="skipped", path=None,
-            message=f"gemini CLI not on PATH. {info.install_hint}",
-        )
-    commands_dir = info.config_dir / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
-    target = commands_dir / "paircode.toml"
-    target.write_text(_read_template("gemini_slash_command.toml"), encoding="utf-8")
-    return InstallResult(
-        cli_name="gemini", action="installed", path=target,
-        message=(
-            f"Wrote /paircode slash command to {target}. "
-            "Run `/commands reload` inside gemini (or restart) to pick it up."
-        ),
-    )
-
-
-# ---------------------------------------------------------------------------
-# Public entry points
-# ---------------------------------------------------------------------------
-
-def install_all() -> list[InstallResult]:
-    """Run every CLI's installer. Also cleans up legacy broken files first."""
-    _clean_legacy_broken_files()
-    detected = detect_all()
-    installers = {
-        "claude": install_claude,
-        "codex": install_codex,
-        "gemini": install_gemini,
-    }
-    results: list[InstallResult] = []
-    for name, info in detected.items():
-        installer = installers.get(name)
-        if not installer:
-            continue
-        try:
-            results.append(installer(info))
-        except Exception as exc:  # pragma: no cover — defensive
-            results.append(InstallResult(
-                cli_name=name, action="failed", path=None,
-                message=f"{type(exc).__name__}: {exc}",
-            ))
-    return results
-
-
-def _clean_legacy_broken_files() -> None:
-    """Remove files prior paircode versions installed and which we now know
-    to be broken or misplaced. Silent best-effort."""
-    # v0.1–v0.7 wrote markdown to codex's Starlark rules dir, which broke
-    # codex's rule loader on every session startup.
-    legacy = Path.home() / ".codex" / "rules" / "paircode.rules"
-    try:
-        if legacy.exists():
-            legacy.unlink()
-    except OSError:
-        pass
-
-    # v0.1–v0.7 also dropped a reference file at ~/.gemini/paircode.md.
-    # v0.9+ writes the real slash command at ~/.gemini/commands/paircode.toml
-    # instead; clean up the old reference.
-    legacy_gemini = Path.home() / ".gemini" / "paircode.md"
-    try:
-        if legacy_gemini.exists():
-            legacy_gemini.unlink()
-    except OSError:
-        pass
-
-
-def uninstall_all() -> list[InstallResult]:
-    """Remove paircode entries from every CLI config dir (idempotent).
-    Also cleans up legacy broken paths from prior paircode versions."""
-    results: list[InstallResult] = []
-    paths: list[tuple[Path, str]] = [
-        # Current v0.9+ paths
-        (Path.home() / ".claude" / "commands" / "paircode.md", "claude"),
-        (Path.home() / ".codex" / "prompts" / "paircode.md", "codex"),
-        (Path.home() / ".gemini" / "commands" / "paircode.toml", "gemini"),
-        # Legacy paths from older paircode versions
-        (Path.home() / ".codex" / "rules" / "paircode.rules", "codex-legacy"),
-        (Path.home() / ".gemini" / "paircode.md", "gemini-legacy"),
-    ]
-    for path, cli_name in paths:
-        if path.exists():
-            try:
-                path.unlink()
-                results.append(InstallResult(
-                    cli_name=cli_name, action="installed",  # "removed"
-                    path=path, message=f"Removed {path}",
-                ))
-            except OSError as exc:
-                results.append(InstallResult(
-                    cli_name=cli_name, action="failed",
-                    path=path, message=f"Failed to remove {path}: {exc}",
-                ))
-        else:
-            results.append(InstallResult(
-                cli_name=cli_name, action="skipped",
-                path=path, message=f"Nothing to remove at {path}",
-            ))
-    return results