paircode 0.12.4__tar.gz → 0.13.1__tar.gz

{paircode-0.12.4 → paircode-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.12.4
+Version: 0.13.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

{paircode-0.12.4 → paircode-0.13.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.12.4"
+version = "0.13.1"
 description = "Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review."
 readme = "README.md"
 license = { text = "MIT" }

{paircode-0.12.4 → paircode-0.13.1}/src/paircode/__init__.py

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

{paircode-0.12.4 → paircode-0.13.1}/src/paircode/cli.py

@@ -324,12 +324,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 +353,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 +371,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"Work:\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"Task:\n"
         f"{prompt}"
     )
 
@@ -423,15 +433,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 +468,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-0.12.4 → paircode-0.13.1}/src/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-0.13.1/src/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 → paircode-0.13.1}/tests/test_peerlab.py

@@ -1,4 +1,9 @@
-"""Tests for paircode.peerlab — per-peer parallel labs with own .git."""
+"""Tests for paircode.peerlab — per-peer parallel labs with own .git.
+
+peerlab maintains its own state under `.peerlab/`, fully independent of
+`.paircode/`. Tests reflect that: no `paircode ensure-scaffold` in the
+setup path.
+"""
 from __future__ import annotations
 
 import shutil
@@ -6,6 +11,7 @@ import subprocess
 from pathlib import Path
 
 import pytest
+import yaml
 from click.testing import CliRunner
 
 from paircode.cli import main
@@ -13,76 +19,120 @@ from paircode.handshake import ProposedPeer
 from paircode.peerlab import (
     LAB_GITIGNORE_MARKER,
     PEERLAB_DIRNAME,
+    PEERLAB_PEERS_FILE,
     ensure_gitignore,
     ensure_lab_gitignore,
     ensure_peer_labs,
+    find_peerlab,
+    init_peerlab,
     peer_lab_path,
+    read_peerlab_peers,
+    write_peerlab_peers,
 )
-from paircode.state import find_paircode, init_paircode
 
 
 # ---------------------------------------------------------------------------
-# ensure_peer_labs — scaffold + seed + git init + initial commit
+# Fixtures
 # ---------------------------------------------------------------------------
 
-def _seed_roster_with(tmp_path: Path, monkeypatch) -> None:
-    """Make propose_roster return codex + gemini so ensure-scaffold populates
-    peers.yaml with both, creating their sandbox dirs too."""
+def _seed_roster(monkeypatch) -> list[ProposedPeer]:
+    """Fake handshake detection so init_peerlab writes a predictable roster."""
     peers = [
         ProposedPeer(id="peer-a-codex", cli="codex", priority="high", notes=""),
         ProposedPeer(id="peer-b-gemini", cli="gemini", priority="low", notes=""),
     ]
-    monkeypatch.setattr("paircode.cli.propose_roster", lambda: peers)
+    monkeypatch.setattr("paircode.peerlab.propose_roster", lambda: peers, raising=False)
+    # The import inside init_peerlab is lazy; patch at both sides to be safe
+    monkeypatch.setattr("paircode.handshake.propose_roster", lambda: peers)
+    return peers
 
 
-def _init_and_scaffold(tmp_path: Path, monkeypatch) -> None:
-    """Seed a .paircode/ + populated project root in tmp_path."""
-    # Simulate a small existing project at tmp_path
+def _setup_populated_project(tmp_path: Path, monkeypatch) -> None:
+    """Simulate a small existing project at tmp_path, cd in, seed handshake."""
     (tmp_path / "src").mkdir()
     (tmp_path / "src" / "app.py").write_text("print('hi')\n")
     (tmp_path / "README.md").write_text("# demo\n")
     monkeypatch.chdir(tmp_path)
-    _seed_roster_with(tmp_path, monkeypatch)
+    _seed_roster(monkeypatch)
+
+
+# ---------------------------------------------------------------------------
+# peerlab state independence — no .paircode/ touched
+# ---------------------------------------------------------------------------
+
+def test_init_peerlab_creates_dir_and_peers_yaml(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
+    assert state.root == tmp_path / PEERLAB_DIRNAME
+    assert state.root.is_dir()
+    assert state.peers_path == state.root / PEERLAB_PEERS_FILE
+    assert state.peers_path.is_file()
+    data = yaml.safe_load(state.peers_path.read_text()) or {}
+    ids = [p["id"] for p in data.get("peers") or []]
+    assert "peer-a-codex" in ids
+    assert "peer-b-gemini" in ids
+
+
+def test_peerlab_ensure_does_not_create_dot_paircode(tmp_path, monkeypatch):
+    """Regression: /peerlab must NOT create .paircode/ as a side effect."""
+    _setup_populated_project(tmp_path, monkeypatch)
     runner = CliRunner()
-    runner.invoke(main, ["ensure-scaffold"])
+    result = runner.invoke(main, ["peerlab", "ensure"])
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / ".peerlab").is_dir()
+    assert not (tmp_path / ".paircode").exists(), (
+        "peerlab ensure must not touch .paircode/ — they're independent state dirs"
+    )
+
 
+def test_find_peerlab_walks_up(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    init_peerlab()
+    # cd into a subdir; find_peerlab should still find .peerlab/ at root
+    sub = tmp_path / "src"
+    monkeypatch.chdir(sub)
+    state = find_peerlab()
+    assert state is not None
+    assert state.root == tmp_path / PEERLAB_DIRNAME
+
+
+def test_init_peerlab_is_idempotent(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    state1 = init_peerlab()
+    before = state1.peers_path.read_text()
+    state2 = init_peerlab()
+    assert state2.peers_path.read_text() == before  # no-op second call
+
+
+# ---------------------------------------------------------------------------
+# ensure_peer_labs — seed + git init + peer-authored commit
+# ---------------------------------------------------------------------------
 
 def test_ensure_peer_labs_creates_dirs_and_seeds_and_inits_git(tmp_path, monkeypatch):
-    """First run: each peer gets a lab, seeded from project root, with own
-    .git/ and an initial commit."""
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
     results = ensure_peer_labs(state)
-    assert len(results) == 2
     statuses = {r.peer_id: r.status for r in results}
     assert statuses["peer-a-codex"] == "created"
     assert statuses["peer-b-gemini"] == "created"
 
-    peerlab_root = tmp_path / PEERLAB_DIRNAME
     for pid in ("peer-a-codex", "peer-b-gemini"):
-        lab = peerlab_root / pid
-        assert lab.is_dir(), f"{lab} missing"
-        # Seeded contents
+        lab = tmp_path / PEERLAB_DIRNAME / pid
+        assert lab.is_dir()
         assert (lab / "src" / "app.py").is_file()
         assert (lab / "README.md").is_file()
-        # Own git
         assert (lab / ".git").is_dir()
-        # Initial commit exists — HEAD resolves
         r = subprocess.run(
             ["git", "-C", str(lab), "log", "-1", "--oneline"],
             capture_output=True, text=True, check=False,
         )
-        assert r.returncode == 0
         assert r.stdout.strip(), f"no initial commit in {lab}"
 
 
 def test_ensure_peer_labs_is_idempotent(tmp_path, monkeypatch):
-    """Second call: labs already exist → status 'already-exists', no re-seed."""
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
     ensure_peer_labs(state)
-
-    # Simulate the peer evolving: write a new file, commit
     lab = peer_lab_path(state, "peer-a-codex")
     (lab / "new-work.py").write_text("# codex added this\n")
     subprocess.run(["git", "-C", str(lab), "add", "-A"], check=False)
@@ -91,189 +141,105 @@ def test_ensure_peer_labs_is_idempotent(tmp_path, monkeypatch):
          "commit", "--quiet", "-m", "codex evolution"],
         check=False,
     )
-
-    # Re-run ensure — should NOT wipe codex's evolution
     results = ensure_peer_labs(state)
     statuses = {r.peer_id: r.status for r in results}
     assert statuses["peer-a-codex"] == "already-exists"
-    assert statuses["peer-b-gemini"] == "already-exists"
-    assert (lab / "new-work.py").exists(), "idempotent run wiped codex's work!"
+    assert (lab / "new-work.py").exists()
 
 
-def test_ensure_gitignore_adds_peerlab_line(tmp_path):
-    """First call appends `.peerlab/` to .gitignore; second call no-ops."""
-    gitignore = tmp_path / ".gitignore"
-    gitignore.write_text("__pycache__/\n.venv/\n")
-    assert ensure_gitignore(tmp_path) is True
-    text = gitignore.read_text()
-    assert ".peerlab/" in text
-    assert "peerlab — per-peer" in text
-
-    # Second call: already there → no change
-    before = text
-    assert ensure_gitignore(tmp_path) is False
-    assert gitignore.read_text() == before
+def test_initial_commit_authored_as_peer_id(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
+    ensure_peer_labs(state)
+    for pid in ("peer-a-codex", "peer-b-gemini"):
+        lab = peer_lab_path(state, pid)
+        r = subprocess.run(
+            ["git", "-C", str(lab), "log", "-1", "--format=%an <%ae>"],
+            capture_output=True, text=True, check=False,
+        )
+        assert pid in r.stdout
+        assert f"{pid}@peerlab.local" in r.stdout
 
 
-def test_ensure_gitignore_creates_file_if_missing(tmp_path):
-    """No .gitignore → create it with the peerlab entry."""
-    gitignore = tmp_path / ".gitignore"
-    assert not gitignore.exists()
-    assert ensure_gitignore(tmp_path) is True
-    assert ".peerlab/" in gitignore.read_text()
+def test_different_peers_produce_different_initial_commits(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
+    ensure_peer_labs(state)
+    codex_lab = peer_lab_path(state, "peer-a-codex")
+    gemini_lab = peer_lab_path(state, "peer-b-gemini")
 
+    def head_sha(lab):
+        r = subprocess.run(
+            ["git", "-C", str(lab), "rev-parse", "HEAD"],
+            capture_output=True, text=True, check=False,
+        )
+        return r.stdout.strip()
 
-def test_ensure_peer_labs_greenfield_minimal_seed(tmp_path, monkeypatch):
-    """On a near-empty project, labs still get created with git. The only
-    non-git content is the `.gitignore` that ensure_peer_labs itself added
-    to the outer repo (then rsync copies it into each lab)."""
-    monkeypatch.chdir(tmp_path)
-    _seed_roster_with(tmp_path, monkeypatch)
-    runner = CliRunner()
-    runner.invoke(main, ["ensure-scaffold"])
-    state = find_paircode()
-    results = ensure_peer_labs(state)
-    statuses = {r.peer_id: r.status for r in results}
-    assert statuses["peer-a-codex"] == "created"
-    lab = peer_lab_path(state, "peer-a-codex")
-    assert lab.is_dir()
-    assert (lab / ".git").is_dir()
-    children = sorted(p.name for p in lab.iterdir() if p.name != ".git")
-    # Greenfield: only the inherited .gitignore, nothing else (no source files)
-    assert children == [".gitignore"], f"expected just .gitignore, got {children}"
+    assert head_sha(codex_lab) != head_sha(gemini_lab)
 
 
 # ---------------------------------------------------------------------------
-# CLI surface — paircode peerlab ensure / list
-# ---------------------------------------------------------------------------
-
-def test_paircode_peerlab_ensure_command(tmp_path, monkeypatch):
-    _init_and_scaffold(tmp_path, monkeypatch)
-    runner = CliRunner()
-    result = runner.invoke(main, ["peerlab", "ensure"])
-    assert result.exit_code == 0, result.output
-    assert (tmp_path / ".peerlab" / "peer-a-codex").is_dir()
-    assert (tmp_path / ".peerlab" / "peer-b-gemini").is_dir()
-
-
-def test_paircode_peerlab_list_shows_head(tmp_path, monkeypatch):
-    _init_and_scaffold(tmp_path, monkeypatch)
-    runner = CliRunner()
-    runner.invoke(main, ["peerlab", "ensure"])
-    result = runner.invoke(main, ["peerlab", "list"])
-    assert result.exit_code == 0
-    assert "peer-a-codex" in result.output
-    assert "peer-b-gemini" in result.output
-
-
-def test_paircode_peerlab_help_is_reachable():
-    runner = CliRunner()
-    for argv in (["peerlab", "--help"], ["peerlab", "ensure", "--help"],
-                 ["peerlab", "invoke", "--help"], ["peerlab", "list", "--help"]):
-        result = runner.invoke(main, argv)
-        assert result.exit_code == 0, f"{argv}: {result.output}"
-
-
-# ---------------------------------------------------------------------------
-# Seed excludes honored
+# lab .gitignore — python/editor defaults
 # ---------------------------------------------------------------------------
 
 def test_lab_gitignore_has_pycache_on_fresh_lab(tmp_path, monkeypatch):
-    """Fresh lab's .gitignore excludes __pycache__ and bytecode so peer
-    commits don't pull in build junk. Regression for v0.12.0 bug where
-    `git add -A` in peer labs committed .pyc files."""
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
     ensure_peer_labs(state)
     lab = peer_lab_path(state, "peer-a-codex")
-    gitignore = lab / ".gitignore"
-    assert gitignore.exists()
-    content = gitignore.read_text()
+    content = (lab / ".gitignore").read_text()
     assert "__pycache__/" in content
     assert "*.py[cod]" in content
     assert LAB_GITIGNORE_MARKER in content
 
 
 def test_ensure_lab_gitignore_appends_to_existing(tmp_path):
-    """If user's project already has a .gitignore (rsync brought it over),
-    the peerlab block is APPENDED — user rules preserved."""
-    lab = tmp_path
-    (lab / ".gitignore").write_text("# user project rules\nsecrets.env\n")
-    assert ensure_lab_gitignore(lab) is True
-    content = (lab / ".gitignore").read_text()
-    assert "secrets.env" in content  # user rule preserved
-    assert LAB_GITIGNORE_MARKER in content  # our block added
+    (tmp_path / ".gitignore").write_text("# user project rules\nsecrets.env\n")
+    assert ensure_lab_gitignore(tmp_path) is True
+    content = (tmp_path / ".gitignore").read_text()
+    assert "secrets.env" in content
+    assert LAB_GITIGNORE_MARKER in content
 
 
 def test_ensure_lab_gitignore_is_idempotent(tmp_path):
-    """Second call no-ops if marker already there."""
-    lab = tmp_path
-    assert ensure_lab_gitignore(lab) is True
-    before = (lab / ".gitignore").read_text()
-    assert ensure_lab_gitignore(lab) is False
-    assert (lab / ".gitignore").read_text() == before
-
-
-def test_initial_commit_authored_as_peer_id(tmp_path, monkeypatch):
-    """Initial seed commit must be authored as the peer_id so replay
-    (git log) attributes work to each peer. Fixes v0.12.0 where commits
-    were authored as generic 'paircode-peerlab'."""
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
-    ensure_peer_labs(state)
-    for pid in ("peer-a-codex", "peer-b-gemini"):
-        lab = peer_lab_path(state, pid)
-        r = subprocess.run(
-            ["git", "-C", str(lab), "log", "-1", "--format=%an <%ae>"],
-            capture_output=True, text=True, check=False,
-        )
-        assert pid in r.stdout, f"commit author should contain {pid}; got {r.stdout}"
-        assert f"{pid}@peerlab.local" in r.stdout
+    assert ensure_lab_gitignore(tmp_path) is True
+    before = (tmp_path / ".gitignore").read_text()
+    assert ensure_lab_gitignore(tmp_path) is False
+    assert (tmp_path / ".gitignore").read_text() == before
 
 
-def test_different_peers_produce_different_initial_commits(tmp_path, monkeypatch):
-    """Distinct peer_ids as commit authors mean the seed commit SHAs differ
-    across labs — proves independence beyond 'same content, same author,
-    accidental SHA collision'."""
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
-    ensure_peer_labs(state)
-    codex_lab = peer_lab_path(state, "peer-a-codex")
-    gemini_lab = peer_lab_path(state, "peer-b-gemini")
+# ---------------------------------------------------------------------------
+# Outer .gitignore — appends .peerlab/
+# ---------------------------------------------------------------------------
 
-    def head_sha(lab):
-        r = subprocess.run(
-            ["git", "-C", str(lab), "rev-parse", "HEAD"],
-            capture_output=True, text=True, check=False,
-        )
-        return r.stdout.strip()
+def test_ensure_gitignore_adds_peerlab_line(tmp_path):
+    gitignore = tmp_path / ".gitignore"
+    gitignore.write_text("__pycache__/\n.venv/\n")
+    assert ensure_gitignore(tmp_path) is True
+    text = gitignore.read_text()
+    assert ".peerlab/" in text
+    assert "peerlab — per-peer" in text
+    assert ensure_gitignore(tmp_path) is False
 
-    assert head_sha(codex_lab) != head_sha(gemini_lab), (
-        "initial seed commits should differ across labs since authors differ"
-    )
 
+# ---------------------------------------------------------------------------
+# Seed excludes honored
+# ---------------------------------------------------------------------------
 
-def test_seed_excludes_dot_paircode_and_dot_git(tmp_path, monkeypatch):
-    """Seeded labs must not contain `.paircode/` (recursion) or the outer
-    repo's `.git/` (each lab gets its own fresh git instead)."""
-    # Project has a real outer .git with real history
+def test_seed_excludes_dot_peerlab_and_outer_git_history(tmp_path, monkeypatch):
     subprocess.run(["git", "-C", str(tmp_path), "init", "--quiet"], check=False)
     subprocess.run(
         ["git", "-C", str(tmp_path), "-c", "user.name=t", "-c", "user.email=t@t",
          "commit", "--quiet", "--allow-empty", "-m", "outer initial"],
         check=False,
     )
-    # Populate via the shared helper (creates src/app.py + README.md)
-    _init_and_scaffold(tmp_path, monkeypatch)
-    state = find_paircode()
+    _setup_populated_project(tmp_path, monkeypatch)
+    state = init_peerlab()
     ensure_peer_labs(state)
     lab = peer_lab_path(state, "peer-a-codex")
-    # Lab must not have .paircode (recursion guard)
-    assert not (lab / ".paircode").exists(), "lab should not contain .paircode/"
-    # Lab's .git exists — its OWN
+    assert not (lab / ".peerlab").exists()
+    assert not (lab / ".paircode").exists()
     assert (lab / ".git").exists()
-    # Critically, the outer repo's .git log must NOT have leaked into the lab's
-    # git log. They're independent histories.
     outer_log = subprocess.run(
         ["git", "-C", str(tmp_path), "log", "--oneline"],
         capture_output=True, text=True, check=False,
@@ -283,11 +249,69 @@ def test_seed_excludes_dot_paircode_and_dot_git(tmp_path, monkeypatch):
         capture_output=True, text=True, check=False,
     ).stdout.strip()
     assert "outer initial" in outer_log
-    assert "outer initial" not in lab_log, "outer git history leaked into lab!"
+    assert "outer initial" not in lab_log
+
+
+# ---------------------------------------------------------------------------
+# CLI surface
+# ---------------------------------------------------------------------------
+
+def test_paircode_peerlab_help_is_reachable():
+    runner = CliRunner()
+    for argv in (["peerlab", "--help"], ["peerlab", "ensure", "--help"],
+                 ["peerlab", "invoke", "--help"], ["peerlab", "list", "--help"],
+                 ["peerlab", "roster", "--help"]):
+        result = runner.invoke(main, argv)
+        assert result.exit_code == 0, f"{argv}: {result.output}"
+
+
+def test_paircode_peerlab_ensure_command(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    runner = CliRunner()
+    result = runner.invoke(main, ["peerlab", "ensure"])
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / ".peerlab" / "peers.yaml").is_file()
+    assert (tmp_path / ".peerlab" / "peer-a-codex").is_dir()
+    assert (tmp_path / ".peerlab" / "peer-b-gemini").is_dir()
+    # AND .paircode/ is NOT created
+    assert not (tmp_path / ".paircode").exists()
+
+
+def test_paircode_peerlab_list_shows_head(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    runner = CliRunner()
+    runner.invoke(main, ["peerlab", "ensure"])
+    result = runner.invoke(main, ["peerlab", "list"])
+    assert result.exit_code == 0
+    assert "peer-a-codex" in result.output
+    assert "peer-b-gemini" in result.output
+
+
+def test_paircode_peerlab_roster_prints_ids(tmp_path, monkeypatch):
+    _setup_populated_project(tmp_path, monkeypatch)
+    runner = CliRunner()
+    runner.invoke(main, ["peerlab", "ensure"])
+    result = runner.invoke(main, ["peerlab", "roster"])
+    assert result.exit_code == 0
+    lines = result.output.strip().splitlines()
+    assert "peer-a-codex" in lines
+    assert "peer-b-gemini" in lines
+
+
+def test_paircode_peerlab_roster_alpha_filter(tmp_path, monkeypatch):
+    """roster --alpha codex drops codex-cli peers when others are available."""
+    _setup_populated_project(tmp_path, monkeypatch)
+    runner = CliRunner()
+    runner.invoke(main, ["peerlab", "ensure"])
+    result = runner.invoke(main, ["peerlab", "roster", "--alpha", "codex"])
+    assert result.exit_code == 0
+    lines = result.output.strip().splitlines()
+    assert "peer-a-codex" not in lines
+    assert "peer-b-gemini" in lines
 
 
 # ---------------------------------------------------------------------------
-# Installer — /peerlab.md deployed alongside /paircode.md
+# Installer — /peerlab.md still deployed alongside /paircode.md
 # ---------------------------------------------------------------------------
 
 def test_installer_deploys_peerlab_slash_command(tmp_path, monkeypatch):
@@ -315,5 +339,5 @@ def test_installer_deploys_peerlab_slash_command(tmp_path, monkeypatch):
 
     inst.install_all()
     peerlab_cmd = fake_home / ".claude" / "commands" / "peerlab.md"
-    assert peerlab_cmd.exists(), "install_claude must deploy /peerlab.md"
+    assert peerlab_cmd.exists()
     assert "peerlab" in peerlab_cmd.read_text()

paircode-0.12.4/src/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.