审查机点了 Request changes，开这个 PR 的代理会话已经关了：谁来改下一刀？（中英切换）

At 09:12, machine 4 clicks Request changes. Three threads are concrete: integer cents, reject unknown tier, add odd-cent tests. The PR is the one an agent opened last night on machine 2 — agent/billing-discount, session id still in the commit message: sess-m2-8841.

The problem: sess-m2-8841 died at 02:00 when the machine rebooted. Machine 2 is now on a new session for another ticket. Machine 1 is free. Machine 3 is loaded. Nobody is staring at the GitHub notification panel. The review lives in threads. Who pushes the next edit?

Three people, seven machines: 1–3 develop (agents open PRs fast), 4–5 review, 6 Windows validation, 7 merge/ops. This post is not about verifying that fixes landed, and not about mid-task WIP handoff between live sessions. It asks one question: when CHANGES_REQUESTED hits a dead authoring session, how do you bind a live PR to a still-awake dev machine without dropping the review thread?

I built a toy repo on this machine: real git branch and fix commit; review state, labels, and leases in JSON — not the live GitHub API; the Actions YAML is copy-paste illustrative and was not fired at a live repo; nothing ran on Windows. Every number below is from this run.

Setup: review present, author session gone

The threads are locatable, not vibes:

1. float truncation in discount.py → price * (100-pct) // 100
2. table[tier] KeyError → explicit ValueError
3. missing tests for 999@15% and unknown tier

That text lives only in GitHub threads. The dead session transcript does not contain it — review had not happened when the agent filed the PR.

Four wake strategies, one gap

Same PR, four strategies, five synthetic mornings each. Metrics: did a machine actually start (wake), minutes to first fix-oriented push, missed threads, double-claim, wrong-machine wake.

*C's 26.7% is entirely machine-2 (dead author machine) winning the lease and continuing from memory without ack — the gate drops it to 0% for ~3 extra minutes of TTF.

A: human inbox — misses by default

Reviewer or lead relies on mail/app notifications. Agent-era density makes muting rational. In the sim, 2 of 5 days nobody notices CHANGES_REQUESTED; when noticed, ~90 minutes to a free machine, and about half of those mornings drop at least one thread in the oral handoff. Wrong-machine 20%: habit-pinging busy machine 3.

This is not laziness. The channel and the duty are misaligned: review state is on GitHub; wake depends on a fatiguing human surface.

B: why @mention is 0%

The intuition: Actions or reviewer @coderobot and it continues. In the lab, wake = 0 for all five days.

The reason is mechanical:

• A GitHub @mention updates a bot account notification inbox.
• Local Claude Code / Codex is an interactive PTY session, not a notification webhook listener.
• Closed session = no process listening. Without a separate always-on daemon polling mentions or pull_request_review, @ cannot resume "the local agent that opened this PR".

Putting B in the runbook installs a doorbell that never rings.

C: label state machine + lease

Rules:

1. On CHANGES_REQUESTED → label state:changes-requested (filterable, not a Slack "we'll get it").
2. Free dev runs pickup.py claim --machine machine-N: writes a lease file (holder + expiry, force-with-lease style) and projects a single pickup:machine-N.
3. Second claim → exit 2 lease_held. On this box: naive dual pickup:* labels dual-write; with lease, double-claim rate 0.
4. Before editing: ack-threads must cover every unresolved thread id.
5. After push → release → state:awaiting-review.

Without ack, C still wakes 100% but machine-2 "continues" miss threads. Lease solves exclusion, not fresh context. Two doors.

D: Actions on pull_request_review

Illustrative workflow (not fired at live GitHub in this lab): on changes_requested, set labels, clear stale pickup:*, leave a structured handoff comment (head SHA, author session likely dead, claim command, ack requirement). A free-machine cron (or a human reading the comment) then claims. Avg TTF ~29 minutes including poll interval; missed threads 0; double-claim 0.

D does not replace C: Actions broadcasts the gap; the lease serializes the claim. A comment alone still allows two machines to start.

Failure modes actually hit here

Not hypothetical:

1. Double claim (no lease): two machines both apply pickup:machine-*. Labels are not locks; both agents push.
2. Double claim (with lease): first ok, second exit 2 lease_held.
3. Dead session continue: machine-2 worktree still on yesterday's branch; agent "remembers" intent; three new threads absent from transcript; without ack, miss 2/3.
4. Fix without reading threads: treat review as ambience; gate is ack-threads covering all unresolved ids or refuse commit.
5. --steal before TTL: holder still writing → dual-write window. Policy: only after expiry, or after machine 4/5 applies pickup:abandoned.
6. Expire then reclaim: expired lease auto-clears; next claim succeeds — the good path.

Mechanism: three lifetimes do not line up

• PR / review threads: days. CHANGES_REQUESTED stays.
• Dev machines: shifts. Whoever is free can fix; the author machine may already be on another ticket.
• Agent session: hours. Reboot, next ticket, context full — process gone. A transcript is not a ticket.

The gap is dead session × live PR × no babysitter. You do not need the dead session resurrected. You need the live PR bound to a live machine, with review threads as hard input before work starts.

The session that opened the PR should never be the default sole fixer. In the agent era opening is cheap, sessions are shorter, review is more async.

Steelman: is this just another ticket system?

Fair objection: you already have assignee, Projects, Slack. Are pickup:* and a lease file ceremony? Three people — just shout?

The objection holds when:

• CHANGES_REQUESTED is <1/day and reviewer + next dev share timezone and chat — A's miss rate is tolerable.
• You have a real always-on worker listening to webhooks (not a local IDE session) — then B can be non-zero. Most "@ the bot" setups are not that architecture.
• Solo repo, same human session always opens and fixes — no seven machines, no shift change.

Once the rhythm is "open overnight, review morning, author session dead by noon", assignee does not give exclusion: two people can both pretend. A Slack ping carries no thread checklist; misses become another CHANGES_REQUESTED round. The lease is cheap: one JSON file + one exit code against dual pushes and dropped threads.

Another steelman: "the author machine must finish." Sounds like ownership; in practice it stalls the queue — machine 2 may be in a long job, or the human away. Ownership should sit on the lease holder, not the historical author. Author metadata stays on commits/PR for context questions; fix rights must transfer.

When this is not worth it

• No agents; humans open and fix; reviewer can shout at the author in the moment — skip leases.
• Repair bot is a cluster worker with real webhooks — invest in a queue service, not IDE-session claiming.
• Reviews are LGTM without threads — fix review quality first; leases cannot save empty comments.
• Replacing ack with a model "summary of comments" — summaries still drop hard constraints; the gate wants thread ids, not another paragraph.

What the lease file owns vs what labels own

A common mix-up: applying pickup:machine-1 is treated as exclusion. The lab contrast is sharp — on the naive path both machines can successfully add pickup:… labels (in simulation: append twice to the JSON label list). Two pickup:* labels coexist. Labels are a visible projection, not compare-and-swap.

Exclusion happens in the claim script's lease read: non-expired holder different from me → exit 2. Label updates are a side effect after a successful claim so machines 4/5/7 can filter "nobody holds this yet." Labels without a lease (or equivalent coordinator) can tell you someone appears to hold it; they cannot stop a second someone from also appearing to hold it.

Where to store the lease is a trade-off: in-repo .pickup/ is noisy; this lab keeps leases/ outside the toy git root. In production, keep labels on GitHub and the lease in a tiny coordinator, a machine-readable comment block, or an external store with If-Match. The invariant is one sentence — at most one non-expired holder at a time.

What a handoff comment must contain

Strategy D's Actions comment is not "please take a look." The generated handoff always includes:

• author machine + session id marked dead with close reason;
• head ref + SHA (so checkout cannot silently drift from the reviewed tip);
• unresolved thread id / path / line / body checklist;
• four hard rules: fetch+checkout, do not reuse dead transcript, ack before push, relabel after push.

A handoff without a checklist collapses to A: human short-term memory. A checklist without a claim still allows two free machines to edit in parallel. Checklist answers what; lease answers who.

Why machine-2 "continue" is specially dangerous

Intuition says the author machine knows the context best. In trials where machine-2 raced for the lease, it often pushed faster (7–14 minutes TTF) and missed threads. Fast because the worktree is warm; blind because review landed after session death — the transcript has none of the three threads, so the model "polishes the discount feature" again. Float math might get lucky; unknown-tier and tests do not.

Auto-routing to the author therefore systematically picks the stalest context. Safer default: any free dev may claim; if the author machine claims, it still faces the ack gate — no exemption. Ownership is the lease holder, not git author.

Re-review filters without chat archaeology

• state:changes-requested with no pickup:* → gap; wake a free dev or mark pickup:abandoned then steal.
• pickup:machine-N unexpired → wait, or check whether ack appeared in the handoff thread.
• state:awaiting-review → re-review queue; confirm resolves.

Machine 7 can soft-block merges while state:changes-requested remains. This lab did not change a live merge gate.

Boundaries with sibling posts

• Verifying comments were actually fixed: post-fix audit. This post is earlier: nobody has claimed the next edit yet.
• Mid-task WIP handoff between machines: live session migration. This is pickup after death; input is review threads, not an unfinished agent plan.
• Morning overnight PR triage: deciding what to kill first. This assumes the PR already entered review and received CHANGES_REQUESTED.

Copy-tomorrow minimum

1. Labels: state:changes-requested, state:awaiting-review, pickup:machine-1|2|3, pickup:abandoned (label_commands.sh in the kit).
2. AGENTS.md: hard rule — after CHANGES_REQUESTED the original session is not automatically responsible; claim first; ack-threads first; no memory-continue.
3. Ship pickup.py: claim / release / status / ack-threads; --live prints gh commands for a real repo.
4. Optional Actions: pull_request_review + changes_requested → labels + structured handoff (YAML in kit).
5. Re-review filter on 4/5: label:state:awaiting-review; still state:changes-requested with no pickup:* is an unclaimed gap.

Rollout: labels + manual claim for two days, then Actions. If you cannot get a unique pickup: within an hour of CHANGES_REQUESTED, automation only broadcasts the vacancy louder.

What actually ran

Real: toy git branch agent/billing-discount; three simulated review threads; pickup.py lease exclusion and expiry; strategies A/B/C/D × 5 mornings; failure-mode scripts; after claim+ack, machine-1 truly committed the integer-cents + unknown-tier fix; tests tests_ok; SHA f307e0f1.

Not run: live GitHub/Actions; labels not applied remotely; no Windows; no seven-machine integration; no always-on webhook daemon.

Kit: changes-requested-pickup-kit.tar.gz — pickup.py, simulate_strategies.py, changes-requested-handoff.yml, AGENTS.md.snippet, label_commands.sh, results.json.

Smallest step today: next time machine 4 hits Request changes, do not ask "is the original agent still up?" Ask "which free dev holds the pickup: lease, and are thread ids all acked?" If you catch yourself Slack-pinging machine 2 while its session is already dead — you are paying the session/PR boundary tax again.