paircode 0.7.1__tar.gz → 0.9.1__tar.gz

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.7.1
+Version: 0.9.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,23 @@ 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 every detected LLM CLI
 ```
 
-Then open Claude Code, Codex, or Gemini and you'll see `/paircode` available globally.
+After install, `/paircode` is available in all three:
+
+| 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
+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.9.1}/README.md

@@ -8,10 +8,23 @@
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude / Codex / Gemini
+paircode install            # registers /paircode in every detected LLM CLI
 ```
 
-Then open Claude Code, Codex, or Gemini and you'll see `/paircode` available globally.
+After install, `/paircode` is available in all three:
+
+| 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
+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.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.7.1"
+version = "0.9.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.9.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.9.0"

paircode-0.9.1/src/paircode/installer.py

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

paircode-0.9.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.9.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.9.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.9.1/tests/test_cli_smoke.py

@@ -0,0 +1,280 @@
+"""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_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)."""
+    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"] == "installed"
+    assert (fake_home / ".codex" / "prompts" / "paircode.md").exists()
+    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."""
+    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["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
+
+
+# ---------------------------------------------------------------------------
+# 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.9.1}/tests/test_smoke.py

@@ -76,9 +76,65 @@ def test_install_writes_to_tmp_claude(tmp_path, monkeypatch):
 
     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"
-    # Verify file landed
+    assert actions["codex"] == "installed"
+    assert actions["gemini"] == "installed"
+
+    # Correct paths per CLI
     claude_cmd = fake_home / ".claude" / "commands" / "paircode.md"
     assert claude_cmd.exists()
-    content = claude_cmd.read_text()
-    assert "paircode" in content
+    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"
+    )
+
+
+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,
-    )