PyPI - paircode - Versions diffs - 0.11.1__tar.gz → 0.11.3__tar.gz - Mend

paircode 0.11.1tar.gz → 0.11.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

{paircode-0.11.1 → paircode-0.11.3}/.gitignore RENAMED Viewed

@@ -35,3 +35,6 @@ ENV/
 /tmp/
 scratch/
 dist/
+# paircode runtime state (focuses, peer workspaces, etc.)
+.paircode/

paircode-0.11.3/PKG-INFO ADDED Viewed

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: paircode
+Version: 0.11.3
+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
+Project-URL: Issues, https://github.com/starshipagentic/paircode/issues
+Author-email: Travis Somerville <travis.somerville@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,claude,codex,gemini,llm,multi-agent,ollama,orchestration,peer-review
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1
+Requires-Dist: cliworker>=0.8.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+# paircode
+**Multi-LLM peer review for your code, with file-traces on disk.** One primary LLM (alpha, usually Claude Code) + any number of peer LLMs (Codex, Gemini, Ollama, …) running research / plan / execute / ask cycles with structured cross-review rounds stored entirely as Markdown on disk.
+> Born from 31 iterations of dual-LLM silent-agreement hunting on a real ML project. See `diary/001-step-a-architecture.md` for the origin story and `diary/003-arch-b-pivot-grappling.md` for the current (v0.11) team-lead architecture.
+## Install
+```bash
+pipx install paircode       # or: pip install --user paircode
+paircode install            # registers /paircode in every detected LLM CLI
+```
+`paircode install` deploys `/paircode` into each LLM CLI it finds on your PATH:
+| CLI | How it's installed | What you get |
+|---|---|---|
+| Claude Code | file-drop `~/.claude/commands/paircode.md` | `/paircode` slash command |
+| Codex CLI | `codex marketplace add starshipagentic/paircode-codex` | `/paircode` slash command |
+| Gemini CLI | `gemini extensions install github.com/starshipagentic/paircode-gemini --consent` | `/paircode` slash command |
+In Gemini you may need `/commands reload` the first time. In Codex the marketplace fetches on first use.
+paircode delegates LLM subprocess invocation to [`cliworker`](https://pypi.org/project/cliworker/) — that's where speed flags, MCP strip tricks, skip-cache, and subscription-first fallback live. paircode adds the peer-review orchestration on top (file-traces, stages, rosters, convergence).
+## Use it
+Inside any LLM CLI that has `/paircode` installed, just type:
+```
+/paircode "build a KISS PHQ-9 depression risk engine"
+```
+or
+```
+/paircode "review my auth middleware approach at src/auth/"
+/paircode "plan the refactor" --peers codex,gemini
+/paircode "get a second opinion on this PR" --peer gemini
+```
+The slash command's team-lead prompt (the LLM you're inside) reads your prompt, picks a stage (`research | plan | execute | ask`), fires peers, collects their markdown, iterates through review rounds until convergence, and writes `consensus.md` at the end. Everything lands under `.paircode/` in your current project.
+## What ends up on disk
+```
+your-project/
+  .paircode/
+    JOURNEY.md                    # fleet log
+    peers.yaml                    # roster: who's on the team
+    peers/
+      peer-a-codex/               # codex's persistent sandbox (code goes here)
+      peer-b-gemini/               # gemini's persistent sandbox
+    focus-01-<slug>/
+      FOCUS.md                    # this focus's prompt + metadata
+      research/
+        alpha-v1.md ... alpha-vN.md
+        peer-a-codex-v1.md ...
+        reviews/round-01-peer-a-codex-critiques-alpha.md
+        alpha-FINAL.md
+        peer-a-codex-FINAL.md
+        consensus.md              # team-lead synthesis (last thing written)
+      plan/         (same shape)
+      execute/      (same shape)
+      ask/          (same shape)
+    focus-02-<slug>/
+      ...
+```
+**Code vs. reports.** Files inside `focus-*/` are markdown *reports* (opinions, plans, critiques, summaries of work). Actual code lives elsewhere:
+- **Peers** code in their sandboxed workspaces at `.paircode/peers/<peer-id>/` — persistent across focuses.
+- **Alpha** codes directly in the project root (the real repo) — alpha *is* the project.
+## Stages
+Stage is picked by the team-lead LLM based on the prompt:
+| Stage | When | Typical prompt |
+|---|---|---|
+| `research` | Explore new ground | "build X", "find the right Y", "how should we approach Z" |
+| `plan` | Concrete implementation plan from prior research | "plan the refactor based on focus-02" |
+| `execute` | Do the work from an existing plan | "execute the plan at focus-02" |
+| `ask` | Get opinions on existing work | "what does codex think of this PR", "review my approach at <path>" |
+The team lead can chain stages in one invocation: `research → plan → execute → done`. No hard round cap — the team lead converges when peers stop surfacing new signal.
+## Commands (the helper CLI)
+Most users will only ever type `paircode install` and then use `/paircode` inside their LLM CLI. The binary's other commands are helpers the team-lead slash command calls on your behalf:
+```
+paircode                         print current .paircode/ state
+paircode install                 register /paircode in every detected LLM CLI
+paircode uninstall               remove /paircode from LLM CLIs (idempotent)
+paircode ensure-scaffold         idempotent .paircode/ init + handshake (silent)
+paircode focus new <slug>        create a new focus dir, print its path
+paircode focus active            print the active focus path
+paircode roster [--alpha <cli>] [--peer <id>] [--peers <id,id>]
+                                 print peer ids, best-effort, never errors
+paircode invoke <peer-id> "<prompt>" --out <path>
+                                 fire one peer, write file-trace to --out
+paircode converge <stage>        copy each participant's latest vN to *-FINAL.md
+```
+## Model compatibility
+| CLI | `/paircode` slash command | Peer invocation | Parallel peers? | Status |
+|---|---|---|---|---|
+| Claude Code (`claude`) | ✓ file-drop at `~/.claude/commands/paircode.md` | ✓ `claude -p <prompt>` | ✓ via Agent tool + `run_in_background=true` | stable |
+| Codex (`codex`) | ✓ via `codex marketplace add` | ✓ `codex exec <prompt>` | ✗ serial-only (codex constraint) | stable |
+| Gemini (`gemini`) | ✓ via `gemini extensions install` | ✓ `gemini -p <prompt>` | ✗ serial-only (gemini constraint) | stable |
+| Ollama (`ollama`) | — (local models, no slash-cmd host) | ✓ `ollama run <model> <prompt>` | n/a | peer-only |
+| Aider / others | — | best-effort, PRs welcome | — | planned |
+Peer roster is auto-detected at first install via `paircode handshake` (silent, called by `ensure-scaffold`). Edit `.paircode/peers.yaml` to customize.
+## Why this exists
+See [`diary/001-step-a-architecture.md`](diary/001-step-a-architecture.md). Short version: running two LLMs adversarially surfaces silent-agreement bug classes that neither engine alone catches — cross-engine agreement is not the same as correctness when both engines share a blind spot.
+See [`diary/003-arch-b-pivot-grappling.md`](diary/003-arch-b-pivot-grappling.md) for why v0.11 moved orchestration out of a Python driver and into the slash-command's team-lead LLM.
+## License
+MIT. See [LICENSE](LICENSE).

paircode-0.11.3/README.md ADDED Viewed

@@ -0,0 +1,126 @@
+# paircode
+**Multi-LLM peer review for your code, with file-traces on disk.** One primary LLM (alpha, usually Claude Code) + any number of peer LLMs (Codex, Gemini, Ollama, …) running research / plan / execute / ask cycles with structured cross-review rounds stored entirely as Markdown on disk.
+> Born from 31 iterations of dual-LLM silent-agreement hunting on a real ML project. See `diary/001-step-a-architecture.md` for the origin story and `diary/003-arch-b-pivot-grappling.md` for the current (v0.11) team-lead architecture.
+## Install
+```bash
+pipx install paircode       # or: pip install --user paircode
+paircode install            # registers /paircode in every detected LLM CLI
+```
+`paircode install` deploys `/paircode` into each LLM CLI it finds on your PATH:
+| CLI | How it's installed | What you get |
+|---|---|---|
+| Claude Code | file-drop `~/.claude/commands/paircode.md` | `/paircode` slash command |
+| Codex CLI | `codex marketplace add starshipagentic/paircode-codex` | `/paircode` slash command |
+| Gemini CLI | `gemini extensions install github.com/starshipagentic/paircode-gemini --consent` | `/paircode` slash command |
+In Gemini you may need `/commands reload` the first time. In Codex the marketplace fetches on first use.
+paircode delegates LLM subprocess invocation to [`cliworker`](https://pypi.org/project/cliworker/) — that's where speed flags, MCP strip tricks, skip-cache, and subscription-first fallback live. paircode adds the peer-review orchestration on top (file-traces, stages, rosters, convergence).
+## Use it
+Inside any LLM CLI that has `/paircode` installed, just type:
+```
+/paircode "build a KISS PHQ-9 depression risk engine"
+```
+or
+```
+/paircode "review my auth middleware approach at src/auth/"
+/paircode "plan the refactor" --peers codex,gemini
+/paircode "get a second opinion on this PR" --peer gemini
+```
+The slash command's team-lead prompt (the LLM you're inside) reads your prompt, picks a stage (`research | plan | execute | ask`), fires peers, collects their markdown, iterates through review rounds until convergence, and writes `consensus.md` at the end. Everything lands under `.paircode/` in your current project.
+## What ends up on disk
+```
+your-project/
+  .paircode/
+    JOURNEY.md                    # fleet log
+    peers.yaml                    # roster: who's on the team
+    peers/
+      peer-a-codex/               # codex's persistent sandbox (code goes here)
+      peer-b-gemini/               # gemini's persistent sandbox
+    focus-01-<slug>/
+      FOCUS.md                    # this focus's prompt + metadata
+      research/
+        alpha-v1.md ... alpha-vN.md
+        peer-a-codex-v1.md ...
+        reviews/round-01-peer-a-codex-critiques-alpha.md
+        alpha-FINAL.md
+        peer-a-codex-FINAL.md
+        consensus.md              # team-lead synthesis (last thing written)
+      plan/         (same shape)
+      execute/      (same shape)
+      ask/          (same shape)
+    focus-02-<slug>/
+      ...
+```
+**Code vs. reports.** Files inside `focus-*/` are markdown *reports* (opinions, plans, critiques, summaries of work). Actual code lives elsewhere:
+- **Peers** code in their sandboxed workspaces at `.paircode/peers/<peer-id>/` — persistent across focuses.
+- **Alpha** codes directly in the project root (the real repo) — alpha *is* the project.
+## Stages
+Stage is picked by the team-lead LLM based on the prompt:
+| Stage | When | Typical prompt |
+|---|---|---|
+| `research` | Explore new ground | "build X", "find the right Y", "how should we approach Z" |
+| `plan` | Concrete implementation plan from prior research | "plan the refactor based on focus-02" |
+| `execute` | Do the work from an existing plan | "execute the plan at focus-02" |
+| `ask` | Get opinions on existing work | "what does codex think of this PR", "review my approach at <path>" |
+The team lead can chain stages in one invocation: `research → plan → execute → done`. No hard round cap — the team lead converges when peers stop surfacing new signal.
+## Commands (the helper CLI)
+Most users will only ever type `paircode install` and then use `/paircode` inside their LLM CLI. The binary's other commands are helpers the team-lead slash command calls on your behalf:
+```
+paircode                         print current .paircode/ state
+paircode install                 register /paircode in every detected LLM CLI
+paircode uninstall               remove /paircode from LLM CLIs (idempotent)
+paircode ensure-scaffold         idempotent .paircode/ init + handshake (silent)
+paircode focus new <slug>        create a new focus dir, print its path
+paircode focus active            print the active focus path
+paircode roster [--alpha <cli>] [--peer <id>] [--peers <id,id>]
+                                 print peer ids, best-effort, never errors
+paircode invoke <peer-id> "<prompt>" --out <path>
+                                 fire one peer, write file-trace to --out
+paircode converge <stage>        copy each participant's latest vN to *-FINAL.md
+```
+## Model compatibility
+| CLI | `/paircode` slash command | Peer invocation | Parallel peers? | Status |
+|---|---|---|---|---|
+| Claude Code (`claude`) | ✓ file-drop at `~/.claude/commands/paircode.md` | ✓ `claude -p <prompt>` | ✓ via Agent tool + `run_in_background=true` | stable |
+| Codex (`codex`) | ✓ via `codex marketplace add` | ✓ `codex exec <prompt>` | ✗ serial-only (codex constraint) | stable |
+| Gemini (`gemini`) | ✓ via `gemini extensions install` | ✓ `gemini -p <prompt>` | ✗ serial-only (gemini constraint) | stable |
+| Ollama (`ollama`) | — (local models, no slash-cmd host) | ✓ `ollama run <model> <prompt>` | n/a | peer-only |
+| Aider / others | — | best-effort, PRs welcome | — | planned |
+Peer roster is auto-detected at first install via `paircode handshake` (silent, called by `ensure-scaffold`). Edit `.paircode/peers.yaml` to customize.
+## Why this exists
+See [`diary/001-step-a-architecture.md`](diary/001-step-a-architecture.md). Short version: running two LLMs adversarially surfaces silent-agreement bug classes that neither engine alone catches — cross-engine agreement is not the same as correctness when both engines share a blind spot.
+See [`diary/003-arch-b-pivot-grappling.md`](diary/003-arch-b-pivot-grappling.md) for why v0.11 moved orchestration out of a Python driver and into the slash-command's team-lead LLM.
+## License
+MIT. See [LICENSE](LICENSE).

{paircode-0.11.1 → paircode-0.11.3}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 [project]
 name = "paircode"
-version = "0.11.1"
+version = "0.11.3"
 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" }

{paircode-0.11.1 → paircode-0.11.3}/src/paircode/__init__.py RENAMED Viewed

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

{paircode-0.11.1 → paircode-0.11.3}/src/paircode/cli.py RENAMED Viewed

@@ -243,7 +243,7 @@ def converge(stage: str) -> None:
     Runs on the active focus. Mechanical file-copy only; the slash command
     writes `consensus.md` afterward from the FINAL files.
     """
-    from paircode.seal import seal_stage
+    from paircode.converge import seal_stage
     state = find_paircode()
     if state is None or state.active_focus is None:

paircode-0.11.1/src/paircode/seal.py → paircode-0.11.3/src/paircode/converge.py RENAMED Viewed

@@ -1,8 +1,12 @@
-"""Seal a stage — copy the latest version per peer to {peer}-FINAL.md.
+"""Converge a stage — copy the latest version per peer to {peer}-FINAL.md.
-Sealing is the declarative exit signal for a stage. Once alpha-FINAL.md and
-each peer's *-FINAL.md exist, the stage is considered complete and the next
-stage can consume its outputs.
+Convergence is the declarative exit signal for a stage. Once alpha-FINAL.md
+and each peer's *-FINAL.md exist, the stage is considered complete and the
+next stage can consume its outputs.
+Renamed from `seal.py` in v0.11.1 to match the user-facing CLI verb
+(`paircode converge <stage>`). The public function name stayed `seal_stage`
+because it describes a file-copy primitive, not the user-level action.
 """
 from __future__ import annotations

{paircode-0.11.1 → paircode-0.11.3}/src/paircode/installer.py RENAMED Viewed

@@ -22,12 +22,12 @@ 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
+from paircode.util import read_template as _read_template
 # Satellite repo coordinates — update here when repos move.
@@ -46,15 +46,6 @@ class InstallResult:
     message: str
-def _read_template(relative_path: str) -> str:
-    """Read a file under `paircode/templates/` by relative path.
-    Host templates live at `<host>/commands/...`, host-agnostic scaffold
-    templates at the root (`FOCUS.md`, `JOURNEY.md`, `peers.yaml`).
-    """
-    return resources.files("paircode.templates").joinpath(relative_path).read_text(encoding="utf-8")
 # ---------------------------------------------------------------------------
 # Per-CLI installers
 # ---------------------------------------------------------------------------

{paircode-0.11.1 → paircode-0.11.3}/src/paircode/state.py RENAMED Viewed

@@ -18,12 +18,13 @@ from __future__ import annotations
 import datetime as _dt
 import re
 from dataclasses import dataclass
-from importlib import resources
 from pathlib import Path
 from typing import Iterable
 import yaml
+from paircode.util import read_template as _read_template
 PAIRCODE_DIRNAME = ".paircode"
 PEERS_FILE = "peers.yaml"
@@ -35,15 +36,6 @@ def _now_iso() -> str:
     return _dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-def _read_template(relative_path: str) -> str:
-    """Read a file under `paircode/templates/` by relative path.
-    Examples: `_read_template("FOCUS.md")` or
-    `_read_template("claude/commands/paircode.md")`.
-    """
-    return resources.files("paircode.templates").joinpath(relative_path).read_text(encoding="utf-8")
 def _render(template: str, vars: dict[str, str]) -> str:
     out = template
     for k, v in vars.items():

paircode-0.11.3/src/paircode/util.py ADDED Viewed

@@ -0,0 +1,18 @@
+"""Small shared helpers for paircode internals."""
+from __future__ import annotations
+from importlib import resources
+def read_template(relative_path: str) -> str:
+    """Read a file under `paircode/templates/` by relative path.
+    Examples:
+        read_template("FOCUS.md")
+        read_template("claude/commands/paircode.md")
+    """
+    return (
+        resources.files("paircode.templates")
+        .joinpath(relative_path)
+        .read_text(encoding="utf-8")
+    )

paircode-0.11.1/tests/test_seal.py → paircode-0.11.3/tests/test_converge.py RENAMED Viewed

@@ -1,9 +1,9 @@
-"""Tests for stage sealing."""
+"""Tests for stage convergence — copying latest vN to *-FINAL.md."""
 from __future__ import annotations
 from pathlib import Path
-from paircode.seal import discover_latest_versions, seal_stage
+from paircode.converge import discover_latest_versions, seal_stage
 def test_discover_latest_versions_picks_highest_per_peer(tmp_path: Path):

paircode-0.11.1/PKG-INFO DELETED Viewed

@@ -1,160 +0,0 @@
-Metadata-Version: 2.4
-Name: paircode
-Version: 0.11.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
-Project-URL: Issues, https://github.com/starshipagentic/paircode/issues
-Author-email: Travis Somerville <travis.somerville@gmail.com>
-License: MIT
-License-File: LICENSE
-Keywords: agents,claude,codex,gemini,llm,multi-agent,ollama,orchestration,peer-review
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development
-Requires-Python: >=3.10
-Requires-Dist: click>=8.1
-Requires-Dist: cliworker>=0.8.1
-Requires-Dist: pyyaml>=6.0
-Requires-Dist: rich>=13.0
-Description-Content-Type: text/markdown
-# paircode
-**Multi-LLM peer review for your code, with file-traces on disk.** One primary LLM (alpha) + any number of peer LLMs (Codex, Gemini, Ollama, …) running independent research, plans, and code, with structured cross-review rounds stored entirely as Markdown on disk.
-> Born from 31 iterations of dual-LLM silent-agreement hunting on a real ML project. See `diary/001-step-a-architecture.md` for the full design rationale.
-## Install
-```bash
-pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in every detected LLM CLI
-```
-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
-### 1. From Claude Code (or any supported LLM) as a slash command
-Inside a Claude Code session:
-```
-/paircode drive "build a KISS PHQ-9 depression risk engine"
-```
-Claude relays that to the CLI. paircode opens a focus, runs research → plan → execute with peer-reviewed rounds, writes everything to `.paircode/` as Markdown.
-### 2. From the shell directly
-```bash
-paircode init                                   # bootstrap .paircode/ in cwd
-paircode handshake --write                      # detect CLIs + write peer roster
-paircode drive "refactor the auth middleware"   # full loop
-paircode status                                 # see where you are
-```
-### 3. Piece by piece
-```bash
-paircode focus "try GitHub Actions migration"
-paircode stage research --rounds 2              # cold v1 + one review/revise round
-paircode seal research                          # mark research FINAL
-paircode stage plan --rounds 3
-paircode seal plan
-paircode stage execute
-paircode seal execute
-```
-## What ends up on disk
-```
-your-project/
-  .paircode/
-    JOURNEY.md                    # fleet log (auto-updated)
-    peers.yaml                    # who's on the team
-    peers/
-      peer-a-codex/               # peer's profile (and code if full-fork mode)
-    focus-01-<slug>/
-      FOCUS.md                    # this focus's goal, roster override, gate config
-      research/
-        alpha-v1.md ... alpha-vN.md
-        peer-a-codex-v1.md ...
-        reviews/round-01-peer-a-codex-critiques-alpha.md
-        alpha-FINAL.md            # sealed exit artifact
-        peer-a-codex-FINAL.md
-      plan/
-        (same shape)
-      execute/
-        (same shape)
-    focus-02-<slug>/
-      ...
-```
-Every LLM's every thought lands as a Markdown file. That's how heterogeneous LLM tools communicate reliably across vendors, sessions, and days.
-## Three peer modes
-| Mode | What the peer does | When to use |
-|---|---|---|
-| **full-fork** | Writes its own cold codebase + markdown artifacts | Silent-agreement hunting, safety-critical code |
-| **pair-code** | Contributes directly to alpha's codebase via patches + reviews | Feature work, regular dev |
-| **opinion-only** | Reads alpha's work, writes reviews, never touches code | Budget peers, quick sanity checks |
-Configured per peer in `.paircode/peers.yaml`.
-## Model compatibility
-| CLI | Slash command | Subprocess driver | Status |
-|---|---|---|---|
-| Claude Code (`claude`) | ✓ `/paircode` via `~/.claude/commands/paircode.md` | ✓ `claude -p <prompt>` | stable |
-| Codex (`codex`) | ✓ context rule via `~/.codex/rules/paircode.rules` | ✓ `codex exec <prompt>` | stable |
-| Gemini CLI (`gemini`) | ✓ reference file at `~/.gemini/paircode.md` | ✓ `gemini -p <prompt>` | stable |
-| Ollama (`ollama`) | — (local models, no slash-cmd primitive) | ✓ `ollama run <model> <prompt>` | stable |
-| Aider / others | — | best-effort, PRs welcome | planned |
-## Commands
-```
-paircode --help           full command list
-paircode install          register /paircode in all detected LLM CLIs
-paircode uninstall        remove /paircode from LLM CLIs (idempotent)
-paircode handshake        detect CLIs, propose peer roster
-paircode handshake --write save roster to .paircode/peers.yaml
-paircode init             bootstrap .paircode/ in cwd
-paircode status           summarize current state
-paircode focus <name>     open a new focus
-paircode focus            list existing focuses
-paircode stage <name>     run one stage N rounds on active focus
-paircode seal <stage>     seal stage — copy each peer's latest vN to {peer}-FINAL.md
-paircode drive <topic>    full loop: research → plan → execute
-```
-## Why this exists
-See [`diary/001-step-a-architecture.md`](diary/001-step-a-architecture.md) for the full backstory. The short version: running two LLMs adversarially surfaces silent-agreement bug classes that neither engine alone can catch, because cross-engine agreement is not the same as correctness when both share the same blind spot.
-## License
-MIT. See [LICENSE](LICENSE).

paircode-0.11.1/README.md DELETED Viewed

@@ -1,132 +0,0 @@
-# paircode
-**Multi-LLM peer review for your code, with file-traces on disk.** One primary LLM (alpha) + any number of peer LLMs (Codex, Gemini, Ollama, …) running independent research, plans, and code, with structured cross-review rounds stored entirely as Markdown on disk.
-> Born from 31 iterations of dual-LLM silent-agreement hunting on a real ML project. See `diary/001-step-a-architecture.md` for the full design rationale.
-## Install
-```bash
-pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in every detected LLM CLI
-```
-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
-### 1. From Claude Code (or any supported LLM) as a slash command
-Inside a Claude Code session:
-```
-/paircode drive "build a KISS PHQ-9 depression risk engine"
-```
-Claude relays that to the CLI. paircode opens a focus, runs research → plan → execute with peer-reviewed rounds, writes everything to `.paircode/` as Markdown.
-### 2. From the shell directly
-```bash
-paircode init                                   # bootstrap .paircode/ in cwd
-paircode handshake --write                      # detect CLIs + write peer roster
-paircode drive "refactor the auth middleware"   # full loop
-paircode status                                 # see where you are
-```
-### 3. Piece by piece
-```bash
-paircode focus "try GitHub Actions migration"
-paircode stage research --rounds 2              # cold v1 + one review/revise round
-paircode seal research                          # mark research FINAL
-paircode stage plan --rounds 3
-paircode seal plan
-paircode stage execute
-paircode seal execute
-```
-## What ends up on disk
-```
-your-project/
-  .paircode/
-    JOURNEY.md                    # fleet log (auto-updated)
-    peers.yaml                    # who's on the team
-    peers/
-      peer-a-codex/               # peer's profile (and code if full-fork mode)
-    focus-01-<slug>/
-      FOCUS.md                    # this focus's goal, roster override, gate config
-      research/
-        alpha-v1.md ... alpha-vN.md
-        peer-a-codex-v1.md ...
-        reviews/round-01-peer-a-codex-critiques-alpha.md
-        alpha-FINAL.md            # sealed exit artifact
-        peer-a-codex-FINAL.md
-      plan/
-        (same shape)
-      execute/
-        (same shape)
-    focus-02-<slug>/
-      ...
-```
-Every LLM's every thought lands as a Markdown file. That's how heterogeneous LLM tools communicate reliably across vendors, sessions, and days.
-## Three peer modes
-| Mode | What the peer does | When to use |
-|---|---|---|
-| **full-fork** | Writes its own cold codebase + markdown artifacts | Silent-agreement hunting, safety-critical code |
-| **pair-code** | Contributes directly to alpha's codebase via patches + reviews | Feature work, regular dev |
-| **opinion-only** | Reads alpha's work, writes reviews, never touches code | Budget peers, quick sanity checks |
-Configured per peer in `.paircode/peers.yaml`.
-## Model compatibility
-| CLI | Slash command | Subprocess driver | Status |
-|---|---|---|---|
-| Claude Code (`claude`) | ✓ `/paircode` via `~/.claude/commands/paircode.md` | ✓ `claude -p <prompt>` | stable |
-| Codex (`codex`) | ✓ context rule via `~/.codex/rules/paircode.rules` | ✓ `codex exec <prompt>` | stable |
-| Gemini CLI (`gemini`) | ✓ reference file at `~/.gemini/paircode.md` | ✓ `gemini -p <prompt>` | stable |
-| Ollama (`ollama`) | — (local models, no slash-cmd primitive) | ✓ `ollama run <model> <prompt>` | stable |
-| Aider / others | — | best-effort, PRs welcome | planned |
-## Commands
-```
-paircode --help           full command list
-paircode install          register /paircode in all detected LLM CLIs
-paircode uninstall        remove /paircode from LLM CLIs (idempotent)
-paircode handshake        detect CLIs, propose peer roster
-paircode handshake --write save roster to .paircode/peers.yaml
-paircode init             bootstrap .paircode/ in cwd
-paircode status           summarize current state
-paircode focus <name>     open a new focus
-paircode focus            list existing focuses
-paircode stage <name>     run one stage N rounds on active focus
-paircode seal <stage>     seal stage — copy each peer's latest vN to {peer}-FINAL.md
-paircode drive <topic>    full loop: research → plan → execute
-```
-## Why this exists
-See [`diary/001-step-a-architecture.md`](diary/001-step-a-architecture.md) for the full backstory. The short version: running two LLMs adversarially surfaces silent-agreement bug classes that neither engine alone can catch, because cross-engine agreement is not the same as correctness when both share the same blind spot.
-## License
-MIT. See [LICENSE](LICENSE).

paircode-0.11.1/src/paircode/journey.py DELETED Viewed

@@ -1,63 +0,0 @@
-"""Update JOURNEY.md as focuses open/close."""
-from __future__ import annotations
-import datetime as _dt
-import re
-from pathlib import Path
-from paircode.state import PaircodeState
-_HISTORY_HEADER_RE = re.compile(r"^## History\s*$", re.MULTILINE)
-_HISTORY_TABLE_RE = re.compile(
-    r"\| # \| Focus \| Opened \| Closed \| Iterations \| Result \|\n\|[-|\s]+\|\n"
-)
-_ACTIVE_FOCUS_RE = re.compile(
-    r"## Active focus\s*\n\n(.+?)\n\n##", re.DOTALL
-)
-def _now() -> str:
-    return _dt.datetime.now().strftime("%Y-%m-%d %H:%M")
-def note_focus_opened(state: PaircodeState, focus_name: str) -> None:
-    """Update JOURNEY.md: set active focus, append history row."""
-    j = state.journey_path
-    if not j.exists():
-        return
-    text = j.read_text(encoding="utf-8")
-    # Replace the "Active focus" section
-    new_active = f"## Active focus\n\n**{focus_name}** — opened {_now()}\n\n##"
-    text = _ACTIVE_FOCUS_RE.sub(new_active, text, count=1)
-    # Append to history table
-    history_match = _HISTORY_TABLE_RE.search(text)
-    if history_match:
-        # Count existing rows in history table
-        rest = text[history_match.end():]
-        existing_rows = rest.split("\n\n")[0]
-        row_count = len([r for r in existing_rows.split("\n") if r.startswith("|")])
-        new_row = f"| {row_count + 1} | {focus_name} | {_now()} | — | 0 | — |\n"
-        text = text[:history_match.end()] + new_row + text[history_match.end():]
-    j.write_text(text, encoding="utf-8")
-def note_focus_closed(state: PaircodeState, focus_name: str, iterations: int, result: str) -> None:
-    """Update JOURNEY.md: mark the focus row as closed with iteration count + result."""
-    j = state.journey_path
-    if not j.exists():
-        return
-    text = j.read_text(encoding="utf-8")
-    # Find row for this focus and update its Closed/Iterations/Result columns
-    pattern = re.compile(
-        rf"(\| \d+ \| {re.escape(focus_name)} \| [^|]+\| )—( \| )0( \| )—( \|)"
-    )
-    text = pattern.sub(
-        rf"\g<1>{_now()}\g<2>{iterations}\g<3>{result}\g<4>",
-        text,
-        count=1,
-    )
-    j.write_text(text, encoding="utf-8")