claude-dev-env 2.1.0 → 2.2.0

package/skills/autoconverge/reference/multi-pr.md

@@ -42,7 +42,27 @@ each PR its own checkout with `git worktree add`. For each PR the user named:
    non-zero exit sets `copilotDisabled: true` on every entry, so each child skips
    the Copilot gate with no agent spawned.
 
-## Launch the multi-PR workflow
+## Launch
+
+Select the pacer once for the multi-PR run (same helper as single-PR):
+
+```
+python "$HOME/.claude/skills/_shared/pr-loop/scripts/select_converge_pacer.py" \
+  --skill autoconverge \
+  --has-workflow <0|1> \
+  --has-schedule-wakeup <0|1>
+```
+
+### `pacer=portable`
+
+Do **not** call `Workflow`. For each PR worktree from pre-flight, run the
+continuous portable driver in
+[`../../_shared/pr-loop/portable-driver.md`](../../_shared/pr-loop/portable-driver.md)
+(serial, or host fan-out when the host can isolate workers). One teardown per
+PR after that PR reaches ready or a named blocker. Shared Copilot quota and
+permission grants from multi-PR pre-flight still apply once.
+
+### `pacer=workflow`
 
 Call the `Workflow` tool against the fan-out script, passing the absolute path of
 `converge.mjs` and one entry per PR:
@@ -74,7 +94,18 @@ Each record's `deferredPrs` is that PR's own list of draft hardening PRs, and
 `allDeferredPrs` is every record's `deferredPrs` flattened into one list. The
 top-level `converged` is true only when every PR converged.
 
-## Multi-PR teardown (on workflow completion)
+## Multi-PR teardown
+
+### `pacer=portable`
+
+For each PR worktree, run the single-PR **Teardown → pacer=portable** path in
+[`SKILL.md`](../SKILL.md) (`pr-loop-lifecycle` Close, no Workflow journal
+report). Write one durable handoff per PR with that PR's `--pr-number` and
+resume command `/autoconverge <PR URL>`. Revoke project permissions once per
+repository after every PR's close. Print one summary line per PR as
+`#<prNumber>: <converged | blocked> — rounds <N>, final <finalSha>[, blocker <blocker>]`.
+
+### `pacer=workflow` (on workflow completion)
 
 Run the single-PR Teardown in [`SKILL.md`](../SKILL.md) once per entry in
 `results`, using that PR's `owner`, `repo`, `prNumber`, and `finalSha`, and its

package/skills/autoconverge/reference/stop-conditions.md

@@ -6,14 +6,17 @@ skill still runs teardown (revoke permissions, final report).
 
 ## Blockers (end the run short of ready)
 
-- **Budget stop** — the workflow's `budget` API is the pacing signal: when a
-  usage target is set, `converge.mjs` checks `budget.remaining()` before each
-  round and stops at the round boundary when one full round (three parallel
-  lenses + one fix commit + re-verify) does not fit. The run returns
-  `blocker: "budget"` with the run id; resume with
+- **Budget stop** — on `pacer=workflow`, the workflow's `budget` API is the
+  pacing signal: when a usage target is set, `converge.mjs` checks
+  `budget.remaining()` before each round and stops at the round boundary when
+  one full round (three parallel lenses + one fix commit + re-verify) does not
+  fit. The run returns `blocker: "budget"` with the run id; resume with
   `Workflow({scriptPath, resumeFromRunId})` — completed rounds replay from the
   journal. The workflow never starts a round the budget cannot finish: a
-  half-run round records nothing resumable and replays dirty.
+  half-run round records nothing resumable and replays dirty. On
+  `pacer=portable`, stop at a tick boundary when the session cannot cover a
+  full clean tick; write handoff and resume with `/autoconverge <PR URL>`
+  ([`../../_shared/pr-loop/portable-driver.md`](../../_shared/pr-loop/portable-driver.md)).
 - **Iteration cap** — 20 loop iterations pass without a full convergence-check
   pass. The iteration counter increments on every pass through any phase, so a
   convergence-check gate that no round can clear (for example a `mergeable_state`

package/skills/autoconverge/test_portable_pacer_gate.py

@@ -0,0 +1,54 @@
+"""Contract checks: autoconverge selects a portable pacer when Workflow is absent."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parent
+SKILL_MARKDOWN_PATH = SKILL_ROOT / "SKILL.md"
+MULTI_PR_MARKDOWN_PATH = SKILL_ROOT / "reference" / "multi-pr.md"
+PORTABLE_DRIVER_PATH = (
+    SKILL_ROOT.parent / "_shared" / "pr-loop" / "portable-driver.md"
+)
+
+SELECT_CONVERGE_PACER_SCRIPT = "select_converge_pacer.py"
+PACER_PORTABLE_TOKEN = "pacer=portable"
+PACER_WORKFLOW_TOKEN = "pacer=workflow"
+ABORT_ONLY_PHRASE = "autoconverge requires the Workflow tool"
+PORTABLE_DRIVER_DOC = "portable-driver.md"
+PORTABLE_DRIVER_LINK_PATTERN = re.compile(
+    r"\((?P<relative>(?:\.\./)+_shared/pr-loop/portable-driver\.md)\)"
+)
+
+
+def test_skill_selects_pacer_and_forbids_abort_only_workflow() -> None:
+    skill_text = SKILL_MARKDOWN_PATH.read_text(encoding="utf-8")
+    assert SELECT_CONVERGE_PACER_SCRIPT in skill_text
+    assert PACER_PORTABLE_TOKEN in skill_text
+    assert PACER_WORKFLOW_TOKEN in skill_text
+    assert PORTABLE_DRIVER_DOC in skill_text
+    assert ABORT_ONLY_PHRASE not in skill_text
+
+
+def test_skill_portable_driver_links_resolve_on_disk() -> None:
+    skill_text = SKILL_MARKDOWN_PATH.read_text(encoding="utf-8")
+    all_relative_links = PORTABLE_DRIVER_LINK_PATTERN.findall(skill_text)
+    assert all_relative_links, "SKILL.md must link portable-driver.md"
+    for each_relative_link in all_relative_links:
+        resolved_path = (SKILL_MARKDOWN_PATH.parent / each_relative_link).resolve()
+        assert resolved_path.is_file(), (
+            f"portable-driver link must resolve on disk: "
+            f"{each_relative_link} -> {resolved_path}"
+        )
+        assert resolved_path == PORTABLE_DRIVER_PATH.resolve()
+
+
+def test_multi_pr_documents_portable_launch_and_teardown() -> None:
+    multi_pr_text = MULTI_PR_MARKDOWN_PATH.read_text(encoding="utf-8")
+    assert PACER_PORTABLE_TOKEN in multi_pr_text
+    assert "Do **not** call `Workflow`" in multi_pr_text or (
+        "Do not call `Workflow`" in multi_pr_text
+    )
+    assert "pacer=portable" in multi_pr_text
+    assert PORTABLE_DRIVER_DOC in multi_pr_text

package/skills/copilot-finding-triage/SKILL.md

@@ -115,9 +115,21 @@ counts as approval.
 
 ### Step 2 — Hold and wait
 
-Arm `ScheduleWakeup` for a 45-minute deadline. Where `ScheduleWakeup` is absent,
-use `send_later`. The clock starts when the page reaches the user, which is the
-moment the script exits zero.
+Branch the hold on the caller's pacer (or on whether a durable wake surface is
+present when the caller has not selected a pacer):
+
+- **Native pacer** (`pacer=schedule_wakeup`, `pacer=workflow`, or
+  `ScheduleWakeup` present): arm `ScheduleWakeup` for a 45-minute deadline.
+  Where `ScheduleWakeup` is absent on that native path, use `send_later`.
+- **Portable pacer** (`pacer=portable`, or no durable wake): do not call
+  `ScheduleWakeup` or `send_later`. Hold with an in-session deadline poll, or
+  write handoff and stop, per
+  [`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md).
+  Callers may override this step after the ntfy page and apply their own
+  portable hold.
+
+The clock starts when the page reaches the user, which is the moment the script
+exits zero.
 
 - If the user answers, follow their direction.
 - If the deadline passes with no answer, run the caller's normal teardown and
@@ -141,7 +153,7 @@ its fix re-runs that same check and posts the before/after output on the thread.
       evidence note.
 - [ ] The page carries the PR name, the per-finding summary, and the review URL.
 - [ ] `scripts/notify_ntfy.py` exited zero before the 45-minute clock started.
-- [ ] The wakeup is armed for 45 minutes from a delivered page.
+- [ ] The hold is armed from a delivered page (45-minute `ScheduleWakeup` / `send_later` on native pacer; portable in-session poll or handoff on `pacer=portable`).
 - [ ] A failed page kept the gate open rather than approving the round.
 
 ## Files

package/skills/pr-converge/CLAUDE.md

@@ -18,13 +18,14 @@ Drives a draft PR to convergence by driving the internal passes to clean first
 | `pr_converge_skill_constants/` | Importable constants module shared by skill scripts |
 | `reference/` | Per-tick steps, convergence gates, fix protocol, obstacle runbooks, state schema, stop conditions, examples |
 | `scripts/` | Python helpers (bugbot check, convergence check, Copilot review fetcher, fix-reply poster, reflow tool) and their tests |
-| `workflows/` | ScheduleWakeup loop pacing specification |
+| `workflows/` | ScheduleWakeup loop pacing specification (`pacer=schedule_wakeup`) |
 
 ## Conventions
 
-- Each invocation runs one tick. The next tick is scheduled via `ScheduleWakeup` unless convergence or a stop condition has been reached.
+- Pre-flight selects a pacer via `select_converge_pacer.py`: `schedule_wakeup` or `portable`. Missing `ScheduleWakeup` selects portable — it does not abort the skill.
+- On `pacer=schedule_wakeup`, each invocation runs one tick and the next advances via `ScheduleWakeup`. On `pacer=portable`, the session runs ticks continuously (continue or in-session poll) until convergence, a stop condition, or a budget handoff.
 - Loop state persists to `$CLAUDE_JOB_DIR/pr-converge-state.json` between ticks.
-- The pre-flight gate requires `EnterWorktree` before any file read or API call, and confirms `ScheduleWakeup` is in the tool list.
+- Isolation uses `EnterWorktree` when present; otherwise the portable driver git worktree path, then `preflight_worktree.py`.
 - All findings and PR reports state verified facts only — no hedging language.
 - The GitHub MCP (`pull_request_read`, `pull_request_review_write`) is the primary path for PR inspection; `gh api` is the fallback.
 - Three step-scoped agents (`fix_executor`, `thread_sweep`, `copilot_watch`) persist across ticks via the `persistent_agents` map in loop state; each tick resumes them with `SendMessage` and spawns a fresh named agent when a stored id is dead.

package/skills/pr-converge/SKILL.md

@@ -9,10 +9,13 @@ description: >-
 
 # PR Converge
 
-One tick per invocation. A code-review ↔ bugteam ↔ Bugbot ↔ Copilot loop on
-a draft PR: the internal code-review and bugteam passes drive the code to clean
-first, then Cursor Bugbot and Copilot run as terminal confirmation gates, until
-all are clean on the same `HEAD` and mergeable.
+A code-review ↔ bugteam ↔ Bugbot ↔ Copilot loop on a draft PR: the internal
+code-review and bugteam passes drive the code to clean first, then Cursor
+Bugbot and Copilot run as terminal confirmation gates, until all are clean on
+the same `HEAD` and mergeable. On `pacer=schedule_wakeup`, one tick runs per
+invocation and the next tick is scheduled. On `pacer=portable`, ticks run
+continuously in-session (see
+[`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md)).
 
 ## Transport check (before any GitHub step)
 
@@ -24,20 +27,50 @@ skill through its substitution matrix.
 
 ## Pre-flight
 
-Pause and physically scan the tool list at the top of this conversation
-for the literal string `ScheduleWakeup`. If you see it, proceed. If the
-string is absent after scanning, report `pr-converge requires
-ScheduleWakeup; aborting` and stop.
+### Task list (step 1)
 
-Call `EnterWorktree` with no arguments before any API call, file read, or
-edit. Agent-view sessions start in the shared checkout; Bash (`gh`, `git`)
-does not auto-isolate. Do not proceed until the working directory contains
-`.claude/worktrees/`. If `EnterWorktree` fails, report the failure and stop.
+After down/opt-out flags are known, build the work list with
+`build_converge_task_list.py` only (same script as autoconverge). Register every
+task; **final task** is always `all_runnable_reviews_clean_same_head`. Complete
+that final task only when every runnable review is CLEAN on the same HEAD.
+On `pacer=portable`, `open-run` returns the same list.
 
-`EnterWorktree` isolates the session repo. When the PR lives in a different
-repo, Step 1.5 routes the working directory into a **PR worktree** of that
-repo on its head branch (routine, never a pause). See
-[`reference/per-tick.md` § Step 1.5](reference/per-tick.md).
+### Pacer selection
+
+Scan the tool list for `ScheduleWakeup`. Record whether it is present, then
+select the pacer:
+
+```
+python "$HOME/.claude/skills/_shared/pr-loop/scripts/select_converge_pacer.py" \
+  --skill pr-converge \
+  --has-workflow <0|1> \
+  --has-schedule-wakeup <0|1>
+```
+
+- `pacer=schedule_wakeup` — native tick pacing via `ScheduleWakeup` (see
+  [`workflows/schedule-wakeup-loop.md`](workflows/schedule-wakeup-loop.md)).
+- `pacer=portable` — continuous in-session driver on
+  [`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md).
+  **Do not abort** because `ScheduleWakeup` is missing.
+
+### Worktree isolation
+
+When the tool list includes `EnterWorktree`, call it with no arguments before
+any API call, file read, or edit. Agent-view sessions start in the shared
+checkout; Bash (`gh`, `git`) does not auto-isolate. Do not proceed until the
+working directory contains `.claude/worktrees/`. If `EnterWorktree` fails,
+report the failure and stop.
+
+When `EnterWorktree` is absent, isolate with git worktree machinery per
+[`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md)
+§ Isolation and worktree, then run strict
+`preflight_worktree.py` for the PR's owner/repo. Fail closed only when the
+checkout is not the PR's repo on the PR head ref.
+
+`EnterWorktree` (or the portable worktree path) isolates the session repo.
+When the PR lives in a different repo, Step 1.5 routes the working directory
+into a **PR worktree** of that repo on its head branch (routine, never a
+pause). See [`reference/per-tick.md` § Step 1.5](reference/per-tick.md).
 
 ## Resume from a prior run
 
@@ -71,10 +104,16 @@ auto-fix; code-concern verify then confirmed / refuted / inconclusive).
 - Self-healing and **confirmed** findings join the fix tick on `current_head`;
   after push, reset clean-at SHAs, set `phase = CODE_REVIEW`, return to Step 5.
 - **Refuted** findings resolve clean on the thread; no phase change.
-- One or more **inconclusive** findings: do not mark ready. Run the triage
-  skill's user gate (ntfy + 45-minute hold across ticks; persist the deadline so
-  each tick reads it on entry). Act on the user's direction inside the window;
-  on timeout, teardown and report the findings un-reviewed.
+- One or more **inconclusive** findings: do not mark ready. Page via the
+  triage skill's ntfy step, then hold by pacer:
+  - **`pacer=schedule_wakeup`** — triage user gate (`ScheduleWakeup` /
+    `send_later` 45-minute hold across ticks; persist the deadline so each tick
+    reads it on entry).
+  - **`pacer=portable`** — in-session deadline poll or handoff per
+    [`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md);
+    never `ScheduleWakeup` or `send_later`.
+  Act on the user's direction inside the window; on timeout, teardown and report
+  the findings un-reviewed.
 - Enter `COPILOT_WAIT` only from gate (d) after requesting a Copilot review
   (Step 7 → 7a). Stay on `COPILOT_WAIT` until a review surfaces at
   `current_head`, `copilot_wait_count >= 3` hard-blocks, or `copilot_down`
@@ -106,11 +145,13 @@ softened.
 
 Single-PR mode persists loop state to `$CLAUDE_JOB_DIR/pr-converge-state.json`.
 On tick entry, read this file if it exists to restore phase, tick_count, and
-clean-at SHAs. On tick exit, write updated state before calling ScheduleWakeup
-so the next tick resumes with accurate state.
+clean-at SHAs. On tick exit, write updated state before the next pacer step
+(`ScheduleWakeup` when `pacer=schedule_wakeup`; continuous continue or
+in-session poll when `pacer=portable`) so the next tick resumes with accurate
+state.
 
-After the state write and before ScheduleWakeup, write the durable handoff so a
-fresh session in a new job can resume this run:
+After the state write and before the next pacer step, write the durable handoff
+so a fresh session in a new job can resume this run:
 
 ```
 python "$HOME/.claude/skills/_shared/pr-loop/scripts/write_handoff.py" \
@@ -171,8 +212,12 @@ grows to 5 or more items, suggest spinning up a subagent to investigate, fix,
 post a fresh PR in a fresh branch based on origin main to the user.
 
 - **`ScheduleWakeup` not in subagent tool registries** — background
-  `general-purpose` tick cannot schedule re-entry; only parent session
-  with `ScheduleWakeup` in registry can call it.
+  `general-purpose` tick cannot schedule re-entry; only the parent session
+  with `ScheduleWakeup` (or the portable continuous driver on the parent)
+  may pace the next tick.
+- **Portable host has no durable wake outside the session** — when
+  `pacer=portable`, budget and context bound how many ticks complete; write
+  handoff at a tick boundary and resume with `/pr-converge <PR URL>`.
 - **`state.json` without §Concurrency lock loses merges** when teammates
   finish in same wall-clock window.
 - **`tick_count` must not double-increment** — conversation state line
@@ -219,22 +264,168 @@ post a fresh PR in a fresh branch based on origin main to the user.
 
 ## Progress checklist
 
-Run the eleven-step per-tick sequence in
-[`reference/progress-checklist.md`](reference/progress-checklist.md): Step 0
-(open the run) through Step 11 (final report), each step pointing to its spoke
-file for MCP calls, script invocations, and decision criteria. State variables
-live in [`reference/state-schema.md`](reference/state-schema.md); ground rules in
-[`reference/ground-rules.md`](reference/ground-rules.md).
-
-Two hard gates bind every step:
-
-- **No unresolved threads.** Do not advance from any step while any unresolved
-  review thread exists on the PR (sweep semantics in the shared fix protocol,
-  [`../../_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md)
-  step 12).
-- **Full-PR-diff.** Every CODE-REVIEW (Step 5) and BUGTEAM (Step 6) round covers
-  the full `origin/main...HEAD` diff — a "clean" verdict against a partial diff
-  is not a valid clean.
+State variables (`phase`, `bugbot_clean_at`, `code_review_clean_at`,
+`bugteam_clean_at`, `copilot_clean_at`, `merge_state_status`, counters) are
+defined in [`reference/state-schema.md`](reference/state-schema.md). Ground rules
+in [`reference/ground-rules.md`](reference/ground-rules.md).
+
+Each step references its spoke file for full procedural detail — MCP calls,
+script invocations, decision criteria. Every "return to Step N" means the next
+tick starts fresh from that step.
+
+**Hard gate: do not advance from any step while ANY unresolved review
+thread exists on the PR.** Sweep semantics and per-thread handling live in
+the shared fix protocol
+([`../../_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md)
+step 12; skill deltas in [`reference/fix-protocol.md`](reference/fix-protocol.md)).
+
+**Full-PR-diff rule: every CODE-REVIEW round (Step 5) and every BUGTEAM
+round (Step 6) covers the FULL `origin/main...HEAD` diff — every file
+the PR touches.** A round that scopes to a subset — only the last commit,
+only files touched since the prior clean SHA, only bugbot-flagged paths,
+or any other delta cut — does not satisfy the gate, and a "clean" verdict
+against a partial diff is not a valid clean. Re-run the round against the
+full diff before recording `code_review_clean_at` or treating the bugteam
+round as converged. This rule holds every tick, every loop, every PR.
+
+- [ ] **Step 0: Open the run**
+      Apply the `pr-loop-lifecycle` skill's Open section
+      (`../pr-loop-lifecycle/SKILL.md`): permission grant + worktree preflight.
+
+- [ ] **Step 1: Resolve PR scope + PR worktree**
+      Apply Step 1.5 scope resolution in
+      [`reference/per-tick.md`](reference/per-tick.md). Resolve the **PR
+      worktree** — the local checkout every local step this tick targets:
+      the `EnterWorktree` checkout when the PR shares the session's repo,
+      else a checkout of the PR's repo that the working directory routes
+      into via `cd`. Cross-repo routing is automatic, not a fork.
+      See: [`reference/per-tick.md` § Step 1](reference/per-tick.md)
+      and [§ Step 1.5](reference/per-tick.md)
+
+- [ ] **Step 2: Initialize loop state**
+      `phase = CODE_REVIEW`; all counters at zero; `run_name` resolved.
+
+- [ ] **Step 3: Mergeability check**
+      See: [`reference/convergence-gates.md` § (c)](reference/convergence-gates.md)
+
+      ```
+      pull_request_read(method="get") → .mergeable_state, .mergeable
+      ```
+
+      - [ ] mergeable → advance to Step 4
+      - [ ] not mergeable → rebase → force-push → return to Step 1
+
+- [ ] **Step 4: BUGBOT — terminal Bugbot confirmation gate**
+      Step 6 routes here after BUGTEAM converges. Bugbot confirms code the
+      internal passes already drove to clean.
+      See: [`reference/per-tick.md` § BUGBOT terminal gate + Step 3](reference/per-tick.md);
+      availability and trigger via `reviewer-gates`
+      (`../reviewer-gates/SKILL.md` § Gate 1 / Gate 3).
+
+      - [ ] **disabled / down** → `bugbot_down = true` → Step 7
+      - [ ] **dirty on `current_head`** → apply shared fix protocol
+            ([`../../_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md);
+            skill deltas in [`reference/fix-protocol.md`](reference/fix-protocol.md))
+            → push → reset push-invalidated markers → `phase = CODE_REVIEW` → Step 5
+      - [ ] **clean on `current_head`** → zero unresolved threads (else fix + resolve first)
+            → `bugbot_clean_at = current_head` → Step 7
+      - [ ] **no review / commit_id mismatch** → `reviewer-gates` Bugbot flow (Gate 3):
+            silent pass → stamp + Step 7; queued/triggered → ScheduleWakeup 360s or portable in-session poll → Step 4;
+            down → `bugbot_down = true` → Step 7
+
+- [ ] **Step 5: CODE-REVIEW — static sweep, review, fix, advance**
+      Entry phase every tick; re-entered after any fix push.
+      See: [`reference/per-tick.md` § CODE_REVIEW entry](reference/per-tick.md).
+      Pre-condition: cwd is the Step 1.5 PR worktree on `current_head`.
+      Scope: FULL `origin/main...HEAD` diff every tick (no path args, no delta cut).
+      Review always runs at effort high on model opus through
+      `invoke_code_review.py`. Mode decision inputs: host profile + session
+      model. Call:
+      `python "$HOME/.claude/scripts/invoke_code_review.py" --cwd <PR-worktree>
+      --session-model <alias>`. Chain mode uses that cwd and empty stdin; the
+      chain process never commits and never pushes. JSON stdout carries
+      `mode` (`in_session` | `chain`), `served_command`, `returncode`, and
+      `dirty_tree`. Config/host errors still emit that JSON with non-zero
+      `returncode` (no traceback-only failure).
+
+      - [ ] **Static sweep fails** → apply shared fix protocol → push → reset markers
+            → stay CODE_REVIEW → Step 5
+      - [ ] **`mode == in_session`** (Claude host, session model opus) → run
+            `/code-review high --fix` in-session (no path args)
+      - [ ] **`mode == chain`** (any other host or non-opus session) → helper
+            already ran the headless review; read `returncode`,
+            `served_command`, and `dirty_tree` from JSON
+      - [ ] **failed review** (`returncode != 0`, or chain with null
+            `served_command`) → do not set `code_review_clean_at` → stay
+            CODE_REVIEW → Step 5
+      - [ ] **fixes applied** (`dirty_tree` true / working tree dirty) →
+            commit + push via shared fix protocol → reset markers → stay
+            CODE_REVIEW → Step 5
+      - [ ] **clean** (successful serve: `returncode == 0`, chain
+            `served_command` non-null when chain, and `dirty_tree` false) →
+            zero unresolved threads (else fix + resolve) →
+            `code_review_clean_at = current_head` → `phase = BUGTEAM` → Step 6
+
+- [ ] **Step 6: BUGTEAM — run, decide, fix, reply, resolve**
+      See: [`reference/per-tick.md` § Step 2 BUGTEAM](reference/per-tick.md);
+      [`../bugteam/SKILL.md`](../bugteam/SKILL.md).
+      Pre-condition: `code_review_clean_at == current_head`.
+      Mandatory: `Skill({skill: "bugteam", args: "<PR URL>"})` this tick
+      (enforcer-blocked otherwise; `qbug` is not a substitute). Scope: FULL
+      `origin/main...HEAD` diff. Re-resolve HEAD after bugteam.
+
+      - [ ] **bugteam pushed** → verify threads replied + resolved → reset markers
+            → `phase = CODE_REVIEW` → ScheduleWakeup 360s or portable in-session poll → Step 5
+      - [ ] **converged, no push** → zero unresolved threads →
+            `bugteam_clean_at = current_head` → `phase = BUGBOT` → Step 4
+      - [ ] **findings without committed fixes** → apply shared fix protocol → push →
+            reset markers → `phase = CODE_REVIEW` → Step 5
+
+- [ ] **Step 7: Convergence gates**
+      Full procedure: [`reference/convergence-gates.md`](reference/convergence-gates.md).
+
+      Pre-condition: Step 6 converged AND (`bugbot_clean_at == current_head` OR
+      `bugbot_down`). The terminal Bugbot gate (Step 4) sets that state just
+      before these gates run. Count unresolved threads before each gate.
+      Every gate records evidence; gate (f) cites evidence from (a)–(e).
+
+      - [ ] **(a) Copilot findings** — fetch Copilot on `current_head`; dirty → fix + return to Step 5; clean → stamp `copilot_clean_at`; absent → continue; when `copilot_down`, skip
+      - [ ] **(b) Claude reviewer** — fetch Claude on `current_head`; dirty → fix + return to Step 5; clean or absent → continue
+      - [ ] **(c) Mergeability** — `mergeable_state == "clean"` and `mergeable == true`; dirty → rebase + return to Step 1; blocked/behind/unknown/unstable → hard blocker
+      - [ ] **(d) Post-convergence Copilot request** — request Copilot when not pending and not `copilot_down`; enter `COPILOT_WAIT` (Step 7a); when `copilot_down`, skip to (e)
+      - [ ] **(e) Thread-resolution** — zero unresolved threads across the PR; else sweep + fix/resolve
+      - [ ] **(f) Mark ready** — run `check_convergence.py`; exit 0 → `update_pull_request(draft=false)` → Step 8; exit 1 → fix path; exit 2 → retry/stop
+
+- [ ] **Step 7a: COPILOT_WAIT — fetch Copilot, decide**
+      See: [`reference/per-tick.md` § Step 2 COPILOT_WAIT](reference/per-tick.md).
+      Skipped entirely when `copilot_down` (gate (d) never enters this phase).
+
+      - [ ] **clean** → `copilot_clean_at = current_head` → Step 7 (re-validate (b), (c), (e), (f))
+      - [ ] **dirty** → apply shared fix protocol
+            ([`../../_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md);
+            skill deltas in [`reference/fix-protocol.md`](reference/fix-protocol.md))
+            → push → reset markers → `phase = CODE_REVIEW` → Step 5
+      - [ ] **no review yet** → increment `copilot_wait_count` → ≥ 3 hard-blocks;
+            else ScheduleWakeup 360s or portable in-session poll → Step 7a next tick
+
+- [ ] **Step 8: Clean working tree**
+      `pr-loop-lifecycle` Close (`../pr-loop-lifecycle/SKILL.md`).
+      See: [`pr-loop-lifecycle/reference/teardown-publish-permissions.md` § Clean working tree](../pr-loop-lifecycle/reference/teardown-publish-permissions.md)
+
+- [ ] **Step 9: Rewrite PR description**
+      `pr-loop-lifecycle` Close.
+      See: [`pr-loop-lifecycle/reference/teardown-publish-permissions.md` § Publish the final PR description](../pr-loop-lifecycle/reference/teardown-publish-permissions.md)
+
+- [ ] **Step 10: Revoke project permissions (always)**
+      `pr-loop-lifecycle` Close (`../pr-loop-lifecycle/SKILL.md` § Close).
+
+- [ ] **Step 11: Print final report**
+      Print this block verbatim — no paraphrase, no extra commentary:
+      ```
+      /pr-converge exit: converged
+      Loops: <N>
+      Final commit: <SHA>
+      ```
 
 ## Edge cases
 
@@ -253,6 +444,7 @@ Two hard gates bind every step:
 | `copilot-finding-triage` | Tier, verify, and route each Copilot finding |
 | `bugteam` | Full-diff bug audit in Step 6 (Skill invocation mandatory) |
 | `pr-loop-cloud-transport` | When `gh` is unavailable or unauthenticated |
+| [`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md) | Continuous in-session pacer when `ScheduleWakeup` is absent |
 | [`../../_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md) | Shared 13-step fix sequence (TDD, commit, push, reply, resolve) |
 | [`reference/fix-protocol.md`](reference/fix-protocol.md) | pr-converge deltas on the shared fix protocol |
 
@@ -263,7 +455,6 @@ Two hard gates bind every step:
 | `SKILL.md` | Hub: pre-flight, state, progress checklist, gotchas |
 | `CLAUDE.md` | Package map for agents working in this skill |
 | `pr_converge_skill_constants/` | Importable constants for skill scripts |
-| `reference/progress-checklist.md` | Per-tick eleven-step checklist (Step 0 open → Step 11 report) |
 | `reference/per-tick.md` | Full per-tick procedure (phases, cwd routing, pacing) |
 | `reference/convergence-gates.md` | Six gates before mark-ready |
 | `reference/fix-protocol.md` | pr-converge fix-protocol deltas |
@@ -274,4 +465,5 @@ Two hard gates bind every step:
 | `reference/examples.md` | Worked tick sequences |
 | `reference/obstacles/` | Per-obstacle fix runbooks |
 | `scripts/` | Convergence helpers, Copilot fetch, fix-reply poster, tests |
-| `workflows/schedule-wakeup-loop.md` | ScheduleWakeup pacing |
+| `workflows/schedule-wakeup-loop.md` | ScheduleWakeup pacing (`pacer=schedule_wakeup`) |
+| [`../_shared/pr-loop/portable-driver.md`](../_shared/pr-loop/portable-driver.md) | Portable continuous pacer (`pacer=portable`) |

package/skills/pr-converge/reference/multi-pr-orchestration.md

@@ -210,7 +210,11 @@ When bugfix (clean-coder) subagent completes after push:
 3. Each PR with new subagent results → spawn next agent per rules, all
    in one parallel message.
 4. Re-read `state.json` if needed for scheduling.
-5. Call `ScheduleWakeup` with appropriate delay.
+5. Advance the pacer: on `pacer=schedule_wakeup`, call `ScheduleWakeup`
+   with the appropriate delay; on `pacer=portable`, continue or poll
+   in-session per
+   [`../../_shared/pr-loop/portable-driver.md`](../../_shared/pr-loop/portable-driver.md)
+   (no `ScheduleWakeup`).
 6. Nothing else.
 
 ## Memory