隔夜代理留了 7 个 PR，4 号机只有 90 分钟：先杀哪几个？（中英切换）

At 08:50, machine 4 opens GitHub sorted by created. On top: a "rename legacy helpers" cleanup — 45 files, +3510/−6. Below that: a lockfile bump, a feature, a drive-by dark-mode-plus-logging rewrite, a red CI inventory PR. At the bottom: a SameSite fix in auth/session.py, about a dozen lines, for users dropped after login redirect.

Standup is 09:30. Ninety minutes. The habit of reading from the top sinks the reviewer into the cleanup. The auth fix stays at the bottom. By standup two "harmless" PRs are rubber-stamped and the rest are later — and later becomes a wall.

Three people, seven machines: 1–3 develop (agents open PRs at high frequency), 4–5 review, 6 Windows validation, 7 merge/ops. This post is not about how to read a diff, and not about which SHA an Approve binds to. It asks an earlier question: is the overnight pile a merge queue, or a triage queue?

I built a toy repo on this machine: seven agent branches, a triage.py, a 90-minute budget simulation, an overnight throttle counter. Commits are real; CI status and labels live in JSON — not the live GitHub API; nothing was executed on Windows. Every number below is from this run.

Setup: seven overnight PRs, one wrong default sort

By created, auth is last. Cleanup is third — early enough to eat the morning.

FIFO: deep-read from the top, die on the cleanup

The simulated reviewer does the common thing: open the list, deep-read from the top, cost by size band (tiny 8 / small 15 / medium 25 / large 55 / huge 90 minutes), budget 90.

The ledger:

• docs-typo 8 → 82 left
• lockfile 25 → 57 left
• big-cleanup needs 90, only 57 left → stuck partial deep-read, budget zero
• feature, drive-by, failing-ci, auth-session-fix all deferred

merge_ready holds only docs and lockfile. The login-breaking fix never gets touched before standup. The drive-by is not killed — merely unread. The red CI PR still occupies attention.

This is not a reviewer-skill failure. The queue semantics are wrong: overnight output is treated as time-ordered merge candidates, so the largest early cleanup wins the pre-standup attention by construction.

Risk-first: disposition, then deep-read

Same PRs, new rule. Pass 1: ≤1 minute each — receipt, paths, size, CI, scope creep — no full diff. Emit kill / fix-track / merge-track plus pr-risk:high|med|low.

triage.py ordered this run as:

1. auth-session-fix → merge-track · high (small, green, receipt, touches auth/)
2. failing-ci → kill (red CI; do not spend review minutes)
3. drive-by → kill (no receipt, multi-intent, "while I was here")
4. lockfile / docs / feature → merge-track
5. big-cleanup → fix-track (huge; defer or split — not a pre-standup deep read)

Pass 1 labels all seven with 83 minutes left. Pass 2 deep-reads only merge-track: auth, lockfile, docs, feature finish; 24 minutes remain. Cleanup stays on fix-track. Drive-by and red CI leave the "to review" set in pass one.

Versus FIFO: auth moves from "never reached" to "first deep read"; cleanup moves from "eats the morning" to "labeled defer"; list noise stops pretending it is a merge candidate.

Signals (deterministic, copyable)

No model "vibes." triage.py uses fixed signals you can edit tomorrow without changing the philosophy:

• Path risk: auth/, session, billing, .github/workflows, lockfiles raise risk
• Size band: add+del and file count → tiny…huge → estimated minutes
• CI: failure → kill (send back; do not review red)
• Receipt: ## Intent / Receipt with Issue, Scope, Risk, Tests, Out of scope
• Scope creep: no Issue, "quick wins" / "and also" / "while I was here" → kill
• Opened order: tie-break only — never the primary sort key

The auth PR at +17/−5, two files, receipt, path hit on auth/session.py → high + merge-track. Cleanup at +3510 / 45 files → huge + fix-track. Drive-by without receipt, body admitting "No issue linked" → kill. Swap path regexes for your layout; do not swap "who opened first" back in as the default.

Labels as state, not chat folklore

Pass 1 must produce filterable state, not a Slack "let's park this":

• triage:pending → triage:kill | triage:fix | triage:merge
• optional pr-risk:high|med|low

Machines 4–5 filter is:pr is:open label:triage:merge before standup, then sort by risk. Machine 7 can refuse merges while triage:pending remains. The kit prints gh pr edit templates; this run only wrote labels into pr_state.json, not a remote repo.

Without labels, disposition lives in one reviewer's working memory — handoff, leave, or one more agent push, and the queue semantics evaporate.

Overnight throttle: the upstream gate on review budget

Even a ruthless morning triage still pays Pass 1 for every overnight PR. Better: agents on machines 1–3 call a gate before gh pr create:

Config max_overnight_prs: 3 (aligned to ~90 minutes next day). throttle.py --demo: first three ALLOW, fourth and fifth REFUSE (exit 2).

Trade-off, stated plainly: throttle alone is not enough. In the demo the first three were docs, lockfile, cleanup — auth was refused. Real systems must couple the counter to "who earns an overnight slot": receipt + issue + high-risk hotfix first; drive-bys should never increment the counter. A triage:hotfix bypass can exist, but daytime queue should still be preferred so bypass does not become a new FIFO.

Put it in AGENTS.md as a hard rule: before 18:00–08:00 opens, run throttle; no Intent/Receipt → do not open; one intent per PR.

Mechanism: why FIFO got more poisonous with agents

In the human-only era, overnight PRs were few; reading top-down wasted attention on an occasional cleanup. With agents on machines 1–3 all night, size skew appears: many docs/small fixes, and at least one industrious "code health" cleanup that often pushes earlier than a hotfix (hotfixes need repros and logs). GitHub's default list reinforces open time. Reviewer habit is "clear the top." Together, small high-risk diffs sink stably.

Second layer: a merge queue implies "green means ship"; a triage queue implies "decide whether this deserves today's attention." Agents are good at turning CI green (failing-ci here is the deliberate counterexample); they will not allocate your attention. Green × early × large is the FIFO deception optimum.

When this does not fit

• You almost never open more than two overnight PRs. Throttle and Pass 1 are ceremony.
• Nobody owns a morning review window. You are missing a duty roster, not a sort key — assign machines 4–5 first.
• Every overnight change must ship the same day (compliance / hotfix window). Allow only hotfix overnight slots; do not run triage theater on seven ordinary PRs.
• No stable path conventions. Path-risk signals go blind; name auth/, billing/, workflows first.
• Model summaries instead of disposition. Summaries still bait deep reads; Pass 1 needs executable kill/fix/merge, not another paragraph.

Not the same article as "how to read a large PR"

Once Pass 2 has chosen merge-track, how to carve a large diff for humans is a review-map problem. This piece stops earlier on purpose: do not put the cleanup into Pass 2. Reverse that order and the best map still spends ninety minutes on the wrong PR.

Two morning failures that look different

The first is above: FIFO sticks on the cleanup; auth is deferred. The list is still long; the reviewer feels tired. The tiredness is real; the output is wrong — attention went to low-risk, high-cost work.

The second is quieter: the reviewer skips the cleanup by instinct, opens auth, kills the drive-by, and leaves nothing behind. Labels stay empty; chat says "big one this afternoon." At 14:00 machine 2's agent force-pushes the cleanup again; machine 5 starts a shift and sorts by created from the top. Instinct triage that never becomes queue state did not happen.

Pass 1's "one minute" is not speed for its own sake — it forces a triage:* write. A skip without a label only transfers the FIFO tax to the next shift.

How agents will game the rules (and what to concede)

Agents can read AGENTS.md and "comply" beautifully: split three unrelated edits into three overnight PRs, fill max_overnight_prs=3, each with a tidy Receipt. Throttle looks green; the morning is still three medium PRs and the auth hotfix still cannot enter.

Do not raise the cap to 10. Harden who earns a slot:

• Receipt Risk: high with paths hitting auth|billing may displace an occupied overnight pr-risk:low slot (comment which PR was displaced).
• No issue number → throttle refuses even if a slot is free.
• Themes triage:killed two days running enter cooldown — same intent banned for the day.

Concede hotfixes: when production is dropping sessions, a human-applied triage:hotfix may open a fourth. Do not concede "the agent declared this a hotfix."

Review budget is calendar-back, not agent-forward

On a three-person team, pre-standup deep-review time on machines 4–5 is usually overestimated. After standup, yesterday's fix-track, and Windows failure bounce-backs, net budget is often 60–90 minutes. Agents keep opening while "context remains."

The right input to max_overnight_prs is next-day net review minutes divided by average merge-track deep-read minutes — not how many diffs a model can emit overnight. I set 3 because a 90-minute window needs ~7 minutes for Pass 1 and ~60 for auth+lockfile+docs+feature in Pass 2. Your numbers differ; the formula should not.

If net budget is often under 45 minutes, the overnight cap is 1–2, and feature PRs wait for daytime. That is not punishing agents; it is naming review as the scarce resource.

Handoff to machines 6 and 7

Machine 6 need not queue Windows work for triage:kill; huge triage:fix cleanups can wait until split. Machine 7 can soft-block merges while any triage:pending remains — forcing Pass 1 to exist. None of that is required on day one; it shows morning disposition is an input to the seven-machine pipeline, not a reviewer's private note.

This run did not wire Windows or a live merge gate. The point is only: queue hygiene saves more than reviewer eyesight — it saves downstream validation on work you already decided to kill or defer.

How I know FIFO really "sticks" on the cleanup

Objection: a human seeing 45 files would skip. Yes — and that skip is already handmade triage. The FIFO simulation models trusting list order and deep-reading downward; the moment you skip, you have stepped toward risk-first, but without labels or Pass 1 accounting the skip cannot hand off to the next shift.

Estimated minutes are a rule table, not an eye tracker. Setting huge=90 matches "the whole pre-standup budget"; even if you believe the cleanup is a 40-minute read, FIFO still schedules it before auth — the qualitative claim stands: open order is not risk order.

Reproduce: unpack the kit → python3 run_lab.py. Check results.json for stuck-partial-deep-read on big-cleanup, auth-session-fix inside risk_sim_summary.merge_ready, and the fourth throttle entry allowed: false.

Smallest copy-tomorrow steps

1. AGENTS.md (machines 1–3): throttle before overnight gh pr create; require Intent/Receipt; ban drive-bys.
2. Create labels: triage:pending|kill|fix|merge, pr-risk:high|med|low.
3. Ten minutes before standup: run triage.py (or label by the same signals), filter triage:merge, high first.
4. Set max_overnight_prs from next-day review minutes / average deep-read minutes, not from how many PRs agents can open.
5. Huge cleanups are always fix-track: split or schedule off the pre-standup window.

A one-week rollout that does not bounce back to FIFO

Do not ship throttle, labels, scripts, and merge gates in the same week. Friction sends people back to FIFO.

Days 1–2: Labels only. Machines 4–5 do Pass 1 by hand before standup. Success: no overnight PR remains without triage:* at standup; auth-sized fixes are at least merge+high, not buried.

Days 3–4: AGENTS.md hard-requires Receipt; close agent PRs that lack it (with a comment — do not silently deep-read). Count kill reasons — if drive-bys are more than half, fix agent prompts before hiring more reviewers.

Day 5: Turn on max_overnight_prs from net budget. Watch for "three low-risk slots full, hotfix blocked"; only then add high-risk displacement.

After that: wire triage.py to exported JSON or a small bot, and let machine 7 refuse pending. Automation amplifies a habit that already works; it does not replace the habit.

If days 1–2 cannot finish labeling before standup, later scripts only automate FIFO more prettily. Prove disposition happens, then tool it.

What was actually run

Run: toy git repo with seven branches; triage.py classify/sort; 90-minute FIFO vs risk-first budget sim; throttle.py ALLOW×3 / REFUSE×2; labels into pr_state.json plus printed gh templates.

Not run: not live GitHub/Actions; labels not applied remotely; no Windows execution; no seven-machine integration.

Kit: overnight-triage-kit.tar.gz — triage.py, throttle.py, labels_kit.py, build_repo.py, run_lab.py, AGENTS.md snippet, illustrative morning-triage.yml, results.

Smallest step today: stop sorting tomorrow morning by created. Label triage:* first, open only triage:merge. If you catch yourself twenty minutes into a 45-file cleanup while auth is still pending, you just paid the FIFO tax again.