@nvice-r/pr-commands 0.1.2 → 0.1.4

package/README.md

@@ -23,6 +23,8 @@ The interactive wizard:
 4. **Identity + token** — reads your API token from the keychain (or tells you how to add one).
 5. **Reviewers** — fetches the repo's default reviewers into an interactive checklist
    (`↑/↓` move · `space` toggle · `a` all · `n` none · `b` back · `enter` confirm; all pre-selected).
+   On reinstall, an existing roster is kept: its members are pre-selected instead, and entries
+   that aren't current default reviewers are carried over as-is.
 6. **Convention** — pick a preset, then review/edit its title-pattern, ticket-regex, and
    template-sections (each pre-filled from the preset, editable). A placeholder legend
    (`<ver>`, `<desc>`, `<ticket>`, …) is shown. Concrete values are written to config — `/pr`
@@ -44,7 +46,9 @@ Flags:
 | `--provider <p>` | force `bitbucket`\|`github`\|`gitlab` instead of detecting |
 | `--agent <id>` | force skill install to this agent (repeatable): `claude-code`\|`antigravity`\|`codex`\|`opencode`. Default: auto-detect |
 | `--all` | install every ready provider binary, not just the detected one |
-| `--yes` | non-interactive: reviewers = all, convention = `trueid` |
+| `--agent-dir <dir>` | repo folder for the reviewer roster (default: primary agent's — `.claude`/`.agent`/`.codex`/`.opencode`) |
+| `--yes` | non-interactive: reviewers = existing roster if any, else all; convention = `trueid` |
+| `--reset-reviewers` | ignore an existing roster and rebuild it from the repo's default reviewers |
 | `--dry-run` | print planned actions, write nothing |
 | `--help` | usage |
 
@@ -74,10 +78,11 @@ identically from every clone and every git worktree, no repo-local symlinks.
 
 | Artifact | Path |
 |----------|------|
-| Shared library | `~/.local/bin/pr-common.sh` |
-| Provider binary | `~/.local/bin/bbpr` (`ghpr`/`glpr` later) |
+| Command (only file on `PATH`) | `~/.local/bin/pr-commands` |
+| Shared library | `~/.local/share/pr-commands/pr-common.sh` |
+| Host provider | `~/.local/share/pr-commands/providers/bitbucket.sh` (`github.sh`/`gitlab.sh` later) |
 | Config | `~/.config/pr/config` |
-| Reviewer roster | `<main-repo-root>/.pr/reviewers.txt` (neutral, agent-agnostic; shared across worktrees) |
+| Reviewer roster | `<main-repo-root>/<agent_dir>/pr-reviewers.txt` (primary agent's folder; shared across worktrees) |
 | Canonical skill | `~/.config/pr/skill/pr/SKILL.md` (single source) |
 | Per-agent skill | `<agent-skills-dir>/pr` → symlink to canonical |
 | Claude `/pr` command | `~/.claude/commands/pr.md` (dual-install, keeps the slash trigger) |
@@ -115,6 +120,30 @@ convention=trueid    # see presets
 Edit by hand any time. **A missing config is a hard error** — `/pr` and the binaries refuse to
 guess. Re-run the installer to regenerate.
 
+### Per-project convention (`.agents/config/pr.yaml`)
+
+When the repo has `.agents/config/pr.yaml` (this checkout, or the main checkout for worktrees),
+`/pr` reads the convention from it instead of the user config. One file per project, so teams
+with different conventions share the same skill:
+
+```yaml
+title_pattern: "[<ver>] Feature/<ver>/<ticket> <desc>"
+ticket_regex: "SC-(\\d+|NOTICKET)"
+template_sections: [What Happened, Insight, Proof of Work]
+body_rules: |
+  - Free-text project rules the skill follows literally.
+base: develop            # default base proposal
+draft: ask               # ask | true | false
+push: [origin]           # remotes pushed before create
+fork:                    # optional cross-repo mode (`/pr cross`)
+  remote: social-commerce
+  repo: workspace/fork-repo
+pre_pr: []               # commands run before confirm; non-zero exit stops /pr
+post_pr: [jira-update]   # sibling skills offered after create
+```
+
+Without the file, the convention keys below (written by the wizard) are used.
+
 ### Convention presets
 
 | preset | title pattern | ticket regex | template sections |
@@ -135,15 +164,19 @@ template_sections=Context|Changes|Risk
 
 ### Reviewers
 
-Roster lives in a **neutral `.pr/` folder** under the main repo root — it's data the bash binary
-reads, not an agent artifact, so it's agent-agnostic (survives switching agents). Editable next to
-the code. Resolved via `git --git-common-dir/..`, so all worktrees of a repo share one roster:
+Roster lives in the **primary agent's repo folder** under the main repo root — `.claude`,
+`.agent` (Antigravity), `.codex` or `.opencode`, picked from the first agent you install for
+(override with `--agent-dir`). The choice is saved as `agent_dir` in the config so the bash binary
+reads the same path. Resolved via `git --git-common-dir/..`, so all worktrees of a repo share one
+roster:
 
 ```
-<main-repo-root>/.pr/reviewers.txt
+<main-repo-root>/<agent_dir>/pr-reviewers.txt
 ```
 
-You (the author) are excluded on install — bbpr also drops self at PR time. One entry per line,
+Switching primary agent = re-run the installer; the old file still loads as a fallback.
+
+You (the author) are excluded on install — `pr-commands` also drops self at PR time. One entry per line,
 trailing `# Name` comment optional:
 
 ```
@@ -151,23 +184,23 @@ trailing `# Name` comment optional:
 {fedcba98-7654-3210-fedc-ba9876543210}  # Bob
 ```
 
-It's plain data — edit freely, no reinstall. Consider gitignoring `.pr/` unless the team wants the
-roster committed. Load order: `$BBPR_REVIEWERS` → `.pr/reviewers.txt` → `<agent_dir>/pr-reviewers.txt`
-(0.1.1) → root `.pr-reviewers.txt` (pre-0.1.1) → global `~/.config/pr/reviewers/<ws>-<slug>.txt` →
+It's plain data — edit freely, no reinstall. Consider gitignoring the roster unless the team wants
+it committed. Load order: `$PR_REVIEWERS` → `<agent_dir>/pr-reviewers.txt` → `.pr/reviewers.txt`
+(0.1.2) → root `.pr-reviewers.txt` (pre-0.1.1) → global `~/.config/pr/reviewers/<ws>-<slug>.txt` →
 legacy. Run-time overrides: `--no-reviewers` skips all, `--reviewer <uuid>` appends.
 
 ### Auth precedence (email)
 
-`--email` flag → `$BB_EMAIL` → `git config bbpr.email` → config `email` → keychain account.
+`--email` flag → `$BB_EMAIL` → `git config pr.email` → config `email` → keychain account.
 The token is always read from the keychain (or `$PR_TOKEN` when `token_src=env`).
 
 ## Provider support
 
-| provider | binary | status |
-|----------|--------|--------|
-| Bitbucket Cloud | `bbpr` | ✅ ready |
-| GitHub | `ghpr` | 🚧 stub — errors `not-yet-supported` |
-| GitLab | `glpr` | 🚧 stub |
+| provider | file | status |
+|----------|------|--------|
+| Bitbucket Cloud | `providers/bitbucket.sh` | ✅ ready |
+| GitHub | `providers/github.sh` | 🚧 not yet — `pr-commands` errors `github not yet supported` |
+| GitLab | `providers/gitlab.sh` | 🚧 not yet |
 
 | OS | token source | status |
 |----|--------------|--------|
@@ -176,15 +209,21 @@ The token is always read from the keychain (or `$PR_TOKEN` when `token_src=env`)
 
 ## Architecture
 
-- **Split by provider, not by OS.** Each provider gets its own small binary (`bbpr`/`ghpr`/`glpr`)
-  because the REST APIs genuinely differ. OS differences (token retrieval) are a single
-  `get_token()` function switched by `uname`, not a separate binary. Ceiling: 3 binaries, never
-  3 × OS.
+- **One command, one file per host.** `pr-commands` is the only thing on `PATH`. It reads
+  `git remote get-url origin` (override: `$PR_PROVIDER`) and loads `providers/<host>.sh`.
+  Each host keeps its own small file because the REST APIs genuinely differ. OS differences
+  (token retrieval) are a single `get_token()` function, not a separate file.
 - **Shared logic in `pr-common.sh`** — git scan, base save, reviewer load, arg parse, token —
-  sourced by every binary. A provider binary is ~40 lines: payload shape + endpoint + parse.
+  sourced before the provider. A provider file is ~60 lines: payload shape + endpoint + parse.
 - **One generic `/pr` skill.** Convention lives in config, not the skill, so the skill is
-  provider- and team-neutral and installs globally. Adding a provider = one binary + one dispatch
-  line, zero new skill files.
+  host- and team-neutral and installs globally. It always calls `pr-commands create`, so adding
+  a host = one provider file + `ready: true` in `install.js`, zero skill changes.
+
+```bash
+pr-commands create --title "..." --body-file body.md --dest develop [--draft]
+pr-commands check     # which host, and is it supported?
+pr-commands help
+```
 
 Full rationale in [`DECISIONS.md`](./DECISIONS.md).
 
@@ -195,14 +234,15 @@ Full rationale in [`DECISIONS.md`](./DECISIONS.md).
 | `no ~/.config/pr/config` | run `npx @nvice-r/pr-commands` |
 | reviewers not fetched | add the keychain token (see Prerequisites), re-run |
 | `WARN ~/.local/bin not on PATH` | add the export line above to your shell rc |
-| `not-yet-supported: <provider>` | GitHub/GitLab aren't implemented yet |
-| worktree runs old behavior | skill/binaries are global, not repo-local; ensure no stale per-repo copy shadows them |
+| `<provider> not yet supported` | GitHub/GitLab aren't implemented yet |
+| worktree runs old behavior | skill/command are global, not repo-local; ensure no stale per-repo copy shadows them |
 | agent doesn't see the skill | re-run and force it: `npx @nvice-r/pr-commands --agent <id>`; check `<agent-skills-dir>/pr` symlink exists |
 
 ## Uninstall
 
 ```bash
-rm ~/.local/bin/bbpr ~/.local/bin/pr-common.sh
+rm ~/.local/bin/pr-commands
+rm -rf ~/.local/share/pr-commands
 rm -rf ~/.config/pr
 rm ~/.claude/commands/pr.md
 # per-agent skill symlinks (remove those you installed):

package/assets/bin/pr-commands

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# pr-commands — create pull requests on any git host (one entry point).
+#
+# Usage:
+#   pr-commands create --title "..." [--body|--body-file f] [--source b] [--dest b]
+#                      [--repo owner/name] [--draft] [--reviewer id]... [--no-reviewers]
+#                      [--email a] [--close-source] [--source-repo owner/fork]
+#   pr-commands check      detect the host from the origin remote; exit 0 if supported
+#   pr-commands help       this help
+#   pr-commands --version
+#
+# The host is detected from `git remote get-url origin` (override: $PR_PROVIDER).
+# Host code lives in <share>/providers/<provider>.sh; shared code in <share>/pr-common.sh,
+# where <share> = $PR_COMMANDS_HOME, else <this dir>/../share/pr-commands.
+# pr-commands-version: 1
+
+set -euo pipefail
+
+PR_CMD="pr-commands"
+_here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SHARE="${PR_COMMANDS_HOME:-$_here/../share/pr-commands}"
+
+usage() { sed -n '2,14p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
+fail()  { echo "$PR_CMD: $*" >&2; exit 1; }
+
+# Echo the provider name for the origin remote (or $PR_PROVIDER), or fail.
+detect_provider() {
+  if [ -n "${PR_PROVIDER:-}" ]; then echo "$PR_PROVIDER"; return; fi
+  local url
+  url="$(git remote get-url origin 2>/dev/null)" || fail "no origin remote"
+  case "$url" in
+    *bitbucket.org*) echo bitbucket ;;
+    *github.com*)    echo github ;;
+    *gitlab*)        echo gitlab ;;
+    *) fail "unknown git host for remote: $url (set PR_PROVIDER to override)" ;;
+  esac
+}
+
+# Source the shared lib + the provider file. Fails if the provider is not installed.
+load_provider() {
+  PROVIDER="$(detect_provider)"
+  local pfile="$SHARE/providers/${PROVIDER}.sh"
+  [ -f "$SHARE/pr-common.sh" ] || fail "missing $SHARE/pr-common.sh — run: npx @nvice-r/pr-commands"
+  [ -f "$pfile" ] || fail "${PROVIDER} not yet supported (no $pfile)"
+  # shellcheck source=../share/pr-commands/pr-common.sh
+  . "$SHARE/pr-common.sh"
+  # shellcheck disable=SC1090
+  . "$pfile"
+}
+
+sub="${1:-help}"
+case "$sub" in
+  -h|--help|--version) ;;
+  --*) set -- create "$@"; sub=create ;;   # bare flags = create
+esac
+
+case "$sub" in
+  create)
+    shift
+    load_provider
+    declare -F provider_create >/dev/null || fail "${PROVIDER}: create not implemented"
+    provider_create "$@"
+    ;;
+  check)
+    load_provider
+    echo "provider=${PROVIDER} ok"
+    ;;
+  help|-h|--help) usage ;;
+  --version|version) sed -n 's/^# pr-commands-version: //p' "${BASH_SOURCE[0]}" ;;
+  *) fail "unknown command: $sub (try: $PR_CMD help)" ;;
+esac

package/assets/{bin → share/pr-commands}/pr-common.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# pr-common-version: 1
-# pr-common.sh — shared library for provider PR binaries (bbpr/ghpr/glpr).
-# NOT executable on its own — sourced by a provider binary, which then builds the
-# provider-specific payload + POST. Everything here is provider-AGNOSTIC.
+# pr-common-version: 3
+# pr-common.sh — shared library for the `pr-commands` entry point.
+# NOT executable on its own — sourced by `pr-commands` before providers/<host>.sh, which
+# builds the host-specific payload + POST. Everything here is host-AGNOSTIC.
 #
 # Provides (after `pr_common_init "$@"`): global vars
-#   TITLE BODY SOURCE DEST REPO EMAIL TOKEN DRAFT CLOSE_SOURCE
+#   TITLE BODY SOURCE DEST REPO SOURCE_REPO EMAIL TOKEN DRAFT CLOSE_SOURCE
 #   FINAL_REVIEWERS[]   (uuids, self already NOT dropped — provider does that)
 # Provides functions:
 #   die, get_token, pr_load_config, pr_parse_args, pr_git_defaults,
@@ -38,7 +38,7 @@ pr_load_config() {
     esac
   done < "$CONFIG_FILE"
   : "${CFG_TOKEN_SRC:=keychain}"
-  : "${CFG_AGENT_DIR:=.claude}"          # agent folder holding the roster (relative to main repo root)
+  : "${CFG_AGENT_DIR:=.claude}"          # primary agent's repo folder holding the roster (relative to main repo root)
 }
 
 # --- token retrieval, OS-switched (D1: OS is a function, not a binary axis) ---
@@ -61,10 +61,14 @@ get_token() {
 
 # --- arg parse (common flags across all providers) ---
 pr_parse_args() {
-  TITLE=""; BODY=""; BODY_FILE=""; SOURCE=""; DEST=""; REPO=""
+  TITLE=""; BODY=""; BODY_FILE=""; SOURCE=""; DEST=""; REPO=""; SOURCE_REPO=""
   DRAFT="false"; CLOSE_SOURCE="false"; NO_REVIEWERS="false"; EMAIL_ARG=""
   EXTRA_REVIEWERS=()
   while [ $# -gt 0 ]; do
+    case "$1" in
+      --title|--body|--body-file|--source|--dest|--target|--repo|--source-repo|--reviewer|--email)
+        [ $# -ge 2 ] || die "$1 needs a value" ;;
+    esac
     case "$1" in
       --title)         TITLE="$2"; shift 2 ;;
       --body)          BODY="$2"; shift 2 ;;
@@ -72,12 +76,13 @@ pr_parse_args() {
       --source)        SOURCE="$2"; shift 2 ;;
       --dest|--target) DEST="$2"; shift 2 ;;
       --repo)          REPO="$2"; shift 2 ;;
+      --source-repo)   SOURCE_REPO="$2"; shift 2 ;;   # fork → cross-repo PR
       --draft)         DRAFT="true"; shift ;;
       --close-source)  CLOSE_SOURCE="true"; shift ;;
       --reviewer)      EXTRA_REVIEWERS+=("$2"); shift 2 ;;
       --no-reviewers)  NO_REVIEWERS="true"; shift ;;
       --email)         EMAIL_ARG="$2"; shift 2 ;;
-      -h|--help)       sed -n '2,20p' "$0"; exit 0 ;;
+      -h|--help)       if declare -F usage >/dev/null; then usage; else sed -n '2,20p' "$0"; fi; exit 0 ;;
       *) die "unknown flag: $1" ;;
     esac
   done
@@ -96,10 +101,11 @@ pr_git_defaults() {
     [ "$SOURCE" = "HEAD" ] && die "detached HEAD — pass --source"
   fi
   if [ -z "$DEST" ]; then
-    DEST="$(git config --get "branch.${SOURCE}.bbprBase" 2>/dev/null || true)"
-    [ -n "$DEST" ] && echo "${PR_CMD:-pr}: using saved base (branch.${SOURCE}.bbprBase = ${DEST})" >&2
+    pr_migrate_base
+    DEST="$(git config --get "branch.${SOURCE}.base" 2>/dev/null || true)"
+    [ -n "$DEST" ] && echo "${PR_CMD:-pr}: using saved base (branch.${SOURCE}.base = ${DEST})" >&2
   fi
-  [ -n "$DEST" ] || die "--dest required (no saved branch.${SOURCE}.bbprBase)"
+  [ -n "$DEST" ] || die "--dest required (no saved branch.${SOURCE}.base)"
   if [ -z "$REPO" ]; then
     local url
     url="$(git remote get-url origin 2>/dev/null)" || die "no origin remote"
@@ -111,9 +117,11 @@ pr_git_defaults() {
 
 # --- creds: email precedence + token via OS ---
 pr_resolve_creds() {
-  # --email > $BB_EMAIL > git config bbpr.email > config email > keychain acct
+  # --email > $BB_EMAIL > git config pr.email > config email > keychain acct
+  # (legacy git config bbpr.email still read as fallback after pr.email)
   EMAIL="$EMAIL_ARG"
   [ -n "$EMAIL" ] || EMAIL="${BB_EMAIL:-}"
+  [ -n "$EMAIL" ] || EMAIL="$(git config pr.email 2>/dev/null || true)"
   [ -n "$EMAIL" ] || EMAIL="$(git config bbpr.email 2>/dev/null || true)"
   [ -n "$EMAIL" ] || EMAIL="${CFG_EMAIL:-}"
   [ -n "$EMAIL" ] || die "no email resolved (set config email or pass --email)"
@@ -123,17 +131,17 @@ pr_resolve_creds() {
 # --- reviewer roster: work-dir file (shared across worktrees) then global fallbacks ---
 pr_load_reviewers() {
   DEFAULT_REVIEWERS=()
-  local file="${BBPR_REVIEWERS:-}"
+  local file="${PR_REVIEWERS:-${BBPR_REVIEWERS:-}}"   # BBPR_REVIEWERS = legacy name
   if [ -z "$file" ]; then
     local slug; slug="$(echo "$REPO" | tr '/' '-')"      # workspace/slug -> workspace-slug
     # main repo root, shared across worktrees: git-common-dir/.. (empty if git call fails)
     local mainroot; mainroot="$(cd "$(git rev-parse --git-common-dir 2>/dev/null)/.." 2>/dev/null && pwd)"
     for cand in \
-      ${mainroot:+"$mainroot/.pr/reviewers.txt"} \
       ${mainroot:+"$mainroot/${CFG_AGENT_DIR:-.claude}/pr-reviewers.txt"} \
+      ${mainroot:+"$mainroot/.pr/reviewers.txt"} \
       ${mainroot:+"$mainroot/.pr-reviewers.txt"} \
       "$HOME/.config/pr/reviewers/${slug}.txt" \
-      "$HOME/.config/bbpr/bbpr-reviewers.txt"; do          # neutral primary; agent-dir + root + global legacy fallbacks
+      "$HOME/.config/bbpr/bbpr-reviewers.txt"; do          # agent-dir primary; 0.1.2 .pr/ + root + global legacy fallbacks
       [ -f "$cand" ] && { file="$cand"; break; }
     done
   fi
@@ -156,12 +164,28 @@ pr_load_reviewers() {
 }
 
 # --- persist resolved base for next run ---
+# branch.<b>.base is the shared, host-neutral key (also read by
+# @nvice-r/git-commands git-restack).
 pr_save_base() {
-  git config "branch.${SOURCE}.bbprBase" "$DEST" 2>/dev/null \
-    && echo "${PR_CMD:-pr}: saved branch.${SOURCE}.bbprBase = ${DEST}" >&2
+  git config "branch.${SOURCE}.base" "$DEST" 2>/dev/null \
+    && echo "${PR_CMD:-pr}: saved branch.${SOURCE}.base = ${DEST}" >&2
   return 0   # base-save is best-effort; never abort the binary on failure
 }
 
+# One-time migration: pr-commands <= 0.1.3 saved the base under the legacy key
+# branch.<b>.bbprBase. Copy it to branch.<b>.base and unset the old key.
+# Remove this function once no branch can still carry the legacy key.
+pr_migrate_base() {
+  local old
+  git config --get "branch.${SOURCE}.base" >/dev/null 2>&1 && return 0
+  old="$(git config --get "branch.${SOURCE}.bbprBase" 2>/dev/null || true)"
+  [ -n "$old" ] || return 0
+  git config "branch.${SOURCE}.base" "$old" 2>/dev/null \
+    && git config --unset "branch.${SOURCE}.bbprBase" 2>/dev/null \
+    && echo "${PR_CMD:-pr}: migrated branch.${SOURCE}.bbprBase -> branch.${SOURCE}.base" >&2
+  return 0   # best-effort; never abort the binary on failure
+}
+
 # --- orchestrate everything a provider needs before its POST ---
 pr_common_init() {
   pr_load_config

package/assets/share/pr-commands/providers/bitbucket.sh

@@ -0,0 +1,77 @@
+# bitbucket-provider-version: 10
+# providers/bitbucket.sh — Bitbucket Cloud (REST API v2.0). Sourced by `pr-commands`
+# after pr-common.sh; never run directly. Only Bitbucket-specific code lives here:
+# payload shape, endpoint, self-as-reviewer rule, response parse.
+
+KEYCHAIN_SERVICE="bitbucket-api-token"
+
+provider_create() {
+  pr_common_init "$@"
+
+  # --- Bitbucket: drop the PR author's own UUID (BB rejects author-as-reviewer) ---
+  if [ "${#FINAL_REVIEWERS[@]}" -gt 0 ]; then
+    local SELF_UUID
+    SELF_UUID="$(curl -sS -u "${EMAIL}:${TOKEN}" "https://api.bitbucket.org/2.0/user" 2>/dev/null \
+      | python3 -c 'import json,sys
+try: print(json.load(sys.stdin).get("uuid",""))
+except Exception: print("")' 2>/dev/null || true)"
+    if [ -n "$SELF_UUID" ]; then
+      local FILTERED=() r
+      for r in "${FINAL_REVIEWERS[@]}"; do
+        [ "$r" = "$SELF_UUID" ] || FILTERED+=("$r")
+      done
+      FINAL_REVIEWERS=("${FILTERED[@]:-}")
+      [ -z "${FINAL_REVIEWERS[0]:-}" ] && FINAL_REVIEWERS=()
+    fi
+  fi
+
+  # --- Bitbucket payload (source/destination keys, draft, reviewers[]) ---
+  local PAYLOAD
+  PAYLOAD="$(
+    TITLE="$TITLE" BODY="$BODY" SOURCE="$SOURCE" DEST="$DEST" SOURCE_REPO="$SOURCE_REPO" \
+    DRAFT="$DRAFT" CLOSE_SOURCE="$CLOSE_SOURCE" \
+    REVIEWERS_JSON="$(printf '%s\n' "${FINAL_REVIEWERS[@]:-}" | python3 -c 'import json,sys; print(json.dumps([{"uuid": l.strip()} for l in sys.stdin if l.strip()]))')" \
+    python3 -c '
+import json, os
+p = {
+  "title": os.environ["TITLE"],
+  "description": os.environ["BODY"],
+  "source": {"branch": {"name": os.environ["SOURCE"]}},
+  "destination": {"branch": {"name": os.environ["DEST"]}},
+  "draft": os.environ["DRAFT"] == "true",
+  "close_source_branch": os.environ["CLOSE_SOURCE"] == "true",
+}
+if os.environ["SOURCE_REPO"]:
+  p["source"]["repository"] = {"full_name": os.environ["SOURCE_REPO"]}
+revs = json.loads(os.environ["REVIEWERS_JSON"])
+if revs: p["reviewers"] = revs
+print(json.dumps(p))
+'
+  )"
+
+  local URL="https://api.bitbucket.org/2.0/repositories/${REPO}/pullrequests"
+  echo "POST $URL"
+  echo "source=${SOURCE_REPO:+$SOURCE_REPO:}$SOURCE  dest=$DEST  draft=$DRAFT  reviewers=${#FINAL_REVIEWERS[@]}"
+
+  local RESP PR_INFO
+  RESP="$(curl -sS -X POST "$URL" -u "${EMAIL}:${TOKEN}" \
+    -H 'Content-Type: application/json' -d "$PAYLOAD")"
+
+  PR_INFO="$(echo "$RESP" | python3 -c '
+import json, sys
+try: d = json.loads(sys.stdin.read())
+except Exception as e: print("non-JSON response", e); sys.exit(2)
+if "error" in d: print("ERROR:", json.dumps(d["error"], indent=2)); sys.exit(1)
+print(str(d.get("id")) + "\t" + str(d.get("links", {}).get("html", {}).get("href")))
+')" || { echo "$PR_INFO" >&2; exit 1; }   # surface the API error; set -e would swallow it
+
+  local NEW_PR_ID NEW_PR_URL ATTACHED
+  NEW_PR_ID="$(echo "$PR_INFO" | cut -f1)"
+  NEW_PR_URL="$(echo "$PR_INFO" | cut -f2)"
+  ATTACHED="$(echo "$RESP" | python3 -c 'import json,sys; print(len(json.load(sys.stdin).get("reviewers", [])))')"
+  echo "created PR #${NEW_PR_ID} with ${ATTACHED} reviewers"
+  echo "$NEW_PR_URL"
+
+  [ -n "$NEW_PR_ID" ] && pr_save_base
+  return 0
+}

package/assets/skill/pr.body.md

@@ -1,6 +1,8 @@
 Create a pull request for the current branch. Provider (Bitbucket / GitHub / GitLab) is
-auto-detected from the git remote; the matching binary (`bbpr` / `ghpr` / `glpr`) is invoked.
-Convention (title pattern, ticket regex, PR template) comes from `~/.config/pr/config`.
+auto-detected from the git remote by the `pr-commands` command, which runs that host's provider.
+Convention (title pattern, ticket regex, PR template, body rules, push remotes, hooks) comes
+from the repo's `.agents/config/pr.yaml` (one file per project, usually copied there by
+`/landing`). Without that file, the convention keys in `~/.config/pr/config` are used.
 
 Installed by `npx @nvice-r/pr-commands`. If setup is missing, this command STOPS and tells the
 user to run the installer — it never guesses config (D8: hard fail, no hardcoded fallback).
@@ -16,14 +18,16 @@ skip the create steps entirely.
 /pr — provider-agnostic PR helper (@nvice-r/pr-commands)
 
 USAGE
-  /pr [base-branch] [draft]   Create a PR for the current branch (default).
+  /pr [base-branch] [draft] [cross]
+                              Create a PR for the current branch (default).
   /pr update [PR#] [short]    Rewrite an existing PR's description in place.
   /pr help                    Show this help.
 
 CREATE
   base-branch   Any arg containing "/". If omitted, inferred from closest ancestor
                 remote branch (saved per-branch after first run).
-  draft         Create as draft. Otherwise opens ready (asks to confirm).
+  draft         Create as draft. Otherwise follows `draft:` in pr.yaml (default: ask).
+  cross         Fork mode: open the PR in origin from the fork in pr.yaml `fork:`.
 
 UPDATE
   PR#           PR number to rewrite. If omitted, resolved from the current branch's
@@ -31,9 +35,10 @@ UPDATE
   short         Compress harder (caveman brevity): cut throat-clearing, restated ticket
                 goals, filler connectors. Keeps every file + technical fact.
 
-CONFIG        ~/.config/pr/config  (os, token_src, email, convention)
-PROVIDER      auto from `git remote get-url origin` -> bbpr | ghpr | glpr
-REVIEWERS     <main-repo-root>/.pr/reviewers.txt (per-repo, shared across worktrees, agent-agnostic)
+CONVENTION    <repo>/.agents/config/pr.yaml (per project; else convention keys in the user config)
+CONFIG        ~/.config/pr/config  (os, token_src, email, agent_dir; legacy convention keys)
+PROVIDER      auto from `git remote get-url origin` (run by `pr-commands`)
+REVIEWERS     <main-repo-root>/<agent_dir>/pr-reviewers.txt (per-repo, shared across worktrees; agent_dir from config)
 SETUP         npx @nvice-r/pr-commands
 ```
 
@@ -47,33 +52,53 @@ missing piece). Do NOT improvise config or reviewers.
 CFG="${PR_CONFIG:-$HOME/.config/pr/config}"
 [ -f "$CFG" ] || { echo "MISSING config: $CFG"; }
 
-# b. detect provider from remote
-URL="$(git remote get-url origin 2>/dev/null)" || echo "no origin remote"
-case "$URL" in
-  *bitbucket.org*) PROVIDER=bitbucket; BIN=bbpr ;;
-  *github.com*)    PROVIDER=github;    BIN=ghpr ;;
-  *gitlab.com*)    PROVIDER=gitlab;    BIN=glpr ;;
-  *) echo "unknown provider for remote: $URL" ;;
-esac
-
-# c. matching binary installed?
-command -v "$BIN" >/dev/null 2>&1 || echo "MISSING binary: $BIN (run installer, or provider not yet supported)"
+# b. command installed?
+command -v pr-commands >/dev/null 2>&1 || echo "MISSING command: pr-commands"
+
+# c. host detected + supported? prints "provider=<name> ok", or the reason it is not
+pr-commands check
+
+# d. project convention file: this checkout first, then the main checkout (worktrees share it,
+#    because .agents/config/ is usually gitignored and only exists in the main checkout)
+TOP="$(git rev-parse --show-toplevel)"
+MAINROOT="$(cd "$(git rev-parse --git-common-dir)/.." && pwd)"
+PR_YAML=""
+for f in "$TOP/.agents/config/pr.yaml" "$MAINROOT/.agents/config/pr.yaml"; do
+  [ -f "$f" ] && { PR_YAML="$f"; break; }
+done
+echo "convention: ${PR_YAML:-$CFG (no .agents/config/pr.yaml)}"
 ```
 
-- config missing → STOP: "run `npx @nvice-r/pr-commands`".
-- provider unknown → STOP: only bitbucket/github/gitlab supported.
-- `$BIN` = `ghpr`/`glpr` and not installed → STOP: "provider not yet supported (macOS+Bitbucket only for now)". (D6 stub.)
+- config or `pr-commands` missing → STOP: "run `npx @nvice-r/pr-commands`".
+- `pr-commands check` fails → STOP and show its message (unknown host, or
+  "<provider> not yet supported" — only Bitbucket for now). (D6 stub.)
 - all pass → continue.
 
 ## Step 1 — gather context (parallel)
 - `git rev-parse --abbrev-ref HEAD` — source branch (CURR)
-- `git config --get branch.<CURR>.bbprBase` — saved base, if any
+- `git config --get branch.<CURR>.base` — saved base, if any
 - `git log --oneline -20`
-- read `convention=` from `$CFG` (default `trueid` if unset — but config presence already enforced in Step 0)
+- read the **convention source**: `$PR_YAML` if Step 0 found one, else the convention keys in `$CFG`.
+  Every later step that says "convention" means this source.
+
+**Convention keys** (YAML in `pr.yaml`; `key=value` in `$CFG`, where list values are pipe-separated):
+
+| key | meaning | if missing |
+|-----|---------|------------|
+| `title_pattern` | title template with `<ver> <desc> <ticket> <type> <scope> <issue>` | ask the user |
+| `ticket_regex` | ticket key in the branch name | no ticket |
+| `template_sections` | body `## ` headings, in order | `Summary`, `Changes` |
+| `body_rules` | extra project rules for the body (free text, follow literally) | none |
+| `base` | default base proposal (Step 2 d) | ask |
+| `draft` | `ask` / `true` / `false` | `ask` |
+| `push` | remotes to push before create (Step 7.5) | none (assume pushed) |
+| `fork` | `{remote, repo}` for cross-repo mode | cross mode unavailable |
+| `pre_pr` | shell commands run before confirm (Step 6.5) | none |
+| `post_pr` | sibling skills offered after create (Step 10) | none |
 
 ## Step 2 — determine base branch (priority)
 a. `$1` (any arg containing `/`) → use it.
-b. else `branch.<CURR>.bbprBase` from git config → use silently.
+b. else saved `branch.<CURR>.base` from git config → use silently.
 c. else infer — smallest non-zero `<ref>..HEAD` distance where `<ref>` is an ancestor of HEAD:
    ```bash
    for ref in $(git for-each-ref --format='%(refname:short)' refs/remotes/origin | grep -v "^origin/<CURR>$"); do
@@ -85,9 +110,9 @@ c. else infer — smallest non-zero `<ref>..HEAD` distance where `<ref>` is an a
    ```
    Propose smallest-`ahead` candidate; confirm. Do NOT auto-pick a naming-pattern match — a
    stacked PR on another in-flight ticket branch is common. Ties or all >20 ahead → ask.
-d. still ambiguous → ask.
+d. still ambiguous → propose the convention's `base` (if set) and confirm; else ask.
 
-The binary auto-saves the resolved base to `branch.<CURR>.bbprBase` on success.
+`pr-commands` auto-saves the resolved base to `branch.<CURR>.base` on success.
 
 ## Step 3 — build diff context
 `git log <base>..HEAD --oneline` · `git diff --stat <base>..HEAD`. Multiple commits → summarize each.
@@ -99,23 +124,30 @@ diff into seams, detect coupling (shared file/symbol → stacked; disjoint → i
 → one atomic PR), present metrics + seam table, then `AskUserQuestion`: proceed-as-one /
 split (`guard_cmd pr-split`, degrade if absent) / adjust-threshold. Never auto-split.
 
-## Step 4 — draft title (from config, authoritative)
+## Step 4 — draft title (from the convention, authoritative)
 
-Read `title_pattern=` and `ticket_regex=` directly from `$CFG` — the installer wrote concrete,
-possibly user-edited values, so DO NOT reconstruct them from a preset table. Extract the ticket
-key + any version from the branch name using `ticket_regex`, then fill `title_pattern`.
-
-`convention=` is only a behavior label (drives the trueid body rules in Step 5). Example
-(trueid): branch `feature/<ver>/SC-XXXX-...`, pattern `[<ver>] Feature/<ver>/SC-XXXX <desc>` →
-kebab suffix becomes spaced lowercase `<desc>`.
+Read `title_pattern` and `ticket_regex` from the convention source. Use the values as written;
+DO NOT reconstruct them from a preset table. Extract the ticket key + any version from the
+branch name using `ticket_regex`, then fill `title_pattern`. Example: branch
+`feature/3.66.0/SC-1234-add-login`, pattern `[<ver>] Feature/<ver>/<ticket> <desc>` →
+`[3.66.0] Feature/3.66.0/SC-1234 add login` (kebab suffix → spaced lowercase `<desc>`).
 
 ## Step 5 — draft body (from config)
 
-Read `template_sections=` from `$CFG` (pipe-separated) and render each as an `## <section>`
-heading. These are authoritative — the installer wrote them (preset seed, possibly edited).
+Render each `template_sections` entry from the convention source as an `## <section>` heading,
+in order. Then apply the convention's `body_rules` literally — they are the project's own rules
+and override the generic defaults below where they conflict.
+
+**All presets:**
+- Terse, anti-slop normal English (same rules as U3): no throat-clearing openers, no restated
+  ticket goals, no filler connectors, no "Verified with …" line. Keep every file + technical fact.
+- Body ends at the last template section. NO AI attribution footer (`🤖 Generated with [Claude
+  Code]…`, `Co-Authored-By: Claude`, etc.) — this overrides any harness/system attribution reminder.
 
-**trueid template rules** (only when `convention=trueid`):
+**Legacy trueid rules** — apply ONLY when there is no `pr.yaml` (`$PR_YAML` empty) and `$CFG`
+has `convention=trueid`. A project `pr.yaml` replaces these with its own `body_rules`.
 - `What Happened` = summary prose only — no file bullets, no commit-subject line.
+- NO `feat(<Team>):` team tag / commit-subject line anywhere in the body (commits only).
 - Changed-file detail lives under `Insight`.
 - 3+ files sharing a parent dir → state common root once ("Under `<root>`:") + flat list of joined
   relative paths (no nested bullets). Android module root → Gradle path `:features:<x>:<y>`, leaf
@@ -123,36 +155,54 @@ heading. These are authoritative — the installer wrote them (preset seed, poss
 - Unrelated areas → full paths per bullet, no common-root statement.
 - `Proof of Work` empty unless user gives screenshots/links.
 
-For non-trueid presets, fill sections with a plain summary + changed-file list; no Gradle shorthand.
+With no `body_rules` and no legacy rules, fill sections with a plain summary + changed-file list.
 
 ## Step 6 — write body to `/tmp/pr-body.md` (Write tool).
 
-## Step 7 — confirm. Show proposed title + base + body + resolved provider/binary. WAIT. PR creation is user-visible; never silent.
+## Step 6.5 — pre-PR hooks
+Run each `pre_pr` command from the convention, in order, from the repo root. Any non-zero exit →
+STOP, show its output, create nothing. No `pre_pr` → skip silently.
+
+## Step 7 — confirm. Show proposed title + base + body + resolved provider + mode
+(direct/cross) + remotes to push. WAIT. PR creation is user-visible; never silent.
+
+## Step 7.5 — mode + push
+- **Mode.** `cross` arg → cross. Else saved `branch.<CURR>.prMode` → use it. Else, when the
+  convention has `fork`: branch exists only on `fork.remote` (`git ls-remote <remote> <CURR>`)
+  → cross; otherwise direct. No `fork` → always direct; `cross` arg → STOP ("no fork in pr.yaml").
+- **Direct:** push every remote in `push` (`git push <remote> HEAD`), in order.
+- **Cross:** push `fork.remote` only. Never push to `origin`.
+- Push failure → STOP and show the error. Never pass `--no-verify` (pre-push hooks may lint;
+  allow 30–60 s). No `push` key → do not push; warn if HEAD is ahead of its upstream.
 
-## Step 8 — create. Run the detected binary (append `--draft` only if draft chosen):
+## Step 8 — create. Run `pr-commands create` (append `--draft` only if draft chosen):
 ```bash
-<BIN> --title "<title>" --body-file /tmp/pr-body.md --dest "<base>" [--draft]
+pr-commands create --title "<title>" --body-file /tmp/pr-body.md --dest "<base>" [--draft] \
+      [--source-repo "<fork.repo>"]                     # cross mode only
 ```
-Always ask open-vs-draft before creating unless `draft` was passed. The binary attaches the
+Draft: `draft` arg → draft. Else convention `draft: true|false` → use it. Else (`ask` or unset)
+ask open-vs-draft before creating. After a cross-mode success, run
+`git config branch.<CURR>.prMode cross` so the next `/pr` reuses the mode. `pr-commands` attaches the
 per-repo reviewer roster automatically; `--no-reviewers` skips, `--reviewer <id>` appends.
 
-## Step 9 — print final PR URL + reviewer count from binary output. On error, surface raw response.
+## Step 9 — print final PR URL + reviewer count from `pr-commands` output. On error, surface raw response.
 
-## Step 10 — offer Jira sync (guarded, optional).
-Reuse ticket key from Step 4. If none, skip. `guard_cmd jira-update`; if absent, just print URL + stop.
-If present, `AskUserQuestion`: sync now → `/jira-update <KEY>`, or skip (print reminder).
+## Step 10 — post-PR skills (guarded, optional).
+For each skill in the convention's `post_pr` (legacy config without `pr.yaml`: `jira-update`):
+`guard_cmd <skill>`; absent → one-line note, skip. Present → `AskUserQuestion`: run now
+(`/<skill> <ticket>` with the Step 4 ticket key) or skip. No ticket key → skip ticket-based skills.
 
 ## Update mode (`/pr update [PR#] [short]`)
 
 Rewrites an existing open PR's **description** in place — no new branch, no new PR. Same Step 0
 install check runs first (config + provider + creds). Provider PATCH is currently Bitbucket-only,
-matching the create path; `ghpr`/`glpr` providers → STOP with the same "not yet supported" note.
+matching the create path; any other host → STOP with the same "not yet supported" note.
 
 **U1 — parse args.** Tokens after `update`: a bare integer = `PR#`; the word `short` (or
 `caveman`) = compress-hard flag. Missing `PR#` → resolve from the current branch: query the
 provider for the open PR whose source branch is `HEAD` (Bitbucket: `GET /pullrequests?q=source.branch.name="<CURR>"&state=OPEN`). Zero or multiple matches → ask.
 
-**U2 — fetch current PR.** Resolve creds the same way the binary does — email from `$CFG`
+**U2 — fetch current PR.** Resolve creds the same way `pr-commands` does — email from `$CFG`
 (`email=`), token from the OS keychain (macOS service `bitbucket-api-token`, account = email).
 `REPO` = workspace/slug from `git remote get-url origin`. Fetch title + description:
 ```bash

package/install.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 // @nvice-r/pr-commands installer. Zero external deps (Node >=16 builtins only).
 // Wizard: detect OS + provider, pick reviewers + convention, write config/roster,
-// install binaries -> ~/.local/bin, install the portable `pr` SKILL.md into every
+// install the `pr-commands` entry point -> ~/.local/bin (+ shared lib and host providers ->
+// ~/.local/share/pr-commands), install the portable `pr` SKILL.md into every
 // detected agent (symlinked to one canonical copy) + Claude /pr slash-command.
 //
 // Flags: --dir <path>  --provider <p>  --agent <id>  --all  --yes  --dry-run  --help
@@ -16,13 +17,15 @@ const { execFileSync } = require('child_process');
 
 const HOME = os.homedir();
 const PKG = __dirname;
+const PKG_VERSION = require('./package.json').version;
 const ASSETS = path.join(PKG, 'assets');
 const BACK = Symbol('back');   // returned by a prompt when the user wants the previous step
 
 const PROVIDERS = {
-  bitbucket: { bin: 'bbpr', host: 'bitbucket.org', keychainSvc: 'bitbucket-api-token', ready: true },
-  github:    { bin: 'ghpr', host: 'github.com',    keychainSvc: 'github-api-token',    ready: false },
-  gitlab:    { bin: 'glpr', host: 'gitlab.com',     keychainSvc: 'gitlab-api-token',    ready: false },
+  // provider code = assets/share/pr-commands/providers/<name>.sh
+  bitbucket: { host: 'bitbucket.org', keychainSvc: 'bitbucket-api-token', ready: true },
+  github:    { host: 'github.com',    keychainSvc: 'github-api-token',    ready: false },
+  gitlab:    { host: 'gitlab.com',     keychainSvc: 'gitlab-api-token',    ready: false },
 };
 const CONVENTIONS = ['trueid', 'conventional', 'github-default', 'custom'];
 // Concrete, editable defaults per preset. Whatever the user confirms is written to config,
@@ -36,7 +39,7 @@ const PRESET_DEFS = {
 
 // ---- arg parse ----
 const argv = process.argv.slice(2);
-const flags = { dir: null, provider: null, all: false, yes: false, dryRun: false, agentDir: null, agents: null };
+const flags = { dir: null, provider: null, all: false, yes: false, dryRun: false, agentDir: null, agents: null, resetReviewers: false };
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
   if (a === '--help' || a === '-h') { printHelp(); process.exit(0); }
@@ -47,9 +50,10 @@ for (let i = 0; i < argv.length; i++) {
   else if (a === '--all') flags.all = true;
   else if (a === '--yes' || a === '-y') flags.yes = true;
   else if (a === '--dry-run') flags.dryRun = true;
+  else if (a === '--reset-reviewers') flags.resetReviewers = true;
   else { console.error(`unknown flag: ${a}`); process.exit(1); }
 }
-const AGENT_DIR = (flags.agentDir || '.claude').replace(/^\/+|\/+$/g, '');  // strip stray slashes
+const cleanDir = (d) => d.replace(/^\/+|\/+$/g, '');   // strip stray slashes
 
 // ---- portable skill ----
 // One canonical SKILL.md (~/.config/pr/skill/pr/); every detected agent's global skills
@@ -68,17 +72,18 @@ model: sonnet
 ---
 
 `;
-// base = probe dir deciding "installed"; skills = GLOBAL skills dir we link into.
+// base = probe dir deciding "installed"; skills = GLOBAL skills dir we link into;
+// repoDir = the agent's per-repo folder (holds the reviewer roster when it's the primary agent).
 // Env vars resolved the same way the agents themselves resolve them.
 function agentTargets() {
   const claudeBase = process.env.CLAUDE_CONFIG_DIR || path.join(HOME, '.claude');
   const codexBase  = process.env.CODEX_HOME || path.join(HOME, '.codex');
   const xdg        = process.env.XDG_CONFIG_HOME || path.join(HOME, '.config');
   return [
-    { id: 'claude-code', base: claudeBase,                             skills: path.join(claudeBase, 'skills'),                     claude: true },
-    { id: 'antigravity', base: path.join(HOME, '.gemini/antigravity'), skills: path.join(HOME, '.gemini/antigravity/skills') },
-    { id: 'codex',       base: codexBase,                              skills: path.join(codexBase, 'skills') },
-    { id: 'opencode',    base: path.join(xdg, 'opencode'),             skills: path.join(xdg, 'opencode/skills') },
+    { id: 'claude-code', base: claudeBase,                             skills: path.join(claudeBase, 'skills'),                     repoDir: '.claude', claude: true },
+    { id: 'antigravity', base: path.join(HOME, '.gemini/antigravity'), skills: path.join(HOME, '.gemini/antigravity/skills'), repoDir: '.agent' },
+    { id: 'codex',       base: codexBase,                              skills: path.join(codexBase, 'skills'),                      repoDir: '.codex' },
+    { id: 'opencode',    base: path.join(xdg, 'opencode'),             skills: path.join(xdg, 'opencode/skills'),                   repoDir: '.opencode' },
   ];
 }
 
@@ -89,11 +94,13 @@ function printHelp() {
 
   --dir <path>       Repo to configure (default: cwd)
   --provider <p>     Force bitbucket|github|gitlab (default: detect from remote)
-  --agent-dir <dir>  (deprecated) Legacy roster folder; roster now lives in <root>/.pr/
+  --agent-dir <dir>  Repo folder holding the reviewer roster (default: primary agent's
+                     folder — .claude / .agent / .codex / .opencode)
   --agent <id>       Force skill install to this agent (repeatable). Ids: claude-code,
                      antigravity, codex, opencode. Default: auto-detect installed agents.
-  --all              Install all provider binaries (default: only the detected one)
-  --yes              Accept defaults, no prompts (reviewers=all, convention=trueid)
+  --all              Install every ready host provider (default: only the detected one)
+  --yes              Accept defaults, no prompts (reviewers=existing roster or all, convention=trueid)
+  --reset-reviewers  Ignore an existing roster and rebuild it from the repo's default reviewers
   --dry-run          Print planned actions, write nothing
   --help             This help`);
 }
@@ -259,6 +266,21 @@ function writeFile(p, content, mode) {
 // Main repo root, shared across worktrees: git-common-dir points at the main .git
 // even from a linked worktree; its parent is the main checkout root. gitCommonDir
 // may be relative ('.git') or absolute ('/main/.git') — path.resolve handles both.
+// Existing roster, so a reinstall keeps it: --agent-dir, each agent's repo folder, then the
+// 0.1.2 neutral .pr/ location. Returns { file, entries: [{uuid, name}] } or null.
+function findExistingRoster(mroot) {
+  const dirs = [flags.agentDir && cleanDir(flags.agentDir), ...agentTargets().map((t) => t.repoDir)].filter(Boolean);
+  const files = [...new Set(dirs)].map((d) => path.join(mroot, d, 'pr-reviewers.txt'))
+    .concat(path.join(mroot, '.pr', 'reviewers.txt'));
+  const file = files.find((f) => fs.existsSync(f));
+  if (!file) return null;
+  const entries = [];
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    const m = line.match(/^\s*(\{[^}]+\})\s*(?:#\s*(.*))?$/);
+    if (m) entries.push({ uuid: m[1], name: (m[2] || '').trim() });
+  }
+  return { file, entries };
+}
 function mainRepoRoot(wd) {
   const gcd = shSafe('git', ['-C', wd, 'rev-parse', '--git-common-dir']);
   return gcd ? path.resolve(wd, gcd, '..') : null;
@@ -325,6 +347,20 @@ function scanGitRepos(root, maxDepth = 3, cap = 50) {
   return found;
 }
 
+// Remove binaries from <= 0.1.3 (bbpr + pr-common.sh in ~/.local/bin). Only files that carry
+// our own version marker are deleted, so an unrelated file with the same name is left alone.
+function removeLegacyBins(binDir) {
+  for (const [name, marker] of [['bbpr', 'bbpr-version'], ['pr-common.sh', 'pr-common-version']]) {
+    const p = path.join(binDir, name);
+    let txt;
+    try { txt = fs.readFileSync(p, 'utf8'); } catch { continue; }
+    if (!txt.includes(marker)) { log(`  kept ${p} (not ours)`); continue; }
+    if (flags.dryRun) { log(`  [dry-run] remove legacy ${p}`); continue; }
+    fs.unlinkSync(p);
+    log(`  removed legacy ${p}`);
+  }
+}
+
 // ---- provider detection ----
 function detectProvider(remoteUrl) {
   if (flags.provider) return flags.provider;
@@ -406,7 +442,7 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
     const L = [];
     if (stage > 0 && st.workDir) {
       L.push(`  \x1b[32m✓\x1b[0m work dir    ${st.workDir}`);
-      L.push(`  \x1b[32m✓\x1b[0m provider    ${st.provider} (${st.slug}) → ${st.pcfg.bin}`);
+      L.push(`  \x1b[32m✓\x1b[0m provider    ${st.provider} (${st.slug})`);
       L.push(`  \x1b[32m✓\x1b[0m auth        ${st.email || '(none)'}${st.token ? ' · token ok' : ' · no token'}`);
     }
     if (stage > 1 && st.chosen) L.push(`  \x1b[32m✓\x1b[0m reviewers   ${st.chosen.length} selected`);
@@ -461,7 +497,7 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
     if (!provider) { console.error(`  ERROR: could not detect provider from ${remoteUrl}`); process.exit(1); }
     const pcfg = PROVIDERS[provider];
     const slug = parseSlug(remoteUrl);
-    log(`  remote: ${remoteUrl}\n  provider=${provider}  slug=${slug}  binary=${pcfg.bin}`);
+    log(`  remote: ${remoteUrl}\n  provider=${provider}  slug=${slug}`);
     if (!pcfg.ready) { console.error(`  ERROR: ${provider} not yet supported (macOS+Bitbucket only). Aborting.`); process.exit(1); }
     // identity + token (derived from provider)
     let email = '';
@@ -474,7 +510,7 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
       log(`  WARN: no keychain token for ${pcfg.keychainSvc}/${email || '(none)'} — reviewers can't auto-fetch`);
       log(`    security add-generic-password -s ${pcfg.keychainSvc} -a ${email || 'you@example.com'} -w '<api-token>'`);
     } else log('  token: found');
-    if (st.slug !== slug) st.revs = undefined;   // invalidate reviewer cache if repo changed
+    if (st.slug !== slug) { st.revs = undefined; st.existing = undefined; st.chosenIdx = undefined; }   // repo changed → drop reviewer caches
     const mroot = mainRepoRoot(wd) || wd;        // shared across worktrees; roster lives here
     if (mroot !== wd) log(`  worktree detected → roster shared at main root: ${mroot}`);
     Object.assign(st, { workDir: wd, mainRoot: mroot, remoteUrl, provider, pcfg, slug, email, token });
@@ -483,6 +519,13 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
   const sReviewers = async () => {
     screen(1, 'Reviewers');
     st.chosen = st.chosen || [];
+    if (st.existing === undefined) st.existing = flags.resetReviewers ? null : findExistingRoster(st.mainRoot);
+    const ex = st.existing;
+    if (ex) log(`  existing roster: ${ex.file} (${ex.entries.length})`);
+    // --yes (or no token to fetch with) + existing roster → keep it untouched, skip the fetch.
+    if (ex && (flags.yes || !(st.token && st.email))) {
+      st.chosen = ex.entries; st.extra = []; log('  kept existing roster (--reset-reviewers to rebuild)'); return;
+    }
     if (!(st.token && st.email)) { log('  skipped (no token) — edit the roster later.'); st.chosen = []; return; }
     if (st.selfUuid === undefined) st.selfUuid = await fetchSelfUuid(st.email, st.token);
     if (st.revs === undefined) st.revs = await fetchBitbucketReviewers(st.slug, st.email, st.token, st.selfUuid);
@@ -490,14 +533,18 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
     if (!revs) { log('  WARN: could not fetch default-reviewers. Roster left empty.'); st.chosen = []; return; }
     if (revs.length === 0) { log('  repo has no default reviewers. Roster left empty.'); st.chosen = []; return; }
     if (flags.yes) { st.chosen = revs; st.chosenIdx = revs.map((_, i) => i); log(`  selected all ${revs.length}`); return; }
+    // Existing roster → pre-check its members; entries not among the defaults are kept as-is.
+    const exIds = ex ? new Set(ex.entries.map((e) => e.uuid)) : null;
+    st.extra = ex ? ex.entries.filter((e) => !revs.some((r) => r.uuid === e.uuid)) : [];
+    const preIdx = st.chosenIdx || (exIds ? revs.map((r, i) => (exIds.has(r.uuid) ? i : -1)).filter((i) => i >= 0) : null);
     const picked = await multiSelect(
-      `Reviewers for ${st.slug} (default: all):`,
-      revs.map((r) => ({ label: r.name })), true, st.chosenIdx || null,
+      `Reviewers for ${st.slug} (default: ${ex ? 'existing roster' : 'all'}):`,
+      revs.map((r) => ({ label: r.name })), true, preIdx,
     );
     if (picked === BACK) return BACK;
     st.chosenIdx = picked;
-    st.chosen = picked.map((i) => revs[i]);
-    log(`  chosen: ${st.chosen.length}`);
+    st.chosen = picked.map((i) => revs[i]).concat(st.extra);
+    log(`  chosen: ${st.chosen.length}${st.extra.length ? ` (incl. ${st.extra.length} kept from existing roster, not in defaults)` : ''}`);
   };
 
   const sPreset = async () => {
@@ -561,29 +608,45 @@ async function fetchBitbucketReviewers(slug, email, token, selfUuid) {
 
   // --- install ---
   screen(4, 'Install');
-  const { slug, pcfg, email, convention, conv, chosen } = st;
-  let cfg = `os=${cfgOs}\ntoken_src=${tokenSrc}\nemail=${email}\nconvention=${convention}\nagent_dir=${AGENT_DIR}\n`;
+  const { slug, email, convention, conv, chosen } = st;
+  // Roster folder = --agent-dir, else the first chosen agent's repo folder, else .claude.
+  const agentIds = st.agents || detectedAgentIds();
+  const primary = agentTargets().find((t) => t.id === agentIds[0]);
+  const agentDir = cleanDir(flags.agentDir || (primary && primary.repoDir) || '.claude');
+  let cfg = `pkg_version=${PKG_VERSION}\nos=${cfgOs}\ntoken_src=${tokenSrc}\nemail=${email}\nconvention=${convention}\nagent_dir=${agentDir}\n`;
   if (conv.title_pattern)     cfg += `title_pattern=${conv.title_pattern}\n`;
   if (conv.ticket_regex)      cfg += `ticket_regex=${conv.ticket_regex}\n`;
   if (conv.template_sections) cfg += `template_sections=${conv.template_sections}\n`;
   writeFile(path.join(HOME, '.config/pr/config'), cfg, 0o600);
-  // Roster: neutral <main-repo-root>/.pr/reviewers.txt — agent-agnostic (bash reads it, not the
-  // agent), shared across worktrees, survives switching agents. pr-common.sh finds it first,
-  // falling back to the legacy agent-dir/root/global paths.
-  const roster = chosen.map((r) => `${r.uuid}  # ${r.name}`).join('\n') + (chosen.length ? '\n' : '');
-  const header = `# pr reviewers for ${slug} — {uuid}  # Name per line; blanks/# ignored. Edit freely.\n`;
-  writeFile(path.join(st.mainRoot, '.pr', 'reviewers.txt'), header + (roster || '# (none selected)\n'));
+  // Roster: <main-repo-root>/<agent_dir>/pr-reviewers.txt — lives with the primary agent's repo
+  // folder, shared across worktrees. agent_dir is recorded in the config so the bash binary
+  // (which can't know the calling agent) reads the same path; legacy .pr/ + root + global paths
+  // remain load fallbacks.
+  const rosterFile = path.join(st.mainRoot, agentDir, 'pr-reviewers.txt');
+  const kept = st.existing && chosen === st.existing.entries;   // untouched existing roster
+  if (kept && st.existing.file === rosterFile) log(`  kept ${rosterFile}`);
+  else if (kept) writeFile(rosterFile, fs.readFileSync(st.existing.file));  // move to new agent_dir; old file left as fallback
+  else {
+    const roster = chosen.map((r) => `${r.uuid}  # ${r.name}`).join('\n') + (chosen.length ? '\n' : '');
+    const header = `# pr reviewers for ${slug} — {uuid}  # Name per line; blanks/# ignored. Edit freely.\n`;
+    writeFile(rosterFile, header + (roster || '# (none selected)\n'));
+  }
+  // One entry point on PATH; shared lib + host providers under ~/.local/share/pr-commands.
   const binDir = path.join(HOME, '.local/bin');
-  const binsToInstall = flags.all
-    ? Object.values(PROVIDERS).filter((p) => p.ready).map((p) => p.bin)
-    : [pcfg.bin];
-  writeFile(path.join(binDir, 'pr-common.sh'), fs.readFileSync(path.join(ASSETS, 'bin/pr-common.sh')), 0o755);
-  for (const b of binsToInstall) {
-    const src = path.join(ASSETS, 'bin', b);
-    if (!fs.existsSync(src)) { log(`  skip ${b} (asset not present yet)`); continue; }
-    writeFile(path.join(binDir, b), fs.readFileSync(src), 0o755);
+  const shareDir = path.join(HOME, '.local/share/pr-commands');
+  const shareSrc = path.join(ASSETS, 'share/pr-commands');
+  writeFile(path.join(binDir, 'pr-commands'), fs.readFileSync(path.join(ASSETS, 'bin/pr-commands')), 0o755);
+  writeFile(path.join(shareDir, 'pr-common.sh'), fs.readFileSync(path.join(shareSrc, 'pr-common.sh')), 0o644);
+  const provNames = flags.all
+    ? Object.keys(PROVIDERS).filter((n) => PROVIDERS[n].ready)
+    : [st.provider];
+  for (const n of provNames) {
+    const src = path.join(shareSrc, 'providers', `${n}.sh`);
+    if (!fs.existsSync(src)) { log(`  skip ${n} (provider not present yet)`); continue; }
+    writeFile(path.join(shareDir, 'providers', `${n}.sh`), fs.readFileSync(src), 0o644);
   }
-  installSkill(st.agents || detectedAgentIds());
+  removeLegacyBins(binDir);
+  installSkill(agentIds);
   if (!(process.env.PATH || '').split(':').includes(binDir)) {
     log(`\n  WARN: ${binDir} not on PATH. Add to your shell rc:`);
     log(`    export PATH="$HOME/.local/bin:$PATH"`);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@nvice-r/pr-commands",
-  "version": "0.1.2",
-  "description": "Provider-agnostic PR helper for Claude Code — npx installer + bbpr/ghpr/glpr binaries + /pr skill",
+  "version": "0.1.4",
+  "description": "Provider-agnostic PR helper for Claude Code — npx installer + one `pr-commands` command (per-host providers) + /pr skill",
   "bin": {
-    "pr-commands": "install.js"
+    "pr-commands-setup": "install.js"
   },
   "files": [
     "install.js",

package/assets/bin/bbpr

@@ -1,78 +0,0 @@
-#!/usr/bin/env bash
-# bbpr-version: 8
-# bbpr — create a Bitbucket Cloud pull request (REST API v2.0).
-# Provider-specific layer; all git/config/creds/reviewer logic lives in pr-common.sh.
-# Usage: bbpr --title "..." [--body|--body-file] [--source b] [--dest b] [--repo w/s]
-#             [--draft] [--reviewer uuid]... [--no-reviewers] [--email a] [--close-source]
-
-set -euo pipefail
-
-PR_CMD="bbpr"
-KEYCHAIN_SERVICE="bitbucket-api-token"
-
-# locate + source the shared lib (same dir as this binary)
-_here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=pr-common.sh
-. "$_here/pr-common.sh"
-
-pr_common_init "$@"
-
-# --- Bitbucket: drop the PR author's own UUID (BB rejects author-as-reviewer) ---
-if [ "${#FINAL_REVIEWERS[@]}" -gt 0 ]; then
-  SELF_UUID="$(curl -sS -u "${EMAIL}:${TOKEN}" "https://api.bitbucket.org/2.0/user" 2>/dev/null \
-    | python3 -c 'import json,sys
-try: print(json.load(sys.stdin).get("uuid",""))
-except Exception: print("")' 2>/dev/null || true)"
-  if [ -n "$SELF_UUID" ]; then
-    FILTERED=()
-    for r in "${FINAL_REVIEWERS[@]}"; do
-      [ "$r" = "$SELF_UUID" ] || FILTERED+=("$r")
-    done
-    FINAL_REVIEWERS=("${FILTERED[@]:-}")
-    [ -z "${FINAL_REVIEWERS[0]:-}" ] && FINAL_REVIEWERS=()
-  fi
-fi
-
-# --- Bitbucket payload (source/destination keys, draft, reviewers[]) ---
-PAYLOAD="$(
-  TITLE="$TITLE" BODY="$BODY" SOURCE="$SOURCE" DEST="$DEST" \
-  DRAFT="$DRAFT" CLOSE_SOURCE="$CLOSE_SOURCE" \
-  REVIEWERS_JSON="$(printf '%s\n' "${FINAL_REVIEWERS[@]:-}" | python3 -c 'import json,sys; print(json.dumps([{"uuid": l.strip()} for l in sys.stdin if l.strip()]))')" \
-  python3 -c '
-import json, os
-p = {
-  "title": os.environ["TITLE"],
-  "description": os.environ["BODY"],
-  "source": {"branch": {"name": os.environ["SOURCE"]}},
-  "destination": {"branch": {"name": os.environ["DEST"]}},
-  "draft": os.environ["DRAFT"] == "true",
-  "close_source_branch": os.environ["CLOSE_SOURCE"] == "true",
-}
-revs = json.loads(os.environ["REVIEWERS_JSON"])
-if revs: p["reviewers"] = revs
-print(json.dumps(p))
-'
-)"
-
-URL="https://api.bitbucket.org/2.0/repositories/${REPO}/pullrequests"
-echo "POST $URL"
-echo "source=$SOURCE  dest=$DEST  draft=$DRAFT  reviewers=${#FINAL_REVIEWERS[@]}"
-
-RESP="$(curl -sS -X POST "$URL" -u "${EMAIL}:${TOKEN}" \
-  -H 'Content-Type: application/json' -d "$PAYLOAD")"
-
-PR_INFO="$(echo "$RESP" | python3 -c '
-import json, sys
-try: d = json.loads(sys.stdin.read())
-except Exception as e: print("non-JSON response", e); sys.exit(2)
-if "error" in d: print("ERROR:", json.dumps(d["error"], indent=2)); sys.exit(1)
-print(str(d.get("id")) + "\t" + str(d.get("links", {}).get("html", {}).get("href")))
-')"
-
-NEW_PR_ID="$(echo "$PR_INFO" | cut -f1)"
-NEW_PR_URL="$(echo "$PR_INFO" | cut -f2)"
-ATTACHED="$(echo "$RESP" | python3 -c 'import json,sys; print(len(json.load(sys.stdin).get("reviewers", [])))')"
-echo "created PR #${NEW_PR_ID} with ${ATTACHED} reviewers"
-echo "$NEW_PR_URL"
-
-[ -n "$NEW_PR_ID" ] && pr_save_base