paircode 0.12.4__py3-none-any.whl → 0.13.2__py3-none-any.whl

paircode/__init__.py

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

paircode/cli.py

@@ -28,6 +28,7 @@ from paircode.handshake import propose_roster, proposed_as_yaml_dicts
 from paircode.installer import install_all, uninstall_all
 from paircode.runner import run_peer
 from paircode.state import (
+    ensure_gitignore,
     ensure_peer_dirs,
     find_paircode,
     init_paircode,
@@ -108,6 +109,9 @@ def ensure_scaffold() -> None:
     if state is None:
         state = init_paircode()
         did_init = True
+    else:
+        # Retroactively protect projects whose .paircode/ predates this guard.
+        ensure_gitignore(state.project_root)
 
     peers = read_peers(state)
     proposed_count = 0
@@ -324,12 +328,15 @@ def peerlab() -> None:
 @peerlab.command("ensure")
 def peerlab_ensure() -> None:
     """Scaffold .peerlab/<peer-id>/ per peer; seed from project root on first
-    creation; git init per lab; add .peerlab/ to outer .gitignore. Idempotent."""
-    from paircode.peerlab import ensure_peer_labs
+    creation; git init per lab; add .peerlab/ to outer .gitignore. Idempotent.
 
-    state = find_paircode()
+    Uses .peerlab/peers.yaml (peerlab's own roster), not .paircode/.
+    """
+    from paircode.peerlab import ensure_peer_labs, find_peerlab, init_peerlab
+
+    state = find_peerlab()
     if state is None:
-        state = init_paircode()
+        state = init_peerlab()
     results = ensure_peer_labs(state)
     for r in results:
         if r.status == "created":
@@ -350,14 +357,14 @@ def peerlab_ensure() -> None:
               help="Apply cliworker speed flags")
 def peerlab_invoke(peer_id: str, prompt: str, out_path: str | None, timeout: int, fast: bool) -> None:
     """Fire a peer CLI with cwd set to its lab. Peer works in-place."""
-    from paircode.peerlab import peer_lab_path
+    from paircode.peerlab import find_peerlab, peer_lab_path, read_peerlab_peers
 
-    state = find_paircode()
+    state = find_peerlab()
     if state is None:
         raise click.ClickException(
-            "No .paircode/ found. Run `paircode ensure-scaffold` + `paircode peerlab ensure` first."
+            "No .peerlab/ found. Run `paircode peerlab ensure` first."
         )
-    peers = read_peers(state)
+    peers = read_peerlab_peers(state)
     peer = next((p for p in peers if p.get("id") == peer_id), None)
     if peer is None:
         known = [p.get("id") for p in peers]
@@ -368,14 +375,21 @@ def peerlab_invoke(peer_id: str, prompt: str, out_path: str | None, timeout: int
             f"Lab dir missing: {lab}. Run `paircode peerlab ensure` first."
         )
 
-    # Preamble so the peer knows it's in a lab with its own git
+    # Preamble: peer knows where its lab is + that cross-reads outside the
+    # lab are allowed when the task says so (cross-review reads alpha's
+    # project root at ../../ and sibling peer labs at ../).
     framed_prompt = (
-        f"You are the {peer_id} peer working in your own lab at {lab}.\n"
-        f"Your cwd is already this lab. You have your own `.git/` here — commit\n"
-        f"your work (stage + commit) before finishing so the team lead can read\n"
-        f"the diff. Don't worry about alpha's repo; your lab is fully independent.\n"
+        f"You are the {peer_id} peer in a paircode peerlab run.\n"
+        f"Your own lab is at {lab} — that is your cwd. You have your own `.git/`\n"
+        f"here; commit your work in this lab before finishing so the team lead\n"
+        f"can read the diff. Modify files ONLY inside your own lab.\n"
+        f"\n"
+        f"The task below may instruct you to READ outside your lab — e.g.,\n"
+        f"alpha's project root at `../../` (alpha's lab) or sibling peer labs\n"
+        f"at `../<other-peer-id>/`. Read-only cross-reads are expected during\n"
+        f"cross-review rounds. Do not write outside your own lab.\n"
         f"\n"
-        f"Work:\n"
+        f"Task:\n"
         f"{prompt}"
     )
 
@@ -423,15 +437,15 @@ def peerlab_invoke(peer_id: str, prompt: str, out_path: str | None, timeout: int
 @peerlab.command("list")
 def peerlab_list() -> None:
     """Show peer labs with creation status + HEAD commit (if any)."""
-    from paircode.peerlab import peer_lab_path
+    from paircode.peerlab import find_peerlab, peer_lab_path, read_peerlab_peers
 
-    state = find_paircode()
+    state = find_peerlab()
     if state is None:
-        click.echo("No .paircode/ found. Nothing to list.")
+        click.echo("No .peerlab/ found. Run `paircode peerlab ensure` first.")
         return
-    peers = read_peers(state)
+    peers = read_peerlab_peers(state)
     if not peers:
-        click.echo("No peers in roster.")
+        click.echo("No peers in .peerlab/peers.yaml roster.")
         return
     ptable = Table(show_header=True, header_style="bold")
     ptable.add_column("peer")
@@ -458,6 +472,51 @@ def peerlab_list() -> None:
     console.print(ptable)
 
 
+@peerlab.command("roster")
+@click.option("--alpha", "alpha_cli", default=None,
+              help="CLI acting as alpha (excluded from peers unless last resort).")
+@click.option("--peer", "peer_filter", default=None,
+              help="Narrow to a single peer id. Silently falls back if missing.")
+@click.option("--peers", "peers_filter", default=None,
+              help="Comma-separated peer ids. Silently falls back if none match.")
+def peerlab_roster(alpha_cli: str | None, peer_filter: str | None, peers_filter: str | None) -> None:
+    """Print peerlab peer ids, one per line — best-effort, never errors.
+
+    Reads .peerlab/peers.yaml (peerlab's own roster, fully independent of
+    .paircode/). Same filter semantics as `paircode roster`.
+    """
+    from paircode.peerlab import find_peerlab, read_peerlab_peers
+
+    state = find_peerlab()
+    if state is None:
+        return
+    all_peers = [p for p in read_peerlab_peers(state) if p.get("id")]
+
+    if peers_filter:
+        wanted = [s.strip() for s in peers_filter.split(",") if s.strip()]
+        filtered = [p for p in all_peers if p.get("id") in wanted]
+    elif peer_filter:
+        filtered = [p for p in all_peers if p.get("id") == peer_filter]
+    else:
+        filtered = list(all_peers)
+
+    def _exclude_alpha(peers: list[dict]) -> list[dict]:
+        if not alpha_cli:
+            return peers
+        return [p for p in peers if p.get("cli") != alpha_cli]
+
+    result = _exclude_alpha(filtered)
+    if not result and (peer_filter or peers_filter):
+        result = _exclude_alpha(all_peers)
+    if not result:
+        result = list(all_peers)
+
+    for p in result:
+        pid = p.get("id")
+        if pid:
+            click.echo(pid)
+
+
 # ---------------------------------------------------------------------------
 # Bare paircode — show state
 # ---------------------------------------------------------------------------

paircode/handshake.py

@@ -16,6 +16,11 @@ class ProposedPeer:
     cli: str
     priority: str
     notes: str = ""
+    # Empty = let the CLI pick its own default model. Pin a specific model string
+    # (e.g. a Pro tier) to avoid the silent free-tier trap: an unpinned peer on a
+    # free/oauth login can quietly run a weak flash model and rubber-stamp consensus.
+    # Emitted into every generated roster so the field is discoverable, not hidden.
+    model: str = ""
 
 
 # Default ranking of peers when auto-proposing a roster.
@@ -25,7 +30,7 @@ _PEER_RANK: list[tuple[str, str, str]] = [
     # (cli, priority, notes)
     ("codex", "high", "Second opinion, good for silent-agreement hunts"),
     ("ollama", "medium", "Local unlimited; good if a capable model is pulled"),
-    ("gemini", "low", "Free tier — use for quick opinions, not full forks"),
+    ("gemini", "low", "Pin model: to a Pro tier — unpinned + a free/oauth login silently runs weak flash"),
 ]
 
 

paircode/peerlab.py

@@ -1,14 +1,25 @@
 """Per-peer independent labs — each peer owns a parallel implementation
 of the project, with its own `.git/` for independent history.
 
-Laid out under `.peerlab/<peer-id>/` at the project root, gitignored from
-the outer repo. Seeding is one-time on first creation (rsync from project
-root minus a standard exclude list). After that, each peer's lab evolves
-independently — the peer commits, diffs, experiments in its own git.
-
-Used by the `/peerlab` slash command (separate concept from `/paircode`):
-team lead fires each peer with cwd = its lab, peers do real work and commit,
-team lead reads the resulting diffs and synthesizes.
+**Fully independent from `/paircode`.** `/peerlab` maintains its own state
+under `.peerlab/` at the project root:
+
+  .peerlab/
+    peers.yaml              # peerlab's own roster
+    alpha-critique.md       # alpha's cross-review output (optional, written by slash command)
+    peer-a-codex/           # external peer lab (full parallel implementation, own .git)
+    peer-b-gemini/
+    ...
+
+`/peerlab` does NOT read or write `.paircode/`. If you use both `/paircode`
+and `/peerlab`, each maintains its own roster independently. That's
+intentional — `/peerlab` is designed to be useful as a standalone concept.
+
+Architecture: **alpha (the interactive LLM session, e.g. Claude Code) is
+itself a peer**. Alpha's "lab" is the project root — alpha codes directly
+in the real repo. This module manages the EXTERNAL peer labs (codex,
+gemini, ollama, ...). During cross-review every participant reads every
+other participant's code.
 """
 from __future__ import annotations
 
@@ -18,10 +29,11 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Iterable
 
-from paircode.state import PaircodeState, read_peers
+import yaml
 
 
 PEERLAB_DIRNAME = ".peerlab"
+PEERLAB_PEERS_FILE = "peers.yaml"
 
 SEED_EXCLUDES: tuple[str, ...] = (
     ".git",
@@ -41,10 +53,6 @@ SEED_EXCLUDES: tuple[str, ...] = (
 
 GITIGNORE_BLOCK_HEADER = "# peerlab — per-peer independent parallel labs"
 
-# Defaults dropped into each new peer lab's own .gitignore so peer commits
-# don't accidentally include Python bytecode, editor junk, OS cruft.
-# If the lab inherited a .gitignore from the project root (rsync seed), we
-# APPEND this block — user's rules win, these are a safety net.
 LAB_GITIGNORE_BLOCK = """\
 # peerlab defaults — python + editor junk (keep peer commits clean)
 __pycache__/
@@ -66,6 +74,21 @@ htmlcov/
 LAB_GITIGNORE_MARKER = "peerlab defaults"
 
 
+# ---------------------------------------------------------------------------
+# PeerlabState — independent of PaircodeState
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class PeerlabState:
+    """`.peerlab/` state. Fully independent from `.paircode/`."""
+    root: Path                    # path to .peerlab/ dir
+    peers_path: Path              # .peerlab/peers.yaml
+
+    @property
+    def project_root(self) -> Path:
+        return self.root.parent
+
+
 @dataclass(frozen=True)
 class EnsureResult:
     peer_id: str
@@ -73,16 +96,61 @@ class EnsureResult:
     status: str  # "created" | "already-exists" | "missing-id"
 
 
+def find_peerlab(start: Path | None = None) -> PeerlabState | None:
+    """Walk up from `start` (or cwd) looking for `.peerlab/`. Return None."""
+    if start is None:
+        start = Path.cwd()
+    start = start.resolve()
+    for ancestor in [start, *start.parents]:
+        root = ancestor / PEERLAB_DIRNAME
+        if root.is_dir():
+            return PeerlabState(root=root, peers_path=root / PEERLAB_PEERS_FILE)
+    return None
+
+
+def init_peerlab(project_root: Path | None = None) -> PeerlabState:
+    """Bootstrap `.peerlab/` in `project_root` (or cwd).
+
+    Creates the dir, runs handshake to detect peer CLIs, writes a fresh
+    `peers.yaml` to `.peerlab/peers.yaml` (if missing). `handshake.propose_roster`
+    is pure — reads PATH, doesn't touch any paircode state on disk.
+    """
+    if project_root is None:
+        project_root = Path.cwd()
+    project_root = project_root.resolve()
+    root = project_root / PEERLAB_DIRNAME
+    root.mkdir(exist_ok=True)
+    peers_path = root / PEERLAB_PEERS_FILE
+    if not peers_path.exists():
+        # Pure-function import; doesn't trigger any paircode state writes.
+        from paircode.handshake import propose_roster, proposed_as_yaml_dicts
+
+        proposed = propose_roster()
+        write_peerlab_peers(peers_path, proposed_as_yaml_dicts(proposed))
+    return PeerlabState(root=root, peers_path=peers_path)
+
+
+def read_peerlab_peers(state: PeerlabState) -> list[dict]:
+    """Parse `.peerlab/peers.yaml` into list of peer dicts. `[]` if missing."""
+    if not state.peers_path.exists():
+        return []
+    data = yaml.safe_load(state.peers_path.read_text(encoding="utf-8")) or {}
+    return list(data.get("peers") or [])
+
+
+def write_peerlab_peers(peers_path: Path, peers: Iterable[dict]) -> None:
+    peers_path.write_text(
+        yaml.safe_dump({"peers": list(peers)}, sort_keys=False, default_flow_style=False),
+        encoding="utf-8",
+    )
+
+
 # ---------------------------------------------------------------------------
-# Helpers — gitignore, rsync, git init, initial commit
+# Outer-repo gitignore — keep `.peerlab/` out of alpha's git
 # ---------------------------------------------------------------------------
 
 def ensure_gitignore(project_root: Path) -> bool:
-    """Append `.peerlab/` to outer .gitignore if not already present.
-
-    Returns True if the line was added (or the file was created), False if
-    it was already there.
-    """
+    """Append `.peerlab/` to outer `.gitignore` if not already present."""
     gitignore = project_root / ".gitignore"
     existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
     for line in existing.splitlines():
@@ -95,9 +163,12 @@ def ensure_gitignore(project_root: Path) -> bool:
     return True
 
 
+# ---------------------------------------------------------------------------
+# Per-lab helpers — rsync seed, git init, initial commit, lab .gitignore
+# ---------------------------------------------------------------------------
+
 def _rsync_project(src: Path, dst: Path, excludes: Iterable[str] = SEED_EXCLUDES) -> None:
-    """Copy src → dst with standard excludes. Uses rsync if available, falls
-    back to `shutil.copytree` with an ignore function."""
+    """Copy src → dst with standard excludes. rsync if available, else shutil."""
     dst.mkdir(parents=True, exist_ok=True)
     rsync = shutil.which("rsync")
     if rsync:
@@ -108,13 +179,11 @@ def _rsync_project(src: Path, dst: Path, excludes: Iterable[str] = SEED_EXCLUDES
         subprocess.run(args, check=True)
         return
 
-    # Pure-Python fallback: copytree with an ignore func.
     exclude_set = set(excludes)
 
     def _ignore(_directory: str, names: list[str]) -> list[str]:
         ignored = []
         for n in names:
-            # Match exact name or a simple *-prefix/suffix wildcard
             if n in exclude_set:
                 ignored.append(n)
                 continue
@@ -125,23 +194,13 @@ def _rsync_project(src: Path, dst: Path, excludes: Iterable[str] = SEED_EXCLUDES
                     ignored.append(n); break
         return ignored
 
-    # copytree fails if dst exists — but our dst was just mkdir'd.
-    # Remove empty dst and let copytree re-create.
     if dst.exists() and not any(dst.iterdir()):
         dst.rmdir()
     shutil.copytree(src, dst, ignore=_ignore)
 
 
 def ensure_lab_gitignore(lab: Path) -> bool:
-    """Ensure the peer lab has Python/editor junk gitignored. Idempotent.
-
-    If the lab already has a `.gitignore` (inherited via rsync from the
-    project root), our block is appended so user rules win. If none exists
-    (greenfield), our block IS the .gitignore.
-
-    Returns True if the block was added this call, False if it was already
-    there (marker detection).
-    """
+    """Append the peerlab-defaults .gitignore block into the lab. Idempotent."""
     gitignore = lab / ".gitignore"
     existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
     if LAB_GITIGNORE_MARKER in existing:
@@ -152,10 +211,8 @@ def ensure_lab_gitignore(lab: Path) -> bool:
 
 
 def _git_init(lab: Path) -> None:
-    """`git init` inside `lab/`. No-op if already inited."""
     if (lab / ".git").exists():
         return
-    # Try modern flag first, fall back for older git.
     result = subprocess.run(
         ["git", "init", "--quiet", "--initial-branch=main", str(lab)],
         capture_output=True, text=True, check=False,
@@ -167,32 +224,22 @@ def _git_init(lab: Path) -> None:
 def _git_initial_commit(
     lab: Path, peer_id: str, message: str = "initial seed from project root"
 ) -> bool:
-    """Stage everything + commit. Returns True if a commit was made.
-
-    Authors the commit as the peer itself (`{peer_id} <{peer_id}@peerlab.local>`)
-    via lab-local git config. Every subsequent peer commit inside this lab
-    inherits that local identity — so `git log` in a peer's lab attributes
-    all work to that peer, clean replay.
-    """
+    """Stage everything + commit as peer_id. Returns True if a commit was made."""
     if not any(lab.iterdir()):
         return False
-    # Local git config — scoped to this lab, doesn't touch global identity.
     subprocess.run(["git", "-C", str(lab), "config", "user.name", peer_id], check=False)
     subprocess.run(
         ["git", "-C", str(lab), "config", "user.email", f"{peer_id}@peerlab.local"],
         check=False,
     )
     subprocess.run(["git", "-C", str(lab), "add", "-A"], check=False)
-    # Commit only if there's something staged
     diff_check = subprocess.run(
-        ["git", "-C", str(lab), "diff", "--cached", "--quiet"],
-        check=False,
+        ["git", "-C", str(lab), "diff", "--cached", "--quiet"], check=False,
     )
     if diff_check.returncode == 0:
-        return False  # nothing staged
+        return False
     subprocess.run(
-        ["git", "-C", str(lab), "commit", "--quiet", "-m", message],
-        check=False,
+        ["git", "-C", str(lab), "commit", "--quiet", "-m", message], check=False,
     )
     return True
 
@@ -201,41 +248,34 @@ def _git_initial_commit(
 # Public — ensure per-peer labs
 # ---------------------------------------------------------------------------
 
-def ensure_peer_labs(state: PaircodeState) -> list[EnsureResult]:
-    """Scaffold `.peerlab/<peer-id>/` for every peer in `peers.yaml`.
+def ensure_peer_labs(state: PeerlabState) -> list[EnsureResult]:
+    """Scaffold `.peerlab/<peer-id>/` for every peer in `.peerlab/peers.yaml`.
 
     Idempotent. On first creation of a lab:
-    - mkdir `.peerlab/<peer-id>/`
+    - mkdir
     - rsync project root → lab (minus SEED_EXCLUDES)
-    - `git init` inside lab (own repo)
-    - initial commit so HEAD exists → peers can `git diff HEAD~1` immediately
+    - drop lab .gitignore
+    - `git init` inside lab
+    - initial commit authored as peer_id so HEAD exists + log attributes clean
 
     On subsequent calls: skip labs that already have `.git/` — never re-seed.
-    Also ensures the outer `.gitignore` contains `.peerlab/` so the outer repo
-    doesn't accidentally track peer labs.
+    Also ensures the outer `.gitignore` contains `.peerlab/`.
     """
     project_root = state.project_root
-    peerlab_root = project_root / PEERLAB_DIRNAME
-    peerlab_root.mkdir(exist_ok=True)
-
     ensure_gitignore(project_root)
 
     results: list[EnsureResult] = []
-    for p in read_peers(state):
+    for p in read_peerlab_peers(state):
         pid = p.get("id") if isinstance(p, dict) else getattr(p, "id", None)
         if not pid:
-            results.append(EnsureResult(peer_id="?", lab_path=peerlab_root, status="missing-id"))
+            results.append(EnsureResult(peer_id="?", lab_path=state.root, status="missing-id"))
             continue
-        lab = peerlab_root / pid
+        lab = state.root / pid
         if (lab / ".git").exists():
             results.append(EnsureResult(peer_id=pid, lab_path=lab, status="already-exists"))
             continue
         lab.mkdir(exist_ok=True)
-        # Seed from project root (might be empty for greenfield — rsync handles fine)
         _rsync_project(project_root, lab)
-        # Drop peerlab-default .gitignore so peer commits don't pull in
-        # __pycache__, .pytest_cache, editor junk etc. Appends if the lab
-        # already inherited a .gitignore from the project root.
         ensure_lab_gitignore(lab)
         _git_init(lab)
         _git_initial_commit(lab, pid, message="initial seed from project root")
@@ -243,6 +283,6 @@ def ensure_peer_labs(state: PaircodeState) -> list[EnsureResult]:
     return results
 
 
-def peer_lab_path(state: PaircodeState, peer_id: str) -> Path:
+def peer_lab_path(state: PeerlabState, peer_id: str) -> Path:
     """Return the absolute lab path for a peer id. Does not create."""
-    return state.project_root / PEERLAB_DIRNAME / peer_id
+    return state.root / peer_id

paircode/state.py

@@ -31,6 +31,8 @@ PEERS_FILE = "peers.yaml"
 JOURNEY_FILE = "JOURNEY.md"
 FOCUS_FILE = "FOCUS.md"
 
+GITIGNORE_BLOCK_HEADER = "# paircode — adversarial multi-LLM peer review state"
+
 
 def _now_iso() -> str:
     return _dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -127,6 +129,24 @@ def ensure_peer_dirs(state: PaircodeState, proposed: Iterable) -> list[Path]:
     return created
 
 
+def ensure_gitignore(project_root: Path) -> bool:
+    """Append `.paircode/` to outer `.gitignore` if not already present.
+
+    Mirrors `peerlab.ensure_gitignore`. Idempotent; returns True when a line
+    is added, False when `.paircode/` (or `.paircode`) is already listed.
+    """
+    gitignore = project_root / ".gitignore"
+    existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
+    for line in existing.splitlines():
+        s = line.strip()
+        if s in (".paircode/", ".paircode"):
+            return False
+    tail = existing.rstrip()
+    new_text = (tail + "\n\n" if tail else "") + GITIGNORE_BLOCK_HEADER + "\n.paircode/\n"
+    gitignore.write_text(new_text, encoding="utf-8")
+    return True
+
+
 def init_paircode(project_root: Path | None = None, force: bool = False) -> PaircodeState:
     """Bootstrap .paircode/ in `project_root` (or cwd). Returns the new state.
 
@@ -143,6 +163,7 @@ def init_paircode(project_root: Path | None = None, force: bool = False) -> Pair
         )
     root.mkdir(parents=True, exist_ok=True)
     (root / "sandbox").mkdir(exist_ok=True)
+    ensure_gitignore(project_root)
 
     journey = _render(
         _read_template("JOURNEY.md"),

paircode/templates/claude/commands/peerlab.md

@@ -1,34 +1,34 @@
 ---
-description: peerlab — each peer owns a parallel lab with its own git. Peers write real code, then cross-review each other's labs, then team lead synthesizes.
+description: peerlab — alpha and peers each build in their own lab, then cross-review each other's code. Alpha is one of the peers.
 ---
 
-You are the team lead for a `/peerlab` run. Each peer has its own persistent lab at `.peerlab/<peer-id>/` with its own `.git/`. Peers **own** their labs. The flow is:
+You are the orchestrator of a `/peerlab` run. In `/peerlab`, **alpha (this Claude session) is one of the peers** — alpha builds in the project root while external peers build in their own labs at `.peerlab/<peer-id>/`. Then every participant reads every other participant's code and writes a critique. Finally you (wearing the orchestrator hat) synthesize the full cross-review into a single chat message.
 
-1. **Work round** — every peer builds in its own lab.
-2. **Cross-review round** — every peer reads the OTHER peers' labs and writes an honest critique (`CRITIQUES.md`) in its own lab. Peer-reviews-peer is the adversarial content; do NOT skip this.
-3. **Team-lead synthesis** — alpha reads both the code diffs AND each peer's critiques, delivers the final take.
+This mirrors mlmodel's `/peerkickoff`: claude has `LABS/claude-kiss/`, codex has `LABS/codex-kiss/`, they build in parallel, cross-audit, iterate. Same pattern — alpha's lab is just the project root instead of a subdir.
 
-Separate concept from `/paircode` — no focus dirs, no stages, no consensus.md. Real code evolution + peer critiques on disk, synthesis in the chat.
+Separate concept from `/paircode` — no focus dirs, no stages, no consensus.md. Real code in real labs + peer critiques on disk + your final synthesis in chat.
 
-`$ARGUMENTS` is the user's raw prompt. Pass it through verbatim.
+`$ARGUMENTS` is the user's raw prompt.
 
 ## Step 1 — Bootstrap (silent via Bash)
 
 ```bash
-paircode peerlab ensure           # scaffolds + seeds + git-inits each lab (idempotent)
-PEERS=$(paircode roster --alpha claude)
+paircode peerlab ensure           # idempotent: scaffold/seed/git-init each external peer lab
+PEERS=$(paircode peerlab roster --alpha claude)   # external peers (excludes alpha/claude)
 ```
 
-`paircode peerlab ensure` is safe to run every time. First time: copies the project root into each peer's lab (minus standard excludes) and `git init`s it. Subsequent times: no-op.
+Note: `/peerlab` is fully independent from `/paircode` — it maintains its own roster at `.peerlab/peers.yaml` and never touches `.paircode/`. You can use `/peerlab` on a project that has never seen `/paircode`.
 
-## Step 2 — Work round (fire every peer in parallel)
+## Step 2 — Work round (alpha + peers in parallel)
 
-For each peer-id in `$PEERS`, spawn one subagent via the Agent tool (`subagent_type=general-purpose`, `run_in_background=true`) — all in a single message so they run concurrently.
+**Two streams happen concurrently.** Do NOT serialize them.
 
-Each subagent's prompt:
+**Stream A — you, alpha:** implement `$ARGUMENTS` directly in the project root using your own tools (Read, Write, Edit, Bash, run tests). The project root IS alpha's lab. Leave your changes uncommitted in the working tree — the user reviews alpha's diff and commits manually (or discards). You are a peer building alongside others, not a distant reader.
+
+**Stream B — external peers:** for each peer-id in `$PEERS`, spawn one subagent via Agent tool (`subagent_type=general-purpose`, `run_in_background=true`) — ALL in a single message so subagents run concurrently with each other AND with Stream A. Each subagent's prompt:
 
 ```
-Monitor peer {peer-id} on the work round. Run this shell command and wait:
+Monitor peer {peer-id} on the work round. Run:
 
   paircode peerlab invoke {peer-id} "<the user's prompt verbatim>"
 
@@ -36,78 +36,84 @@ That fires the peer with cwd = .peerlab/{peer-id}/ (its own lab). The peer
 commits its work in its own .git before finishing.
 
 After it returns, gather:
-  1. The peer's stdout (narrative).
+  1. Peer's stdout narrative.
   2. git -C .peerlab/{peer-id} log --oneline -5
   3. git -C .peerlab/{peer-id} diff HEAD~1 HEAD --stat
 
 Report back under 400 words: peer-id, ok=yes/no, duration, 1-line summary,
-and the git stat.
+git stat output.
 ```
 
-Wait for every peer to finish the work round before starting Step 3.
+Once every Stream B subagent has reported AND you've finished Stream A, proceed to Step 3.
+
+## Step 3 — Cross-review round (everyone reads everyone)
+
+**This is the adversarial heart of /peerlab.** Every participant — alpha AND every external peer — reads every OTHER participant's code and writes a critique. Do not skip.
 
-## Step 3 — Cross-review round (peers read each other's labs)
+If fewer than 2 participants made real progress in Step 2 (e.g., only alpha; every peer failed), you can skip Step 3 — note it in the synthesis. Otherwise:
 
-This is the adversarial heart of `/peerlab`. Every peer now reads every OTHER peer's lab and writes an honest critique. Do not skip this — it's what makes `/peerlab` different from "parallel output".
+**Stream A — you, alpha, critiquing every peer lab:** for each peer-id in `$PEERS`:
+- `git -C .peerlab/<peer-id> log -p HEAD~1..HEAD` — read the full diff
+- `Read` individual files inside the lab if the diff doesn't give enough context
 
-If only ONE peer finished Step 2 successfully, skip Step 3 (nobody to cross-review) and note it in the final synthesis. Otherwise:
+Write your consolidated critique of the external peer labs to `.peerlab/alpha-critique.md` (at the `.peerlab/` root, NOT inside any peer's lab). Severity-ranked, file:line citations pointing at each peer's files. One section per external peer. Don't pile on, don't rubber-stamp.
 
-For each peer-id in the set of peers that succeeded in Step 2, spawn one subagent (Agent tool, `run_in_background=true`) — all in one message. Each subagent's prompt:
+**Stream B — each external peer, critiquing alpha + siblings:** for each peer-id in `$PEERS`, spawn a subagent (Agent tool, `run_in_background=true`) — ALL in one message, parallel to Stream A. Each subagent's prompt:
 
 ```
-Monitor peer {peer-id} on the cross-review round. Run this shell command
-and wait:
+Monitor peer {peer-id} on the cross-review round. Run:
 
   paircode peerlab invoke {peer-id} "You already committed your own work
-  in your lab — your cwd. Now cross-review every OTHER peer's lab.
-  Siblings live at ../<other-peer-id>/ relative to your cwd. List them
-  with `ls ..` and exclude your own id ({peer-id}).
+  in your lab (your cwd). Now cross-review every OTHER participant:
 
-  For each other peer:
-    git -C ../<other-peer-id> log --oneline
-    git -C ../<other-peer-id> diff HEAD~1 HEAD
-    # read the changed files directly if the diff isn't enough
+  (1) Alpha's work is at the project root. From your cwd that's ../../ .
+      Read what alpha did — either:
+        git -C ../../ diff HEAD            (if alpha's changes are uncommitted — usually the case)
+        git -C ../../ log --oneline -5 + diff HEAD~1 HEAD   (if alpha committed)
+      Then Read the specific files alpha touched.
 
-  Write CRITIQUES.md in YOUR cwd (your own lab) with one section per
-  peer you reviewed. Severity-ranked findings with file:line citations
-  pointing at the OTHER peer's files. Be specific. Don't pile on,
-  don't rubber-stamp. Cite real lines, not vibes.
+  (2) Sibling peer labs are at ../<other-peer-id>/ . For each:
+        git -C ../<other-peer-id> log -p HEAD~1..HEAD
+
+  Write CRITIQUES.md in your own cwd (your own lab) with one section per
+  participant reviewed. Include alpha. Severity-ranked. file:line citations
+  pointing at the OTHER participant's files. Don't pile on, don't rubber-stamp.
 
-  Then commit your critique:
     git add CRITIQUES.md
     git commit -m 'cross-review'"
 
-After it returns, verify:
-  - .peerlab/{peer-id}/CRITIQUES.md exists and has non-trivial content
-  - git -C .peerlab/{peer-id} log -1 --oneline mentions 'cross-review'
-
-Report back under 300 words: peer-id, ok=yes/no, duration, and a 1-line
-summary of whose code this peer found most/least convincing.
+After it returns, verify .peerlab/{peer-id}/CRITIQUES.md exists with a
+non-trivial section for alpha plus each sibling. Report back under 300
+words: peer-id, ok=yes/no, duration, 1-line summary of whose code this
+peer found most/least convincing.
 ```
 
-Wait for every peer to finish cross-review before Step 4.
+Wait for Stream A AND every Stream B subagent before Step 4.
 
 ## Step 4 — Synthesize (one message to user, ≤300 words)
 
-For each peer, read BOTH:
-- The work diff: `git -C .peerlab/<peer-id> log -p HEAD~2..HEAD` (covers work commit + critique commit — 2 commits if both rounds ran, 1 if Step 3 was skipped).
-- The critique: `.peerlab/<peer-id>/CRITIQUES.md` — what THIS peer thought of the OTHERS.
+Read the full cross-review:
+- `.peerlab/alpha-critique.md` — your own critique of the peer labs
+- Each `.peerlab/<peer-id>/CRITIQUES.md` — each peer's critique of alpha + siblings
+- Alpha's own work in the project root (you remember; you did it in Step 2)
+- Each peer's work diff (already gathered in Step 2)
 
-Then produce a tight team-lead synthesis that leans on the peers' own voices, not just yours:
+Synthesize with the peers' voices, not just yours:
 
-- **Per-peer implementation summary**: 1–2 lines each — files touched, LOC delta, the shape of the approach.
-- **What peers said about each other**: extract the sharpest findings from each `CRITIQUES.md`. If codex called out a bug in gemini's lab with a file:line, quote it. If gemini pointed at an edge case codex missed, quote it. These are the adversarial moments — don't bury them.
-- **Cross-cutting themes**: where did peers agree about what's wrong? Where did they disagree? Disagreement is signal.
-- **Honest head-to-head**: which lab made the cleanest move, informed by the peer critiques? Don't play favorites, don't hedge.
-- **What to pull into alpha**: if a peer's approach is objectively better, name files + approach. Don't do the pull yourself — recommend.
+- **Implementation summaries** — alpha's approach in project root, each peer's approach in its lab. 1–2 lines each.
+- **What peers said about alpha** — pull the sharpest findings from each peer's CRITIQUES.md about YOUR work. Quote them, don't paraphrase away the teeth.
+- **What alpha said about peers** — reference your alpha-critique.md findings.
+- **Cross-cutting themes** — where did critiques converge? That's high-signal consensus.
+- **Head-to-head** — which implementation won, informed by the cross-review? Don't play favorites, don't hedge.
+- **Next action** — merge a peer's pattern into alpha? Adjust alpha's implementation based on a peer's critique? Fire a peer to self-heal based on alpha's critique? Recommend; user decides.
 
-No focus dirs. No consensus.md. Just the synthesis as your chat reply.
+No focus dirs, no consensus.md file. Just your synthesis as the chat reply.
 
 ## Guardrails
 
-- **Alpha (this session) does NOT edit `.peerlab/<peer-id>/`.** Peers own their labs. You only read.
-- **Alpha does NOT implement the user's prompt in the project root.** That's a `/paircode` job or a direct Claude Code ask. `/peerlab` is strictly "peers go build + cross-review; I read the diffs and critiques."
-- **Fire every peer** unless the user's prompt explicitly names `--peer`/`--peers`. Watchdog protects against hangs.
-- **Do not skip Step 3.** The cross-review round is the point. If only one peer made it through Step 2, note why in the synthesis and skip Step 3 explicitly.
-- **If a peer fails** (hung, errored, no commits), note it in the synthesis and continue. One flaky peer doesn't sink the run.
-- **No AI attribution** in anything you write — see the maintainer's CLAUDE.md.
+- **Alpha IS a peer.** You build in project root during Step 2 — not sitting out.
+- **Uncommitted changes in project root stay uncommitted.** User reviews alpha's diff + commits manually. Do NOT `git add` or `git commit` in the project root as part of `/peerlab`.
+- **External peers commit inside their own labs** — their `.git/` is isolated, `.peerlab/` is gitignored from the outer repo.
+- **Fire every external peer** unless the user's prompt explicitly names `--peer`/`--peers`. Watchdog caps silent hangs at ~32s.
+- **Do not skip Step 3** unless fewer than 2 participants succeeded in Step 2. Cross-review is the point.
+- **No AI attribution** in any artifact you write (alpha-critique.md, chat synthesis). See the maintainer's CLAUDE.md.

paircode/templates/peers.yaml

@@ -10,7 +10,11 @@
 # Fields:
 #   id              — peer-a, peer-b, peer-c, ... (unique, immutable)
 #   cli             — the command-line binary used to invoke this peer (claude/codex/gemini/ollama/aider/...)
-#   model           — specific model string (optional; CLI default if omitted)
+#   model           — specific model string. Optional but RECOMMENDED. If omitted,
+#                     the CLI picks its own default — which on a free/misconfigured
+#                     login can silently be a weak flash-tier model that just agrees
+#                     with you. Pin a Pro tier for real fork weight (e.g. gemini: a
+#                     *-pro* model; claude: sonnet/opus). Empty = CLI default.
 #   priority        — high | medium | low (used when budget is tight)
 #   daily_budget    — advisory only for now; paircode logs when a peer sits out
 #

paircode-0.13.2.data/data/paircode/templates/claude/commands/peerlab.md

@@ -0,0 +1,119 @@
+---
+description: peerlab — alpha and peers each build in their own lab, then cross-review each other's code. Alpha is one of the peers.
+---
+
+You are the orchestrator of a `/peerlab` run. In `/peerlab`, **alpha (this Claude session) is one of the peers** — alpha builds in the project root while external peers build in their own labs at `.peerlab/<peer-id>/`. Then every participant reads every other participant's code and writes a critique. Finally you (wearing the orchestrator hat) synthesize the full cross-review into a single chat message.
+
+This mirrors mlmodel's `/peerkickoff`: claude has `LABS/claude-kiss/`, codex has `LABS/codex-kiss/`, they build in parallel, cross-audit, iterate. Same pattern — alpha's lab is just the project root instead of a subdir.
+
+Separate concept from `/paircode` — no focus dirs, no stages, no consensus.md. Real code in real labs + peer critiques on disk + your final synthesis in chat.
+
+`$ARGUMENTS` is the user's raw prompt.
+
+## Step 1 — Bootstrap (silent via Bash)
+
+```bash
+paircode peerlab ensure           # idempotent: scaffold/seed/git-init each external peer lab
+PEERS=$(paircode peerlab roster --alpha claude)   # external peers (excludes alpha/claude)
+```
+
+Note: `/peerlab` is fully independent from `/paircode` — it maintains its own roster at `.peerlab/peers.yaml` and never touches `.paircode/`. You can use `/peerlab` on a project that has never seen `/paircode`.
+
+## Step 2 — Work round (alpha + peers in parallel)
+
+**Two streams happen concurrently.** Do NOT serialize them.
+
+**Stream A — you, alpha:** implement `$ARGUMENTS` directly in the project root using your own tools (Read, Write, Edit, Bash, run tests). The project root IS alpha's lab. Leave your changes uncommitted in the working tree — the user reviews alpha's diff and commits manually (or discards). You are a peer building alongside others, not a distant reader.
+
+**Stream B — external peers:** for each peer-id in `$PEERS`, spawn one subagent via Agent tool (`subagent_type=general-purpose`, `run_in_background=true`) — ALL in a single message so subagents run concurrently with each other AND with Stream A. Each subagent's prompt:
+
+```
+Monitor peer {peer-id} on the work round. Run:
+
+  paircode peerlab invoke {peer-id} "<the user's prompt verbatim>"
+
+That fires the peer with cwd = .peerlab/{peer-id}/ (its own lab). The peer
+commits its work in its own .git before finishing.
+
+After it returns, gather:
+  1. Peer's stdout narrative.
+  2. git -C .peerlab/{peer-id} log --oneline -5
+  3. git -C .peerlab/{peer-id} diff HEAD~1 HEAD --stat
+
+Report back under 400 words: peer-id, ok=yes/no, duration, 1-line summary,
+git stat output.
+```
+
+Once every Stream B subagent has reported AND you've finished Stream A, proceed to Step 3.
+
+## Step 3 — Cross-review round (everyone reads everyone)
+
+**This is the adversarial heart of /peerlab.** Every participant — alpha AND every external peer — reads every OTHER participant's code and writes a critique. Do not skip.
+
+If fewer than 2 participants made real progress in Step 2 (e.g., only alpha; every peer failed), you can skip Step 3 — note it in the synthesis. Otherwise:
+
+**Stream A — you, alpha, critiquing every peer lab:** for each peer-id in `$PEERS`:
+- `git -C .peerlab/<peer-id> log -p HEAD~1..HEAD` — read the full diff
+- `Read` individual files inside the lab if the diff doesn't give enough context
+
+Write your consolidated critique of the external peer labs to `.peerlab/alpha-critique.md` (at the `.peerlab/` root, NOT inside any peer's lab). Severity-ranked, file:line citations pointing at each peer's files. One section per external peer. Don't pile on, don't rubber-stamp.
+
+**Stream B — each external peer, critiquing alpha + siblings:** for each peer-id in `$PEERS`, spawn a subagent (Agent tool, `run_in_background=true`) — ALL in one message, parallel to Stream A. Each subagent's prompt:
+
+```
+Monitor peer {peer-id} on the cross-review round. Run:
+
+  paircode peerlab invoke {peer-id} "You already committed your own work
+  in your lab (your cwd). Now cross-review every OTHER participant:
+
+  (1) Alpha's work is at the project root. From your cwd that's ../../ .
+      Read what alpha did — either:
+        git -C ../../ diff HEAD            (if alpha's changes are uncommitted — usually the case)
+        git -C ../../ log --oneline -5 + diff HEAD~1 HEAD   (if alpha committed)
+      Then Read the specific files alpha touched.
+
+  (2) Sibling peer labs are at ../<other-peer-id>/ . For each:
+        git -C ../<other-peer-id> log -p HEAD~1..HEAD
+
+  Write CRITIQUES.md in your own cwd (your own lab) with one section per
+  participant reviewed. Include alpha. Severity-ranked. file:line citations
+  pointing at the OTHER participant's files. Don't pile on, don't rubber-stamp.
+
+    git add CRITIQUES.md
+    git commit -m 'cross-review'"
+
+After it returns, verify .peerlab/{peer-id}/CRITIQUES.md exists with a
+non-trivial section for alpha plus each sibling. Report back under 300
+words: peer-id, ok=yes/no, duration, 1-line summary of whose code this
+peer found most/least convincing.
+```
+
+Wait for Stream A AND every Stream B subagent before Step 4.
+
+## Step 4 — Synthesize (one message to user, ≤300 words)
+
+Read the full cross-review:
+- `.peerlab/alpha-critique.md` — your own critique of the peer labs
+- Each `.peerlab/<peer-id>/CRITIQUES.md` — each peer's critique of alpha + siblings
+- Alpha's own work in the project root (you remember; you did it in Step 2)
+- Each peer's work diff (already gathered in Step 2)
+
+Synthesize with the peers' voices, not just yours:
+
+- **Implementation summaries** — alpha's approach in project root, each peer's approach in its lab. 1–2 lines each.
+- **What peers said about alpha** — pull the sharpest findings from each peer's CRITIQUES.md about YOUR work. Quote them, don't paraphrase away the teeth.
+- **What alpha said about peers** — reference your alpha-critique.md findings.
+- **Cross-cutting themes** — where did critiques converge? That's high-signal consensus.
+- **Head-to-head** — which implementation won, informed by the cross-review? Don't play favorites, don't hedge.
+- **Next action** — merge a peer's pattern into alpha? Adjust alpha's implementation based on a peer's critique? Fire a peer to self-heal based on alpha's critique? Recommend; user decides.
+
+No focus dirs, no consensus.md file. Just your synthesis as the chat reply.
+
+## Guardrails
+
+- **Alpha IS a peer.** You build in project root during Step 2 — not sitting out.
+- **Uncommitted changes in project root stay uncommitted.** User reviews alpha's diff + commits manually. Do NOT `git add` or `git commit` in the project root as part of `/peerlab`.
+- **External peers commit inside their own labs** — their `.git/` is isolated, `.peerlab/` is gitignored from the outer repo.
+- **Fire every external peer** unless the user's prompt explicitly names `--peer`/`--peers`. Watchdog caps silent hangs at ~32s.
+- **Do not skip Step 3** unless fewer than 2 participants succeeded in Step 2. Cross-review is the point.
+- **No AI attribution** in any artifact you write (alpha-critique.md, chat synthesis). See the maintainer's CLAUDE.md.

{paircode-0.12.4.data → paircode-0.13.2.data}/data/paircode/templates/peers.yaml

@@ -10,7 +10,11 @@
 # Fields:
 #   id              — peer-a, peer-b, peer-c, ... (unique, immutable)
 #   cli             — the command-line binary used to invoke this peer (claude/codex/gemini/ollama/aider/...)
-#   model           — specific model string (optional; CLI default if omitted)
+#   model           — specific model string. Optional but RECOMMENDED. If omitted,
+#                     the CLI picks its own default — which on a free/misconfigured
+#                     login can silently be a weak flash-tier model that just agrees
+#                     with you. Pin a Pro tier for real fork weight (e.g. gemini: a
+#                     *-pro* model; claude: sonnet/opus). Empty = CLI default.
 #   priority        — high | medium | low (used when budget is tight)
 #   daily_budget    — advisory only for now; paircode logs when a peer sits out
 #

{paircode-0.12.4.dist-info → paircode-0.13.2.dist-info}/METADATA

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

paircode-0.13.2.dist-info/RECORD

@@ -0,0 +1,30 @@
+paircode/__init__.py,sha256=K8qZD2jJXH_pWsZiBgeyuBX65A7ejdGldxRzPtI38vY,167
+paircode/__main__.py,sha256=nj3xFbNqz8UN8UQJSJ1mDyPTD2PZ-7PZ1TF-eTyBbgA,69
+paircode/cli.py,sha256=12pRd0gGP8gZ4iqD702f8VNZRtoQCWQABDZNqLYWL0M,21573
+paircode/converge.py,sha256=zt5hHQUffiD-12enuASHGnp3Xc4LfufbF13rpWLI4sE,1966
+paircode/detect.py,sha256=41XxPw7sTRdxieLPc9L2zsxFteIPBr59ObYj13kUVl0,1426
+paircode/handshake.py,sha256=hlvwPLdxlaqNekQXBPlKU78SPwckHGSXI71LwQW44ck,2098
+paircode/installer.py,sha256=0RVHBg1qgm4v7rdp4a4k8_rx04F_DEN_9uFfHIsuf4o,13155
+paircode/peerlab.py,sha256=YELTyU4HdPqo5zhvH9Nol0xrVmdXc0btnTtxxgeMWaU,10167
+paircode/runner.py,sha256=9-Kn3wdd87PjnfOlKbHDSapucJe2kCb1Kho99DEX73I,4699
+paircode/state.py,sha256=cEzBPZ-5QZMst113kSLH_YfcE0GF6ZEVvYJnfFnb1us,7416
+paircode/util.py,sha256=eqvd0RCaOZgK0g6a7G03y-sJ_w4xYjCZ9k4oH2gmytw,477
+paircode/templates/FOCUS.md,sha256=BL3I6bjwezqzBSksRb2aYXY_L8Ff4vqZfhvGAPb9r9E,689
+paircode/templates/JOURNEY.md,sha256=GAM2RJ42T5JElFYPiv0nIUCG0vr5q7csXoRsrm4VMwY,464
+paircode/templates/peers.yaml,sha256=iTlKrfy9Czsfslbv0YsihZmNedwCEihtw9vMvpIXtKo,1177
+paircode/templates/claude/commands/paircode.md,sha256=K5FBXhDbJFt0IunBPvHSfbeYp2yDrZRjR1phpWJQ8Fg,11432
+paircode/templates/claude/commands/peerlab.md,sha256=7svj_kBag_S_CRMYSRxc1CglK7MI7n75H-H0NAQKpbM,7209
+paircode/templates/codex/commands/paircode.md,sha256=QEnq-JG_CuAU5Y4KSVXZvUHbvrIy0bTCXxZRV01ZNWE,8396
+paircode/templates/gemini/commands/paircode.toml,sha256=ruvY6xV5BpAKxdNK7dyEnSMreNRykDfmgKk9DAK1YxA,7551
+paircode-0.13.2.data/data/paircode/templates/FOCUS.md,sha256=BL3I6bjwezqzBSksRb2aYXY_L8Ff4vqZfhvGAPb9r9E,689
+paircode-0.13.2.data/data/paircode/templates/JOURNEY.md,sha256=GAM2RJ42T5JElFYPiv0nIUCG0vr5q7csXoRsrm4VMwY,464
+paircode-0.13.2.data/data/paircode/templates/peers.yaml,sha256=iTlKrfy9Czsfslbv0YsihZmNedwCEihtw9vMvpIXtKo,1177
+paircode-0.13.2.data/data/paircode/templates/claude/commands/paircode.md,sha256=K5FBXhDbJFt0IunBPvHSfbeYp2yDrZRjR1phpWJQ8Fg,11432
+paircode-0.13.2.data/data/paircode/templates/claude/commands/peerlab.md,sha256=7svj_kBag_S_CRMYSRxc1CglK7MI7n75H-H0NAQKpbM,7209
+paircode-0.13.2.data/data/paircode/templates/codex/commands/paircode.md,sha256=QEnq-JG_CuAU5Y4KSVXZvUHbvrIy0bTCXxZRV01ZNWE,8396
+paircode-0.13.2.data/data/paircode/templates/gemini/commands/paircode.toml,sha256=ruvY6xV5BpAKxdNK7dyEnSMreNRykDfmgKk9DAK1YxA,7551
+paircode-0.13.2.dist-info/METADATA,sha256=P3Ugf67lqVZsW03EFRWURGtMnw31f2SAnXr9ksrcJp8,7724
+paircode-0.13.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+paircode-0.13.2.dist-info/entry_points.txt,sha256=Xws2Px0qjasysoJikWE8LokoojG2_7qwOh8vTF-v9K0,47
+paircode-0.13.2.dist-info/licenses/LICENSE,sha256=2z2DTvqat4kmyHNEC8ehgOC5fBtyENHg2-Z0MiY_rxM,1074
+paircode-0.13.2.dist-info/RECORD,,

{paircode-0.12.4.dist-info → paircode-0.13.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any

paircode-0.12.4.data/data/paircode/templates/claude/commands/peerlab.md

@@ -1,113 +0,0 @@
----
-description: peerlab — each peer owns a parallel lab with its own git. Peers write real code, then cross-review each other's labs, then team lead synthesizes.
----
-
-You are the team lead for a `/peerlab` run. Each peer has its own persistent lab at `.peerlab/<peer-id>/` with its own `.git/`. Peers **own** their labs. The flow is:
-
-1. **Work round** — every peer builds in its own lab.
-2. **Cross-review round** — every peer reads the OTHER peers' labs and writes an honest critique (`CRITIQUES.md`) in its own lab. Peer-reviews-peer is the adversarial content; do NOT skip this.
-3. **Team-lead synthesis** — alpha reads both the code diffs AND each peer's critiques, delivers the final take.
-
-Separate concept from `/paircode` — no focus dirs, no stages, no consensus.md. Real code evolution + peer critiques on disk, synthesis in the chat.
-
-`$ARGUMENTS` is the user's raw prompt. Pass it through verbatim.
-
-## Step 1 — Bootstrap (silent via Bash)
-
-```bash
-paircode peerlab ensure           # scaffolds + seeds + git-inits each lab (idempotent)
-PEERS=$(paircode roster --alpha claude)
-```
-
-`paircode peerlab ensure` is safe to run every time. First time: copies the project root into each peer's lab (minus standard excludes) and `git init`s it. Subsequent times: no-op.
-
-## Step 2 — Work round (fire every peer in parallel)
-
-For each peer-id in `$PEERS`, spawn one subagent via the Agent tool (`subagent_type=general-purpose`, `run_in_background=true`) — all in a single message so they run concurrently.
-
-Each subagent's prompt:
-
-```
-Monitor peer {peer-id} on the work round. Run this shell command and wait:
-
-  paircode peerlab invoke {peer-id} "<the user's prompt verbatim>"
-
-That fires the peer with cwd = .peerlab/{peer-id}/ (its own lab). The peer
-commits its work in its own .git before finishing.
-
-After it returns, gather:
-  1. The peer's stdout (narrative).
-  2. git -C .peerlab/{peer-id} log --oneline -5
-  3. git -C .peerlab/{peer-id} diff HEAD~1 HEAD --stat
-
-Report back under 400 words: peer-id, ok=yes/no, duration, 1-line summary,
-and the git stat.
-```
-
-Wait for every peer to finish the work round before starting Step 3.
-
-## Step 3 — Cross-review round (peers read each other's labs)
-
-This is the adversarial heart of `/peerlab`. Every peer now reads every OTHER peer's lab and writes an honest critique. Do not skip this — it's what makes `/peerlab` different from "parallel output".
-
-If only ONE peer finished Step 2 successfully, skip Step 3 (nobody to cross-review) and note it in the final synthesis. Otherwise:
-
-For each peer-id in the set of peers that succeeded in Step 2, spawn one subagent (Agent tool, `run_in_background=true`) — all in one message. Each subagent's prompt:
-
-```
-Monitor peer {peer-id} on the cross-review round. Run this shell command
-and wait:
-
-  paircode peerlab invoke {peer-id} "You already committed your own work
-  in your lab — your cwd. Now cross-review every OTHER peer's lab.
-  Siblings live at ../<other-peer-id>/ relative to your cwd. List them
-  with `ls ..` and exclude your own id ({peer-id}).
-
-  For each other peer:
-    git -C ../<other-peer-id> log --oneline
-    git -C ../<other-peer-id> diff HEAD~1 HEAD
-    # read the changed files directly if the diff isn't enough
-
-  Write CRITIQUES.md in YOUR cwd (your own lab) with one section per
-  peer you reviewed. Severity-ranked findings with file:line citations
-  pointing at the OTHER peer's files. Be specific. Don't pile on,
-  don't rubber-stamp. Cite real lines, not vibes.
-
-  Then commit your critique:
-    git add CRITIQUES.md
-    git commit -m 'cross-review'"
-
-After it returns, verify:
-  - .peerlab/{peer-id}/CRITIQUES.md exists and has non-trivial content
-  - git -C .peerlab/{peer-id} log -1 --oneline mentions 'cross-review'
-
-Report back under 300 words: peer-id, ok=yes/no, duration, and a 1-line
-summary of whose code this peer found most/least convincing.
-```
-
-Wait for every peer to finish cross-review before Step 4.
-
-## Step 4 — Synthesize (one message to user, ≤300 words)
-
-For each peer, read BOTH:
-- The work diff: `git -C .peerlab/<peer-id> log -p HEAD~2..HEAD` (covers work commit + critique commit — 2 commits if both rounds ran, 1 if Step 3 was skipped).
-- The critique: `.peerlab/<peer-id>/CRITIQUES.md` — what THIS peer thought of the OTHERS.
-
-Then produce a tight team-lead synthesis that leans on the peers' own voices, not just yours:
-
-- **Per-peer implementation summary**: 1–2 lines each — files touched, LOC delta, the shape of the approach.
-- **What peers said about each other**: extract the sharpest findings from each `CRITIQUES.md`. If codex called out a bug in gemini's lab with a file:line, quote it. If gemini pointed at an edge case codex missed, quote it. These are the adversarial moments — don't bury them.
-- **Cross-cutting themes**: where did peers agree about what's wrong? Where did they disagree? Disagreement is signal.
-- **Honest head-to-head**: which lab made the cleanest move, informed by the peer critiques? Don't play favorites, don't hedge.
-- **What to pull into alpha**: if a peer's approach is objectively better, name files + approach. Don't do the pull yourself — recommend.
-
-No focus dirs. No consensus.md. Just the synthesis as your chat reply.
-
-## Guardrails
-
-- **Alpha (this session) does NOT edit `.peerlab/<peer-id>/`.** Peers own their labs. You only read.
-- **Alpha does NOT implement the user's prompt in the project root.** That's a `/paircode` job or a direct Claude Code ask. `/peerlab` is strictly "peers go build + cross-review; I read the diffs and critiques."
-- **Fire every peer** unless the user's prompt explicitly names `--peer`/`--peers`. Watchdog protects against hangs.
-- **Do not skip Step 3.** The cross-review round is the point. If only one peer made it through Step 2, note why in the synthesis and skip Step 3 explicitly.
-- **If a peer fails** (hung, errored, no commits), note it in the synthesis and continue. One flaky peer doesn't sink the run.
-- **No AI attribution** in anything you write — see the maintainer's CLAUDE.md.

paircode-0.12.4.dist-info/RECORD

@@ -1,30 +0,0 @@
-paircode/__init__.py,sha256=KaQh-Ad75QE_KNJInKMirtsdbq84QM_xQfpaTbIkS4E,167
-paircode/__main__.py,sha256=nj3xFbNqz8UN8UQJSJ1mDyPTD2PZ-7PZ1TF-eTyBbgA,69
-paircode/cli.py,sha256=XgMRVH56cxK8J36vut9pmNeofhql6UxBo6zDwdxUuTU,19065
-paircode/converge.py,sha256=zt5hHQUffiD-12enuASHGnp3Xc4LfufbF13rpWLI4sE,1966
-paircode/detect.py,sha256=41XxPw7sTRdxieLPc9L2zsxFteIPBr59ObYj13kUVl0,1426
-paircode/handshake.py,sha256=QDYZOiBVeZsmPogr9RX_ky9iu7wbAimU34bT7JWlboI,1713
-paircode/installer.py,sha256=0RVHBg1qgm4v7rdp4a4k8_rx04F_DEN_9uFfHIsuf4o,13155
-paircode/peerlab.py,sha256=7rYIge71AalpHSvhjPHatj7S33dtgKYCq4WWLNBT5UE,9082
-paircode/runner.py,sha256=9-Kn3wdd87PjnfOlKbHDSapucJe2kCb1Kho99DEX73I,4699
-paircode/state.py,sha256=LG2YQ6a92HEXf70F655jUk7-vtJZfs7kTBS01TI3GwI,6563
-paircode/util.py,sha256=eqvd0RCaOZgK0g6a7G03y-sJ_w4xYjCZ9k4oH2gmytw,477
-paircode/templates/FOCUS.md,sha256=BL3I6bjwezqzBSksRb2aYXY_L8Ff4vqZfhvGAPb9r9E,689
-paircode/templates/JOURNEY.md,sha256=GAM2RJ42T5JElFYPiv0nIUCG0vr5q7csXoRsrm4VMwY,464
-paircode/templates/peers.yaml,sha256=4c6NYi0MDvUXvWxr0slF82wDl4YmjfNndtD5kkNVaCE,839
-paircode/templates/claude/commands/paircode.md,sha256=K5FBXhDbJFt0IunBPvHSfbeYp2yDrZRjR1phpWJQ8Fg,11432
-paircode/templates/claude/commands/peerlab.md,sha256=0-vI4S9HChJylLC_wbZ5bScAqWjmHMsSfYsIq_CNl_8,6079
-paircode/templates/codex/commands/paircode.md,sha256=QEnq-JG_CuAU5Y4KSVXZvUHbvrIy0bTCXxZRV01ZNWE,8396
-paircode/templates/gemini/commands/paircode.toml,sha256=ruvY6xV5BpAKxdNK7dyEnSMreNRykDfmgKk9DAK1YxA,7551
-paircode-0.12.4.data/data/paircode/templates/FOCUS.md,sha256=BL3I6bjwezqzBSksRb2aYXY_L8Ff4vqZfhvGAPb9r9E,689
-paircode-0.12.4.data/data/paircode/templates/JOURNEY.md,sha256=GAM2RJ42T5JElFYPiv0nIUCG0vr5q7csXoRsrm4VMwY,464
-paircode-0.12.4.data/data/paircode/templates/peers.yaml,sha256=4c6NYi0MDvUXvWxr0slF82wDl4YmjfNndtD5kkNVaCE,839
-paircode-0.12.4.data/data/paircode/templates/claude/commands/paircode.md,sha256=K5FBXhDbJFt0IunBPvHSfbeYp2yDrZRjR1phpWJQ8Fg,11432
-paircode-0.12.4.data/data/paircode/templates/claude/commands/peerlab.md,sha256=0-vI4S9HChJylLC_wbZ5bScAqWjmHMsSfYsIq_CNl_8,6079
-paircode-0.12.4.data/data/paircode/templates/codex/commands/paircode.md,sha256=QEnq-JG_CuAU5Y4KSVXZvUHbvrIy0bTCXxZRV01ZNWE,8396
-paircode-0.12.4.data/data/paircode/templates/gemini/commands/paircode.toml,sha256=ruvY6xV5BpAKxdNK7dyEnSMreNRykDfmgKk9DAK1YxA,7551
-paircode-0.12.4.dist-info/METADATA,sha256=Z44dZ6F3wlod75WRlH-G6FxPLIwN2Ap-fw5tFXWb4uE,7724
-paircode-0.12.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-paircode-0.12.4.dist-info/entry_points.txt,sha256=Xws2Px0qjasysoJikWE8LokoojG2_7qwOh8vTF-v9K0,47
-paircode-0.12.4.dist-info/licenses/LICENSE,sha256=2z2DTvqat4kmyHNEC8ehgOC5fBtyENHg2-Z0MiY_rxM,1074
-paircode-0.12.4.dist-info/RECORD,,