prm: don't attempt remote branch deletion where the proxy blocks it

Close-out step 5 assumed every environment could delete a remote ref, so a
proxied web session (Claude Code on the web) burned turns on pushes that can
never land: the egress proxy returns HTTP 403 on the git-receive-pack POST
carrying a ref deletion, and the GitHub MCP surface exposes no delete verb.

Add a one-shot environment probe before the close-out, skip the remote half of
step 5 outright when it answers, and defer those branches to /repo_cleanup
(its Bucket B enumerates origin branches, so a local sweep picks them up).
Also correct the remote-environment note, which claimed step 5 ran "as usual"
over gh, and record deferred branches in the ledger alongside deleted ones.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DHmxnBNwDGedeUoRJk9iFz

Author: claude

skills/prm/prm.md

@@ -37,6 +37,16 @@ checkout required. Detect which you are in:
 - **Remote (mobile/codex)** — no multi-repo checkout. Resolve the PR from the
   argument or by listing candidates (below), and **skip the local-only cleanup**
   with a one-line note. Never `cd` into a repo that isn't there.
+- **Proxied web session (Claude Code on the web)** — remote as above, **plus it
+  cannot delete remote branches at all**: the egress proxy refuses ref deletions.
+  Probe once, before the close-out, and remember the answer for the whole run:
+
+  ```bash
+  curl -sf "$HTTPS_PROXY/__agentproxy/status" >/dev/null && echo "ref deletes blocked"
+  ```
+
+  An answer means every `git push origin --delete` in this run will fail. Do not
+  attempt one — see step 5.
 
 ## The routine
 
@@ -119,14 +129,19 @@ step 6. Order is forced by the tooling, so do not reorder:
    registered in `active.md` — which is exactly why step 3 comes first.
 5. **Branches** — delete the remote `feature/<task>` per proven-merged repo, plus
    any local branch left in the canonical checkout. Never delete a branch whose
-   merge you did not prove in sub-step 1.
+   merge you did not prove in sub-step 1. **If the environment cannot delete
+   remote refs** (proxied web session, above), skip the remote half outright and
+   list those branches in the ledger as deferred to `/repo_cleanup` — never spend
+   turns on a push the proxy has already refused.
 6. **Report the ledger** — PRs merged, issue closed, record path, `active.md`
-   released, worktree removed, branches deleted, and anything skipped.
+   released, worktree removed, branches deleted **or deferred**, and anything
+   skipped.
 
-**Remote (mobile/codex):** sub-steps 1, 2 and 5 run over `gh`/`git ls-remote` as
+**Remote (mobile/codex):** sub-steps 1 and 2 run over `gh`/`git ls-remote` as
 usual. Mind (3) works if PyAutoMind is checked out; otherwise say the record is
 pending. The worktree (4) is local-only — name it as outstanding rather than
-implying it ran.
+implying it ran. Branches (5) delete normally from mobile and Codex, but **not**
+from a proxied web session — there they are deferred, not attempted.
 
 ### 6. The only guards that stop you
 

skills/prm/reference.md

@@ -189,7 +189,40 @@ directory listing is the only way to find it.
 
 ### 5. Branches
 
-Local branches go with the worktree; the remote ones do not:
+Local branches go with the worktree; the remote ones do not. **First establish
+whether this environment may delete remote refs at all** — one probe, once per
+run, before any repo:
+
+```bash
+curl -sf "$HTTPS_PROXY/__agentproxy/status" >/dev/null && echo "ref deletes blocked"
+```
+
+An answer means a proxied web session (Claude Code on the web). There, a ref
+deletion dies on the `git-receive-pack` POST:
+
+```
+error: RPC failed; HTTP 403 curl 22 The requested URL returned error: 403
+send-pack: unexpected disconnect while reading sideband packet
+```
+
+That 403 is generated in front of GitHub — the ref advertisement to the same host
+seconds earlier returns 200 with an `X-Github-Request-Id`, the 403 carries none —
+so credentials, `gh` scopes and branch protection are **not** the cause, and no
+retry, repo, or token changes it. The GitHub MCP surface has no delete verb
+either (`create_branch` exists; nothing deletes a ref). So in that environment:
+delete the local branches if a checkout exists, **skip the remote half entirely**,
+and put one line per branch in the ledger:
+
+```
+branches: deferred — PyAutoMind claude/<task> (merged, proxy blocks remote delete) → /repo_cleanup
+```
+
+`/repo_cleanup` is the destination: its Bucket B enumerates origin branches
+directly, so a deferred branch is picked up by the next local sweep. Repo-side,
+"Automatically delete head branches" (Settings → General → Pull Requests) removes
+the need for the step at all.
+
+Otherwise — local CLI, mobile, Codex — delete as usual:
 
 ```bash
 git -C <repo> push origin --delete feature/<task>
@@ -198,11 +231,14 @@ git -C <repo> fetch --prune
 ```
 
 Only branches proven merged in step 1. `git ls-remote --heads origin feature/<task>`
-is the ground truth that the delete landed.
+is the ground truth that the delete landed. If a delete 403s where you expected it
+to work, treat it as the proxied case from that point on: **stop after the first
+refusal**, do not repeat it per repo, and defer the rest.
 
 ### 6. The ledger
 
 Report, per line: PR(s) merged (URL + `MERGED`), issue closed (number + state),
 record path under `complete/<YYYY>/<MM>/`, `active.md` claim released, worktree
-removed, branches deleted, and **anything skipped** with the reason. A close-out
-that quietly skipped a step reads exactly like one that finished.
+removed, branches deleted **or deferred** (with the destination), and **anything
+skipped** with the reason. A close-out that quietly skipped a step reads exactly
+like one that finished.