paircode 0.7.1__tar.gz → 0.8.1__tar.gz

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.7.1
+Version: 0.8.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/tsomerville2/paircode
-Project-URL: Repository, https://github.com/tsomerville2/paircode
-Project-URL: Issues, https://github.com/tsomerville2/paircode/issues
+Project-URL: Homepage, https://github.com/starshipagentic/paircode
+Project-URL: Repository, https://github.com/starshipagentic/paircode
+Project-URL: Issues, https://github.com/starshipagentic/paircode/issues
 Author-email: Travis Somerville <travis.somerville@gmail.com>
 License: MIT
 License-File: LICENSE
@@ -21,6 +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: pyyaml>=6.0
 Requires-Dist: rich>=13.0
 Description-Content-Type: text/markdown
@@ -35,10 +36,20 @@ Description-Content-Type: text/markdown
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude / Codex / Gemini
+paircode install            # registers /paircode in Claude Code (global slash command)
 ```
 
-Then open Claude Code, Codex, or Gemini and you'll see `/paircode` available globally.
+After install, open Claude Code in any project and `/paircode` is available.
+
+> **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'`).
+
+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
+logic. paircode adds the peer-review orchestration on top (file-traces, stages,
+gates, journey).
 
 ## Use it — three entry points
 

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

@@ -8,10 +8,20 @@
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude / Codex / Gemini
+paircode install            # registers /paircode in Claude Code (global slash command)
 ```
 
-Then open Claude Code, Codex, or Gemini and you'll see `/paircode` available globally.
+After install, open Claude Code in any project and `/paircode` is available.
+
+> **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'`).
+
+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
+logic. paircode adds the peer-review orchestration on top (file-traces, stages,
+gates, journey).
 
 ## Use it — three entry points
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.7.1"
+version = "0.8.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,12 +39,13 @@ dependencies = [
     "click>=8.1",
     "pyyaml>=6.0",
     "rich>=13.0",
+    "cliworker>=0.7.1",
 ]
 
 [project.urls]
-Homepage = "https://github.com/tsomerville2/paircode"
-Repository = "https://github.com/tsomerville2/paircode"
-Issues = "https://github.com/tsomerville2/paircode/issues"
+Homepage = "https://github.com/starshipagentic/paircode"
+Repository = "https://github.com/starshipagentic/paircode"
+Issues = "https://github.com/starshipagentic/paircode/issues"
 
 [project.scripts]
 paircode = "paircode.cli:main"

{paircode-0.7.1 → paircode-0.8.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.7.0"
+__version__ = "0.8.0"

paircode-0.8.1/src/paircode/installer.py

@@ -0,0 +1,183 @@
+"""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

paircode-0.8.1/src/paircode/runner.py

@@ -0,0 +1,122 @@
+"""Invoke peer LLM CLIs via cliworker, capture output to .md files.
+
+Thin wrapper over `cliworker.run()`. Gives paircode:
+  * CLAUDE_FAST flags when fast=True (claude -p goes from 18s → 4s)
+  * Gemini MCP strip-and-restore during calls
+  * Skip-cache for broken engines (1h TTL)
+  * Subscription-mode-first by default (no API credits unless paid_ok=True)
+  * One place to fix CLI quirks instead of re-implementing them here
+
+Adds one paircode-specific thing cliworker doesn't: writing each peer's
+response to a .md file with a file-trace header (peer_id / cli / model /
+duration / ok). That's the orchestration log paircode needs.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from cliworker import CLIResult, get_spec, run
+
+
+DEFAULT_TIMEOUT_SECONDS = 600  # 10 min per peer call — generous for cold research
+
+
+@dataclass(frozen=True)
+class PeerRunResult:
+    """paircode's peer-run result — wraps cliworker's CLIResult with a peer_id."""
+    peer_id: str
+    cli: str
+    ok: bool
+    stdout: str
+    stderr: str
+    duration_s: float
+    command: list[str]
+
+    @classmethod
+    def from_cli_result(cls, peer_id: str, r: CLIResult) -> "PeerRunResult":
+        return cls(
+            peer_id=peer_id,
+            cli=r.spec.cli,
+            ok=r.ok,
+            stdout=r.stdout,
+            stderr=r.stderr,
+            duration_s=r.duration_s,
+            command=list(r.argv),
+        )
+
+
+def run_peer(
+    peer_id: str,
+    cli: str,
+    prompt: str,
+    output_path: Path,
+    model: Optional[str] = None,
+    timeout_s: int = DEFAULT_TIMEOUT_SECONDS,
+    fast: bool = False,
+    paid_ok: bool | list[str] | None = None,
+) -> PeerRunResult:
+    """Run one peer LLM against `prompt`, write its stdout to `output_path`.
+
+    Delegates to `cliworker.run()` for the actual subprocess call. Adds the
+    paircode-specific file-trace header. Output file is written regardless
+    of success — every invocation leaves a trace on disk.
+
+    Args:
+        peer_id: paircode-level identifier (e.g. "peer-a-codex"). Not known to cliworker.
+        cli: one of "claude", "codex", "gemini", "ollama".
+        prompt: the instruction to send.
+        output_path: where to write the file-trace .md.
+        model: optional model override (e.g. "sonnet", "gemma3:4b").
+        timeout_s: per-call timeout.
+        fast: True = apply cliworker's speed flags (CLAUDE_FAST, gemini MCP strip).
+              False (default) = full mode — all MCPs/tools loaded, matches how
+              the user's normal `claude -p` session behaves.
+        paid_ok: None (default) = free/subscription only, never burn API credits.
+                 True = allow paid API fallback for this CLI.
+                 list[str] = allow paid only for those CLI names (typically just `cli`).
+    """
+    # Build spec with optional model override
+    spec = get_spec(cli, model=model) if model else get_spec(cli)
+
+    # cliworker's run() needs None (not False) to "respect spec default" for fast.
+    results = run(
+        prompt, spec,
+        fast=True if fast else None,
+        paid_ok=paid_ok,
+        timeout_s=timeout_s,
+    )
+
+    # cliworker.run() returns empty list only if no CLIs passed AND no default chain.
+    # We passed an explicit spec, so this should always have at least one result.
+    if results:
+        cli_result = results[-1]
+    else:
+        # Defensive fallback — construct a failure result
+        cli_result = CLIResult(
+            spec=spec, ok=False, stdout="",
+            stderr=f"no result from cliworker for {cli}",
+            duration_s=0.0, returncode=None, argv=[], skipped_reason=None,
+        )
+
+    # Write the paircode file-trace
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    header = (
+        f"<!-- peer_id: {peer_id} -->\n"
+        f"<!-- cli: {cli} -->\n"
+        f"<!-- model: {model or '(default)'} -->\n"
+        f"<!-- duration_s: {cli_result.duration_s:.1f} -->\n"
+        f"<!-- ok: {cli_result.ok} -->\n\n"
+    )
+    if cli_result.ok:
+        body = cli_result.stdout
+    else:
+        body = (
+            f"# Peer run FAILED\n\n"
+            f"```\n{cli_result.stderr}\n```\n\n"
+            f"{cli_result.stdout}"
+        )
+    output_path.write_text(header + body, encoding="utf-8")
+
+    return PeerRunResult.from_cli_result(peer_id, cli_result)

paircode-0.8.1/tests/test_cli_smoke.py

@@ -0,0 +1,252 @@
+"""End-to-end CLI smoke tests for paircode (v0.8+).
+
+Invokes the real CLI via CliRunner and asserts on real output. Catches
+regressions unit tests miss: broken subcommands, click routing drift,
+wrong default behavior, missing help content.
+
+Mirrors the same approach we added to cliworker in its v0.5.5.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from paircode import __version__
+from paircode.cli import main
+
+
+# ---------------------------------------------------------------------------
+# Help-lint: every registered command + every --help variant must work.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize(
+    "cmd_argv",
+    [
+        ["--help"],
+        ["--version"],
+        ["install", "--help"],
+        ["uninstall", "--help"],
+        ["handshake", "--help"],
+        ["status", "--help"],
+        ["init", "--help"],
+        ["focus", "--help"],
+        ["stage", "--help"],
+        ["seal", "--help"],
+        ["drive", "--help"],
+    ],
+)
+def test_every_command_help_is_reachable(cmd_argv):
+    runner = CliRunner()
+    result = runner.invoke(main, cmd_argv)
+    assert result.exit_code == 0, (
+        f"{cmd_argv} exited {result.exit_code}:\n{result.output}"
+    )
+    assert result.output.strip(), f"{cmd_argv} printed nothing"
+
+
+def test_main_help_lists_all_public_subcommands():
+    runner = CliRunner()
+    result = runner.invoke(main, ["--help"])
+    assert result.exit_code == 0
+    for cmd in (
+        "install", "uninstall", "handshake", "status",
+        "init", "focus", "stage", "seal", "drive",
+    ):
+        assert cmd in result.output, f"Main --help missing subcommand: {cmd}"
+
+
+def test_version_string_matches_dunder():
+    runner = CliRunner()
+    result = runner.invoke(main, ["--version"])
+    assert result.exit_code == 0
+    assert __version__ in result.output
+
+
+# ---------------------------------------------------------------------------
+# Runner <-> cliworker integration
+# ---------------------------------------------------------------------------
+
+def test_runner_imports_cliworker():
+    """Regression: paircode.runner must import and delegate to cliworker as
+    of v0.8+. If someone reverts the refactor, this test breaks."""
+    import paircode.runner as runner
+    import cliworker
+
+    # The run_peer function should internally call cliworker.run
+    source = Path(runner.__file__).read_text()
+    assert "from cliworker" in source, (
+        "paircode.runner must use cliworker — "
+        "the whole point of v0.8 was to delegate to it"
+    )
+    assert "cliworker.run" in source or "import run" in source
+
+
+def test_run_peer_wraps_cliworker_result(monkeypatch, tmp_path):
+    """run_peer should call cliworker.run() and return a PeerRunResult
+    with the peer_id set + the file-trace written to disk."""
+    from paircode.runner import run_peer, PeerRunResult
+
+    # Intercept cliworker.run so no real subprocess fires
+    from cliworker.core import CLIResult
+    from cliworker import get_spec
+
+    def fake_run(prompt, *specs, **kwargs):
+        spec = specs[0] if specs else get_spec("claude")
+        return [CLIResult(
+            spec=spec, ok=True, stdout="mocked answer",
+            stderr="", duration_s=0.42, returncode=0,
+            argv=["fake", "claude", "-p", prompt], skipped_reason=None,
+        )]
+
+    monkeypatch.setattr("paircode.runner.run", fake_run)
+
+    out_path = tmp_path / "peer-a-v1.md"
+    result = run_peer(
+        peer_id="peer-a-fake",
+        cli="claude",
+        prompt="what is TCP?",
+        output_path=out_path,
+        timeout_s=30,
+    )
+
+    # Returns a proper PeerRunResult
+    assert isinstance(result, PeerRunResult)
+    assert result.peer_id == "peer-a-fake"
+    assert result.cli == "claude"
+    assert result.ok is True
+    assert result.stdout == "mocked answer"
+    assert result.duration_s == pytest.approx(0.42)
+
+    # File-trace landed with the correct header
+    assert out_path.exists()
+    content = out_path.read_text()
+    assert "peer_id: peer-a-fake" in content
+    assert "cli: claude" in content
+    assert "ok: True" in content
+    assert "mocked answer" in content
+
+
+def test_run_peer_with_failure_still_writes_trace(monkeypatch, tmp_path):
+    """Failed peer runs must still leave a file-trace on disk, with the
+    failure captured — that's the whole point of 'every thought on disk'."""
+    from paircode.runner import run_peer
+    from cliworker.core import CLIResult
+    from cliworker import get_spec
+
+    def fake_run(prompt, *specs, **kwargs):
+        spec = specs[0] if specs else get_spec("claude")
+        return [CLIResult(
+            spec=spec, ok=False, stdout="",
+            stderr="subscription lapsed",
+            duration_s=1.5, returncode=1, argv=[], skipped_reason=None,
+        )]
+
+    monkeypatch.setattr("paircode.runner.run", fake_run)
+
+    out_path = tmp_path / "peer-v1.md"
+    result = run_peer(
+        peer_id="peer-x", cli="claude", prompt="hi",
+        output_path=out_path,
+    )
+    assert result.ok is False
+    assert out_path.exists()
+    content = out_path.read_text()
+    assert "FAILED" in content
+    assert "subscription lapsed" in content
+
+
+def test_run_peer_fast_kwarg_passes_through(monkeypatch, tmp_path):
+    """run_peer(fast=True) must land as fast=True on cliworker.run()."""
+    from paircode.runner import run_peer
+    from cliworker.core import CLIResult
+    from cliworker import get_spec
+
+    captured = {}
+
+    def fake_run(prompt, *specs, **kwargs):
+        captured["fast"] = kwargs.get("fast")
+        return [CLIResult(
+            spec=specs[0], ok=True, stdout="ok", stderr="",
+            duration_s=0.1, returncode=0, argv=[], skipped_reason=None,
+        )]
+
+    monkeypatch.setattr("paircode.runner.run", fake_run)
+
+    run_peer(
+        peer_id="p", cli="claude", prompt="hi",
+        output_path=tmp_path / "x.md",
+        fast=True,
+    )
+    assert captured["fast"] is True
+
+    # And default: no fast
+    captured.clear()
+    run_peer(
+        peer_id="p", cli="claude", prompt="hi",
+        output_path=tmp_path / "y.md",
+    )
+    assert captured.get("fast") in (None, False)
+
+
+# ---------------------------------------------------------------------------
+# Installer: codex no-op + legacy cleanup
+# ---------------------------------------------------------------------------
+
+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."""
+    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}")
+    results = inst.install_all()
+
+    actions = {r.cli_name: r.action for r in results}
+    assert actions["codex"] == "noop"
+
+    # File must NOT exist
+    assert not (fake_home / ".codex" / "rules" / "paircode.rules").exists()
+
+
+# ---------------------------------------------------------------------------
+# Init + status dispatch smoke
+# ---------------------------------------------------------------------------
+
+def test_init_creates_paircode_dir(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(main, ["init"])
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / ".paircode").exists()
+    assert (tmp_path / ".paircode" / "JOURNEY.md").exists()
+    assert (tmp_path / ".paircode" / "peers.yaml").exists()
+
+
+def test_status_finds_paircode_dir(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    # First init
+    runner.invoke(main, ["init"])
+    # Then status should find it and exit cleanly
+    result = runner.invoke(main, ["status"])
+    assert result.exit_code == 0
+    assert ".paircode" in result.output
+
+
+def test_status_without_paircode_dir_prints_hint(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(main, ["status"])
+    # Should not crash; should suggest init
+    assert result.exit_code == 0
+    assert "init" in result.output.lower()

{paircode-0.7.1 → paircode-0.8.1}/tests/test_smoke.py

@@ -76,9 +76,56 @@ def test_install_writes_to_tmp_claude(tmp_path, monkeypatch):
 
     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"
-    # Verify file landed
+    # 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
     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"
+    )
+
+
+def test_install_cleans_legacy_codex_rules_file(tmp_path, monkeypatch):
+    """Users who installed paircode 0.1–0.7 have a broken ~/.codex/rules/paircode.rules.
+    Running install again (or any time) must clean it up."""
+    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)
+
+    # Seed the legacy broken file
+    legacy = fake_home / ".codex" / "rules" / "paircode.rules"
+    legacy.parent.mkdir(parents=True)
+    legacy.write_text("# old broken markdown-in-starlark\n")
+    assert legacy.exists()
+
+    def fake_which(binary):
+        return f"/fake/bin/{binary}"
+
+    monkeypatch.setattr("shutil.which", fake_which)
+    inst.install_all()
+
+    # Legacy file should be gone after install_all
+    assert not legacy.exists(), (
+        "install_all must remove the legacy ~/.codex/rules/paircode.rules "
+        "(it's Starlark-parsed and our markdown broke codex)"
+    )

paircode-0.7.1/src/paircode/installer.py

@@ -1,161 +0,0 @@
-"""Install paircode's slash command / rules into the detected LLM CLIs.
-
-Strategy per CLI:
-  - Claude Code: write `~/.claude/commands/paircode.md` (user-level global slash command).
-  - Codex: write `~/.codex/prompts/paircode.md` if codex supports it, otherwise write
-    a rules snippet at `~/.codex/rules/paircode.rules` that gets picked up as context.
-  - Gemini: no global slash-command primitive; install as a skill via `gemini skills install`
-    or write an extension manifest. Fallback: print instructions to invoke `paircode` from shell.
-"""
-from __future__ import annotations
-
-import shutil
-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"
-    path: Path | None
-    message: str
-
-
-def _read_template(name: str) -> str:
-    return resources.files("paircode.templates").joinpath(name).read_text(encoding="utf-8")
-
-
-def install_claude(info: CliInfo) -> InstallResult:
-    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:
-    if not info.installed:
-        return InstallResult(
-            cli_name="codex",
-            action="skipped",
-            path=None,
-            message=f"codex CLI not on PATH. {info.install_hint}",
-        )
-    # Codex doesn't have a user-facing slash-command dir; we write a rules snippet
-    # that codex reads as context in every session. This is graceful fallback.
-    rules_dir = info.config_dir / "rules"
-    rules_dir.mkdir(parents=True, exist_ok=True)
-    target = rules_dir / "paircode.rules"
-    template = _read_template("codex_rules.md")
-    target.write_text(template, encoding="utf-8")
-    return InstallResult(
-        cli_name="codex",
-        action="installed",
-        path=target,
-        message=(
-            f"Wrote paircode rules to {target}. Codex will see paircode as an "
-            "available tool in its context. Invoke via `codex exec 'paircode ...'`."
-        ),
-    )
-
-
-def install_gemini(info: CliInfo) -> InstallResult:
-    if not info.installed:
-        return InstallResult(
-            cli_name="gemini",
-            action="skipped",
-            path=None,
-            message=f"gemini CLI not on PATH. {info.install_hint}",
-        )
-    # Gemini CLI exposes `gemini skills install <source>`, but we don't want to
-    # depend on the gemini binary being on PATH at install time. Instead, we
-    # document the invocation pattern: gemini users call paircode from shell or
-    # via a skill installed manually. Write a reminder file at ~/.gemini/paircode.md.
-    info.config_dir.mkdir(parents=True, exist_ok=True)
-    target = info.config_dir / "paircode.md"
-    template = _read_template("codex_rules.md")  # same "you have paircode CLI" content
-    target.write_text(template, encoding="utf-8")
-    return InstallResult(
-        cli_name="gemini",
-        action="installed",
-        path=target,
-        message=(
-            f"Wrote paircode reference to {target}. Gemini users: invoke via "
-            "`gemini -p 'run paircode status'` or from shell directly. Full "
-            "skill-registration support lands in a later release."
-        ),
-    )
-
-
-def install_all() -> list[InstallResult]:
-    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 uninstall_all() -> list[InstallResult]:
-    """Remove paircode entries from every known CLI config dir (idempotent)."""
-    results: list[InstallResult] = []
-    paths = [
-        (Path.home() / ".claude" / "commands" / "paircode.md", "claude"),
-        (Path.home() / ".codex" / "rules" / "paircode.rules", "codex"),
-        (Path.home() / ".gemini" / "paircode.md", "gemini"),
-    ]
-    for path, cli_name in paths:
-        if path.exists():
-            path.unlink()
-            results.append(
-                InstallResult(
-                    cli_name=cli_name,
-                    action="installed",  # we removed it
-                    path=path,
-                    message=f"Removed {path}",
-                )
-            )
-        else:
-            results.append(
-                InstallResult(
-                    cli_name=cli_name,
-                    action="skipped",
-                    path=path,
-                    message=f"Nothing to remove at {path}",
-                )
-            )
-    return results

paircode-0.7.1/src/paircode/runner.py

@@ -1,114 +0,0 @@
-"""Invoke peer LLM CLIs as subprocesses, capture output to .md files.
-
-This is the "spawn an LLM, write its answer to disk" primitive. Each CLI
-has different flags for non-interactive / prompt-mode; we normalize them
-here so upstream code just says "ask <peer> this prompt, save to <path>".
-"""
-from __future__ import annotations
-
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-
-DEFAULT_TIMEOUT_SECONDS = 600  # 10 min per peer call — generous for cold research
-
-
-@dataclass(frozen=True)
-class PeerRunResult:
-    peer_id: str
-    cli: str
-    ok: bool
-    stdout: str
-    stderr: str
-    duration_s: float
-    command: list[str]
-
-
-def _cli_command(cli: str, prompt: str, model: Optional[str]) -> list[str]:
-    """Return the subprocess argv to invoke `cli` non-interactively with `prompt`."""
-    if cli == "claude":
-        # Claude Code: -p is non-interactive (print) mode
-        cmd = ["claude", "-p", prompt]
-        if model:
-            cmd.extend(["--model", model])
-        return cmd
-    if cli == "codex":
-        # Codex CLI: `codex exec` is non-interactive; --dangerously-bypass needed to
-        # write files / skip approvals when running headless.
-        cmd = ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox", prompt]
-        if model:
-            cmd.extend(["--model", model])
-        return cmd
-    if cli == "gemini":
-        cmd = ["gemini", "-p", prompt]
-        if model:
-            cmd.extend(["--model", model])
-        return cmd
-    if cli == "ollama":
-        # Ollama needs a model name
-        return ["ollama", "run", model or "llama3.1", prompt]
-    # Unknown CLI — best-effort: pass prompt as last arg
-    return [cli, prompt]
-
-
-def run_peer(
-    peer_id: str,
-    cli: str,
-    prompt: str,
-    output_path: Path,
-    model: Optional[str] = None,
-    timeout_s: int = DEFAULT_TIMEOUT_SECONDS,
-) -> PeerRunResult:
-    """Run one peer LLM against `prompt`, write its stdout to `output_path`.
-
-    Returns a PeerRunResult capturing success/failure + full stdout + stderr.
-    The output file is written regardless of success (empty or error-captured
-    text) so that every invocation leaves a file-trace on disk.
-    """
-    import time
-
-    cmd = _cli_command(cli, prompt, model)
-    start = time.monotonic()
-    try:
-        proc = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=timeout_s,
-            check=False,
-        )
-        duration = time.monotonic() - start
-        ok = proc.returncode == 0
-        stdout, stderr = proc.stdout, proc.stderr
-    except FileNotFoundError:
-        duration = time.monotonic() - start
-        ok = False
-        stdout = ""
-        stderr = f"{cli} binary not found on PATH"
-    except subprocess.TimeoutExpired:
-        duration = time.monotonic() - start
-        ok = False
-        stdout = ""
-        stderr = f"{cli} timed out after {timeout_s}s"
-
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    header = (
-        f"<!-- peer_id: {peer_id} -->\n"
-        f"<!-- cli: {cli} -->\n"
-        f"<!-- model: {model or '(default)'} -->\n"
-        f"<!-- duration_s: {duration:.1f} -->\n"
-        f"<!-- ok: {ok} -->\n\n"
-    )
-    body = stdout if ok else f"# Peer run FAILED\n\n```\n{stderr}\n```\n\n{stdout}"
-    output_path.write_text(header + body, encoding="utf-8")
-    return PeerRunResult(
-        peer_id=peer_id,
-        cli=cli,
-        ok=ok,
-        stdout=stdout,
-        stderr=stderr,
-        duration_s=duration,
-        command=cmd,
-    )