paircode 0.8.1__tar.gz → 0.10.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.8.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
@@ -36,15 +36,18 @@ Description-Content-Type: text/markdown
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude Code (global slash command)
+paircode install            # registers /paircode in every detected LLM CLI
 ```
 
-After install, open Claude Code in any project and `/paircode` is available.
+After install, `/paircode` is available in all three:
 
-> **Note**: codex and gemini don't have a slash-command registration system
-> we can target, so `paircode install` is a no-op for them. From codex or
-> gemini, invoke paircode from your shell: `paircode status`, `paircode drive "..."`
-> etc. (or wrapped: `codex exec 'paircode status'`).
+| CLI | File installed |
+|---|---|
+| Claude Code | `~/.claude/commands/paircode.md` |
+| Codex CLI | `~/.codex/prompts/paircode.md` |
+| Gemini CLI | `~/.gemini/commands/paircode.toml` |
+
+Open any of them and type `/paircode`. In Gemini, you may need `/commands reload` the first time.
 
 As of v0.8.0, paircode delegates all CLI invocation to [`cliworker`](https://pypi.org/project/cliworker/) — one place to own
 the speed flags, MCP strip tricks, skip-cache, and subscription-first fallback

{paircode-0.8.1 → paircode-0.10.1}/README.md

@@ -8,15 +8,18 @@
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude Code (global slash command)
+paircode install            # registers /paircode in every detected LLM CLI
 ```
 
-After install, open Claude Code in any project and `/paircode` is available.
+After install, `/paircode` is available in all three:
 
-> **Note**: codex and gemini don't have a slash-command registration system
-> we can target, so `paircode install` is a no-op for them. From codex or
-> gemini, invoke paircode from your shell: `paircode status`, `paircode drive "..."`
-> etc. (or wrapped: `codex exec 'paircode status'`).
+| CLI | File installed |
+|---|---|
+| Claude Code | `~/.claude/commands/paircode.md` |
+| Codex CLI | `~/.codex/prompts/paircode.md` |
+| Gemini CLI | `~/.gemini/commands/paircode.toml` |
+
+Open any of them and type `/paircode`. In Gemini, you may need `/commands reload` the first time.
 
 As of v0.8.0, paircode delegates all CLI invocation to [`cliworker`](https://pypi.org/project/cliworker/) — one place to own
 the speed flags, MCP strip tricks, skip-cache, and subscription-first fallback

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.8.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.8.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.8.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.10.1/src/paircode/templates/codex_slash_command.md

@@ -0,0 +1,24 @@
+---
+description: Run paircode — adversarial journey framework for LLM peer review. Bootstraps .paircode/ if missing, otherwise advances the active focus.
+argument-hint: [SUBCOMMAND or TOPIC]
+---
+
+You have access to the `paircode` CLI. It's a Python tool that orchestrates multi-LLM peer review (research → plan → execute) with file-traces on disk.
+
+Behavior:
+
+1. **Parse the arguments.** Everything after `/paircode` is passed as CLI args. If empty, run `paircode` with no args (it prints status or bootstraps).
+2. **Run the CLI.** Invoke `paircode <args>` via shell. Capture stdout and stderr.
+3. **Relay output to the user.** Show what paircode printed.
+4. **If `paircode` spawns its own LLM subprocesses** (for research/plan/execute stages), it handles that internally — just relay status updates.
+5. **If the user's intent was a topic-level drive** (e.g., `/paircode "build a widget thing"`), invoke `paircode drive "<topic>"`.
+
+Common subcommands:
+- `paircode install` — register /paircode in Claude/Codex/Gemini
+- `paircode status` — summarize .paircode/ state in cwd
+- `paircode handshake` — detect installed LLM CLIs, propose peer roster
+- `paircode focus <name>` — open a new focus
+- `paircode stage {research|plan|execute}` — run one peer-review round
+- `paircode drive "<topic>"` — high-level: open focus, run research → plan → execute
+
+Always show the user what happened. Brief, honest, actionable.

paircode-0.10.1/src/paircode/templates/gemini_slash_command.toml

@@ -0,0 +1,25 @@
+description = "Run paircode — adversarial journey framework for LLM peer review. Bootstraps .paircode/ if missing, otherwise advances the active focus."
+
+prompt = """
+You have access to the `paircode` CLI — a Python tool that orchestrates multi-LLM peer review (research → plan → execute) with file-traces on disk.
+
+Arguments: {{args}}
+
+Behavior:
+
+1. Parse the arguments above. If empty, run `paircode` with no args (it prints status or bootstraps).
+2. Run the CLI: invoke `paircode {{args}}` via shell. Capture stdout and stderr.
+3. Relay output to the user. Show what paircode printed.
+4. If `paircode` spawns its own LLM subprocesses (for research/plan/execute stages), it handles that internally — just relay status updates.
+5. If the user's intent was a topic-level drive (e.g. `/paircode "build a widget thing"`), invoke `paircode drive "<topic>"`.
+
+Common subcommands:
+  paircode install      register /paircode in Claude/Codex/Gemini
+  paircode status       summarize .paircode/ state in cwd
+  paircode handshake    detect installed LLM CLIs, propose peer roster
+  paircode focus <name> open a new focus
+  paircode stage {research|plan|execute}   run one peer-review round
+  paircode drive "<topic>"                  high-level: run research → plan → execute
+
+Always show the user what happened. Brief, honest, actionable.
+"""

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

@@ -191,12 +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_returns_noop_for_codex_not_installed_file(tmp_path, monkeypatch):
-    """Regression of the 'broken codex rules' bug: installer must never write
-    ~/.codex/rules/paircode.rules — that file breaks codex's 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))
@@ -209,15 +226,123 @@ def test_installer_returns_noop_for_codex_not_installed_file(tmp_path, monkeypat
     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"] == "noop"
+    assert actions["codex"] == "installed"
 
-    # File must NOT exist
+    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_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))
+    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()
+    actions = {r.cli_name: r.action for r in results}
+    assert actions["gemini"] == "installed"
+
+    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
+
+
 # ---------------------------------------------------------------------------
 # Init + status dispatch smoke
 # ---------------------------------------------------------------------------

{paircode-0.8.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,34 +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}
-    # claude gets a real install (writes slash command file)
+
     assert actions["claude"] == "installed"
-    # codex and gemini are intentional no-ops as of v0.8 — we stopped writing
-    # broken files to ~/.codex/rules/. Both should report "noop" not "installed".
-    assert actions["codex"] == "noop", (
-        f"codex should be noop (not installed), got {actions['codex']!r}"
-    )
-    assert actions["gemini"] == "noop", (
-        f"gemini should be noop (not installed), got {actions['gemini']!r}"
-    )
-    # Verify claude slash command actually landed on disk
+    assert actions["codex"] == "installed"
+    assert actions["gemini"] == "installed"
+
+    # Claude: file-drop landed on disk
     claude_cmd = fake_home / ".claude" / "commands" / "paircode.md"
     assert claude_cmd.exists()
-    content = claude_cmd.read_text()
-    assert "paircode" in content
-    # And verify we do NOT write a broken codex rules file
-    codex_rules = fake_home / ".codex" / "rules" / "paircode.rules"
-    assert not codex_rules.exists(), (
-        f"paircode should not write {codex_rules} — that file breaks codex's rule loader"
-    )
+    assert "paircode" in claude_cmd.read_text()
+
+    # 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.8.1/src/paircode/installer.py

@@ -1,183 +0,0 @@
-"""Install paircode's slash command into detected LLM CLIs.
-
-Strategy per CLI:
-  - Claude Code: writes ~/.claude/commands/paircode.md as a real slash command.
-    When the user types `/paircode` in any Claude Code session, this file
-    tells Claude to invoke the paircode CLI via bash.
-  - Codex: no file written. Codex doesn't have a user-facing slash-command
-    system. Users invoke `paircode` from their shell or `codex exec paircode ...`.
-    Previous versions wrote `~/.codex/rules/paircode.rules` — that file is
-    Starlark-formatted and our markdown content broke codex's rule loader.
-    `uninstall` still cleans up that legacy path.
-  - Gemini: no file written. Same reasoning — gemini's custom-command story
-    is `gemini skills install` with a git-repo source, not a markdown drop.
-    That's a v0.9+ stretch goal. For now, gemini users invoke paircode from
-    the shell.
-"""
-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"
-    template = _read_template("claude_slash_command.md")
-    target.write_text(template, encoding="utf-8")
-    return InstallResult(
-        cli_name="claude",
-        action="installed",
-        path=target,
-        message=f"Wrote /paircode slash command to {target}. Use it from any Claude Code session.",
-    )
-
-
-def install_codex(info: CliInfo) -> InstallResult:
-    """Codex has no user-facing slash-command system. No-op, print guidance."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="codex",
-            action="skipped",
-            path=None,
-            message=f"codex CLI not on PATH. {info.install_hint}",
-        )
-    return InstallResult(
-        cli_name="codex",
-        action="noop",
-        path=None,
-        message=(
-            "codex has no slash-command system — nothing to install. "
-            "Invoke paircode from your shell (`paircode status`) or via "
-            "`codex exec 'paircode status'` from inside a codex session."
-        ),
-    )
-
-
-def install_gemini(info: CliInfo) -> InstallResult:
-    """Gemini's custom-command story uses `gemini skills install` with a git
-    repo. That's not an easy installer drop — deferred to v0.9+. No-op."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="gemini",
-            action="skipped",
-            path=None,
-            message=f"gemini CLI not on PATH. {info.install_hint}",
-        )
-    return InstallResult(
-        cli_name="gemini",
-        action="noop",
-        path=None,
-        message=(
-            "gemini uses `gemini skills install` for custom commands — "
-            "proper skill-registration lands in v0.9+. For now, invoke "
-            "paircode from your shell or via `gemini -p 'run paircode status'`."
-        ),
-    )
-
-
-# ---------------------------------------------------------------------------
-# 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 that previous versions of paircode installed and which we
-    now know to be broken or misplaced. Silent; best-effort."""
-    for legacy_path in (
-        # v0.1–v0.7 wrote markdown to codex's Starlark rules dir, which broke
-        # codex's rule loader. Always clean this up on any install.
-        Path.home() / ".codex" / "rules" / "paircode.rules",
-        # v0.1–v0.7 also dropped a reference file at ~/.gemini/paircode.md.
-        # Harmless but no longer created; remove to keep the dir clean.
-        Path.home() / ".gemini" / "paircode.md",
-    ):
-        try:
-            if legacy_path.exists():
-                legacy_path.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]] = [
-        (Path.home() / ".claude" / "commands" / "paircode.md", "claude"),
-        # Legacy paths — older paircode put these here, we still clean them up
-        (Path.home() / ".codex" / "rules" / "paircode.rules", "codex"),
-        (Path.home() / ".gemini" / "paircode.md", "gemini"),
-    ]
-    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