From 8b919847e0e48d4ac9a853913be1209123d04762 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:05:43 -0700
Subject: [PATCH 01/17] Model the self-review policy in derive()

Developers now CR and QA their own PRs unless they ask for review, so
"needs CR" no longer means someone else owes a review. derive() needs
to know which PRs are the author's own job and which are waiting on
people who were asked.

A pull is ownReview when its author is a developer (config
projects.developerTeams, or everyone when that's unset) and nothing
requested a review: no person, no team, no claim. askedOf lists who was
asked, with a requested GitHub team counting as everyone on the roster
team of that name, and askedAt is when. Only pulls waiting on others
can starve. An author's own stale stamp now owes a re-stamp, like
anyone else's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/stack.test.ts  |  3 +
 frontend-v2/src/model/status.test.ts | 90 +++++++++++++++++++++++++---
 frontend-v2/src/store.ts             | 12 +++-
 shared/model/status.ts               | 88 ++++++++++++++++++++++++---
 shared/types.ts                      | 15 +++++
 5 files changed, 190 insertions(+), 18 deletions(-)

diff --git a/frontend-v2/src/model/stack.test.ts b/frontend-v2/src/model/stack.test.ts
index de497c7e..341cfb75 100644
--- a/frontend-v2/src/model/stack.test.ts
+++ b/frontend-v2/src/model/stack.test.ts
@@ -78,6 +78,9 @@ function dp(
       cryo: false,
       changesRequestedBy: [],
       engagedNoStamp: [],
+      ownReview: false,
+      askedOf: [],
+      askedAt: null,
    };
 }
 
diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index 71c99478..1d8cddbb 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -3,7 +3,9 @@ import type { PullData, Signature, SignatureType } from '../../../shared/types';
 import {
    ciVerdict,
    derive,
+   isDeveloper,
    isIterating,
+   reviewPolicy,
    reviewWeight,
    STARVE_DAYS,
    type Weight,
@@ -140,9 +142,11 @@ describe('status derivation precedence', () => {
       expect(d.recrBy).toEqual([]);
    });
 
-   it("the author's own stale stamp never creates a re-stamp lane entry", () => {
+   it("the author's own stale stamp is a re-stamp the author owes", () => {
       const p = withStatus({ allCR: [sig('CR', 'author', false)] });
-      expect(derive(p, undefined, NOW).status).toBe('needs_cr');
+      const d = derive(p, undefined, NOW);
+      expect(d.status).toBe('needs_recr');
+      expect(d.recrBy).toEqual(['author']);
    });
 
    it('CR done, QA missing → needs_qa; both → ready', () => {
@@ -399,26 +403,98 @@ describe('ciVerdict', () => {
    });
 });
 
+const OUTSIDER = reviewPolicy({ Devs: ['r', 'q'] });
+
+describe('the self-review policy', () => {
+   const old = new Date((NOW - 10 * 86400) * 1000).toISOString();
+
+   it("a developer's unrequested pull is their own review, and never starves", () => {
+      const d = derive(pull({ created_at: old }), undefined, NOW);
+      expect(d.ownReview).toBe(true);
+      expect(d.status).toBe('needs_cr');
+      expect(d.starved).toBe(false);
+      expect(d.askedOf).toEqual([]);
+   });
+
+   it('a review request hands it to the people asked, and it can starve', () => {
+      const p = pull({
+         created_at: old,
+         requested_reviewers: ['r', 'claimer'],
+         review_requests: [
+            { login: 'r', at: NOW - 3600, self: false },
+            { login: 'claimer', at: NOW - 60, self: true },
+         ],
+      });
+      const d = derive(p, undefined, NOW);
+      expect(d.ownReview).toBe(false);
+      expect(d.askedOf).toEqual(['r']);
+      expect(d.askedAt).toBe(NOW - 3600);
+      expect(d.starved).toBe(true);
+   });
+
+   it('a claim alone takes it off the author too', () => {
+      const p = pull({
+         requested_reviewers: ['claimer'],
+         review_requests: [{ login: 'claimer', at: NOW, self: true }],
+      });
+      const d = derive(p, undefined, NOW);
+      expect(d.ownReview).toBe(false);
+      expect(d.askedOf).toEqual([]);
+   });
+
+   it('a team request asks everyone on the roster team of that name', () => {
+      const policy = reviewPolicy({ 'Store Front': ['author', 'a', 'b'], Other: ['c'] });
+      const d = derive(
+         pull({ requested_teams: ['store-front'] }),
+         undefined,
+         NOW,
+         undefined,
+         undefined,
+         policy
+      );
+      expect(d.askedOf).toEqual(['a', 'b']);
+      expect(d.ownReview).toBe(false);
+      // a team the roster doesn't know still counts as asking for review
+      const unknown = derive(
+         pull({ requested_teams: ['infra'] }),
+         undefined,
+         NOW,
+         undefined,
+         undefined,
+         policy
+      );
+      expect(unknown.ownReview).toBe(false);
+      expect(unknown.askedOf).toEqual([]);
+   });
+
+   it("someone outside the dev team doesn't review their own", () => {
+      const d = derive(pull(), undefined, NOW, undefined, undefined, OUTSIDER);
+      expect(d.ownReview).toBe(false);
+      expect(isDeveloper(OUTSIDER, 'R')).toBe(true);
+   });
+});
+
 describe('starvation and weight', () => {
-   it('an old CR-incomplete pull is starved, whatever partial progress it has', () => {
+   it('an old CR-incomplete pull waiting on others is starved, whatever partial progress it has', () => {
+      // the author is outside the dev team, so the review is someone else's
       const old = new Date((NOW - 10 * 86400) * 1000).toISOString();
       const p = pull({ created_at: old });
-      const d = derive(p, undefined, NOW);
+      const d = derive(p, undefined, NOW, undefined, undefined, OUTSIDER);
       expect(d.starved).toBe(true);
       expect(d.starveScore).toBeGreaterThan(0);
 
       // half-reviewed rot: 1 of 2 CRs, still starving (the old crHave === 0
       // cliff hid these from the aging lane forever)
       const half = withStatus({ cr_req: 2, allCR: [sig('CR', 'r', true)] }, { created_at: old });
-      expect(derive(half, undefined, NOW).starved).toBe(true);
+      expect(derive(half, undefined, NOW, undefined, undefined, OUTSIDER).starved).toBe(true);
 
       // a stale stamp waiting on its re-CR rots too
       const stale = withStatus({ allCR: [sig('CR', 'r', false)] }, { created_at: old });
-      expect(derive(stale, undefined, NOW).starved).toBe(true);
+      expect(derive(stale, undefined, NOW, undefined, undefined, OUTSIDER).starved).toBe(true);
 
       // fully CRed: never starved
       const done = withStatus({ allCR: [sig('CR', 'r', true)] }, { created_at: old });
-      expect(derive(done, undefined, NOW).starved).toBe(false);
+      expect(derive(done, undefined, NOW, undefined, undefined, OUTSIDER).starved).toBe(false);
 
       // parked (Cryogenic Storage) ages on purpose: never starved, so no
       // starve nags, no starve score, no turn rotation
diff --git a/frontend-v2/src/store.ts b/frontend-v2/src/store.ts
index a7d9655a..c48d98d6 100644
--- a/frontend-v2/src/store.ts
+++ b/frontend-v2/src/store.ts
@@ -3,7 +3,9 @@ import { backend, type ConnectionState } from './backend/socket';
 import {
    derive,
    parseWeightLabels,
+   reviewPolicy,
    type DerivedPull,
+   type ReviewPolicy,
    type Weight,
 } from '../../shared/model/status';
 import { isBotLogin } from '../../shared/model/visibility';
@@ -57,6 +59,9 @@ let repoSpecs: RepoSpec[] = [];
 // payload — not a separate config.json fetch. A fresh weightLabels Map
 // reference invalidates the derive cache so weights re-resolve when it arrives.
 let weightLabels: ReadonlyMap<string, Weight> = new Map();
+// who's a developer (and what a team review request means), from the same
+// payload; replaced whole on initialize, so it's part of the cache key too
+let policy: ReviewPolicy = reviewPolicy();
 let extraBots: ReadonlySet<string> = new Set();
 let projectLabelPrefix: string | null = null;
 let me = '';
@@ -239,6 +244,7 @@ const derived = new WeakMap<
       spec: RepoSpec | undefined;
       warnDays: number;
       weightLabels: ReadonlyMap<string, Weight>;
+      policy: ReviewPolicy;
       minute: number;
       value: DerivedPull;
    }
@@ -251,11 +257,12 @@ function deriveCached(pull: PullData, spec: RepoSpec | undefined, warnDays: numb
       hit.spec === spec &&
       hit.warnDays === warnDays &&
       hit.weightLabels === weightLabels &&
+      hit.policy === policy &&
       hit.minute === minute
    )
       return hit.value;
-   const value = derive(pull, spec, Date.now() / 1000, warnDays, weightLabels);
-   derived.set(pull, { spec, warnDays, weightLabels, minute, value });
+   const value = derive(pull, spec, Date.now() / 1000, warnDays, weightLabels, policy);
+   derived.set(pull, { spec, warnDays, weightLabels, policy, minute, value });
    return value;
 }
 
@@ -320,6 +327,7 @@ function start() {
          repoSpecs = payload.repos;
          // server-owned config rides with the board (see shared/types)
          weightLabels = parseWeightLabels(payload.weightLabels);
+         policy = reviewPolicy(payload.developerTeams);
          extraBots = new Set(payload.bots ?? []);
          projectLabelPrefix = payload.projectLabelPrefix || null;
          firstBuild ??= payload.build;
diff --git a/shared/model/status.ts b/shared/model/status.ts
index e4e9022f..5c780309 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -80,8 +80,21 @@ export interface DerivedPull {
    ageDays: number;
    /** epoch secs the last required sign-off landed; null until fully signed off */
    signedOffAt: number | null;
-   /** CR-incomplete past STARVE_DAYS — including half-reviewed and stale-CR rot */
+   /** CR-incomplete past STARVE_DAYS on a pull waiting on someone else's
+    * review (asked for, or from outside the dev team); a developer's own
+    * unrequested pull never starves, its review is the author's job */
    starved: boolean;
+   /** the self-review policy: a developer's pull with no review request (no
+    * person, no team, no claim). Its CR and QA are the author's own to do,
+    * and nobody else owes it anything */
+   ownReview: boolean;
+   /** logins asked to review it by the author's side: requested reviewers
+    * (claims excluded) plus every member of a requested roster team; never
+    * the author */
+   askedOf: string[];
+   /** epoch secs of the earliest open request in askedOf; null if none or
+    * unknown. Requests are answered in hours, so this clock drives the nudge */
+   askedAt: number | null;
    starveScore: number;
    weight: Weight;
    /** mergeable === false: shows as a flag everywhere, gates "ready" */
@@ -109,7 +122,7 @@ export interface DerivedPull {
 }
 
 export const WEIGHT_ORDER = ['XS', 'S', 'M', 'L', 'XL'] as const;
-export type Weight = (typeof WEIGHT_ORDER)[number];
+export type Weight = typeof WEIGHT_ORDER[number];
 const WEIGHT_RANK: Record<Weight, number> = WEIGHT_ORDER.reduce(
    (acc, w, i) => ({ ...acc, [w]: i }),
    {} as Record<Weight, number>
@@ -152,14 +165,15 @@ export const ROT_DAYS = 10;
 const activeUsers = (sigs: Signature[]) =>
    unique(sigs.filter(s => s.data.active).map(s => s.data.user.login));
 
-/** users with only invalidated stamps (no active one), excluding the author */
-const staleUsers = (sigs: Signature[], author: string) => {
+/** users with only invalidated stamps (no active one), the author included:
+ * under self-review an author's own stale stamp is a re-stamp they owe */
+const staleUsers = (sigs: Signature[]) => {
    const active = activeUsers(sigs);
    return unique(
       sigs
          .filter(s => !s.data.active)
          .map(s => s.data.user.login)
-         .filter(u => !active.includes(u) && u !== author)
+         .filter(u => !active.includes(u))
    );
 };
 
@@ -244,6 +258,34 @@ export function headPushedAt(pull: PullData): number | null {
 export const crDone = (p: { crHave: number; data: PullData }) => p.crHave >= p.data.status.cr_req;
 export const qaDone = (p: { qaHave: number; data: PullData }) => p.qaHave >= p.data.status.qa_req;
 
+/** Who counts as a developer, and the roster teams a GitHub team request
+ * resolves through. Built once from config projects.developerTeams. */
+export interface ReviewPolicy {
+   /** developer logins (lowercased); empty means everyone is a developer */
+   developers: ReadonlySet<string>;
+   /** roster team name, lowercased and slugged like GitHub's ("Store
+    * Front" -> "store-front"), to its logins */
+   teams: ReadonlyMap<string, string[]>;
+}
+
+const slug = (name: string) => name.trim().toLowerCase().replace(/\s+/g, '-');
+
+export function reviewPolicy(developerTeams?: Record<string, string[]> | null): ReviewPolicy {
+   const teams = new Map<string, string[]>();
+   const developers = new Set<string>();
+   for (const [name, logins] of Object.entries(developerTeams ?? {})) {
+      if (!Array.isArray(logins)) continue;
+      teams.set(slug(name), logins);
+      logins.forEach(l => developers.add(l.toLowerCase()));
+   }
+   return { developers, teams };
+}
+
+const EVERYONE_DEVELOPS: ReviewPolicy = { developers: new Set(), teams: new Map() };
+
+export const isDeveloper = (policy: ReviewPolicy, login: string) =>
+   !policy.developers.size || policy.developers.has(login.toLowerCase());
+
 export function derive(
    pull: PullData,
    spec: RepoSpec | undefined,
@@ -254,7 +296,9 @@ export function derive(
    /** label title → weight bucket, from config.json's `weightLabels`. A
     * matching label is the authoritative review-effort signal and overrides
     * the diff-size heuristic; empty map keeps the heuristic. */
-   weightLabels: ReadonlyMap<string, Weight> = new Map()
+   weightLabels: ReadonlyMap<string, Weight> = new Map(),
+   /** who's a developer and what a team request means (reviewPolicy) */
+   policy: ReviewPolicy = EVERYONE_DEVELOPS
 ): DerivedPull {
    const st = pull.status;
    const crBy = activeUsers(st.allCR);
@@ -263,8 +307,30 @@ export function derive(
    const qaHave = qaBy.length;
    const ci = ciVerdict(pull, spec);
 
-   const staleCr = staleUsers(st.allCR, pull.user.login);
-   const staleQa = staleUsers(st.allQA, pull.user.login);
+   const author = pull.user.login;
+   // the author's own stamp goes stale on a push like anyone's, and under
+   // self-review it's the author who owes the re-stamp
+   const staleCr = staleUsers(st.allCR);
+   const staleQa = staleUsers(st.allQA);
+
+   // who the author's side asked: people (not claims, which are a reviewer
+   // volunteering) and every member of a requested roster team
+   const claims = new Set((pull.review_requests ?? []).filter(r => r.self).map(r => r.login));
+   const requestedTeams = pull.requested_teams ?? [];
+   const askedOf = unique([
+      ...(pull.requested_reviewers ?? []).filter(l => !claims.has(l)),
+      ...requestedTeams.flatMap(t => policy.teams.get(t.toLowerCase()) ?? []),
+   ]).filter(l => l !== author);
+   const askedAt =
+      Math.min(
+         ...(pull.review_requests ?? [])
+            .filter(r => !r.self && r.at != null && askedOf.includes(r.login))
+            .map(r => r.at as number)
+      ) || null;
+   const ownReview =
+      isDeveloper(policy, author) &&
+      !(pull.requested_reviewers ?? []).length &&
+      !requestedTeams.length;
 
    // a lifted block deactivates its signature, same as a stale CR stamp
    const devBlockedBy = activeUsers(st.dev_block);
@@ -332,7 +398,8 @@ export function derive(
    // Rot is rot whether the pull has zero stamps, one of two, or a stale one
    // waiting on a re-stamp — the old `crHave === 0` cliff hid half-reviewed
    // pulls from the aging lane forever.
-   const starved = !isParked && CR_INCOMPLETE.includes(status) && !crMet && ageDays >= warnDays;
+   const starved =
+      !isParked && !ownReview && CR_INCOMPLETE.includes(status) && !crMet && ageDays >= warnDays;
 
    const signedOffAt =
       crMet && qaMet
@@ -373,6 +440,9 @@ export function derive(
       cryo: isParked,
       changesRequestedBy,
       engagedNoStamp,
+      ownReview,
+      askedOf,
+      askedAt: Number.isFinite(askedAt) ? askedAt : null,
    };
 }
 
diff --git a/shared/types.ts b/shared/types.ts
index ffab015f..716f81b5 100644
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -96,6 +96,16 @@ export interface PullData {
     * omit the field entirely, so read as [] when absent — requested_reviewers
     * stays the authoritative list of who's requested either way. */
    review_requests?: Array<{ login: string; at: number | null; self: boolean }>;
+   /** GitHub team slugs the PR asks a review from (the pull's
+    * requested_teams). Under the self-review policy a request means everyone
+    * listed; derive() turns a slug into people through the roster teams
+    * (config projects.developerTeams), matched by name. Absent on older
+    * servers: read as []. */
+   requested_teams?: string[];
+   /** areas the diff touches that usually deserve team input (ci, migrations,
+    * alerting, agent-docs, deploy, dependencies), computed server-side from
+    * the changed file paths. Absent until the server has looked: read as []. */
+   input_hints?: string[];
    // the wire also sends top-level cr_req/qa_req twins, but status.cr_req/
    // qa_req are the ones every consumer reads — typing one copy prevents
    // reading the wrong one
@@ -151,6 +161,11 @@ export interface InitializePayload {
     * only when the server is set up for projects; the Projects tab shows only
     * then. See shared/model/projects.ts. */
    projectLabelPrefix?: string;
+   /** config projects.developerTeams: team name -> logins. Anyone listed is
+    * a developer, who reviews their own PRs unless they ask for review;
+    * everyone else's PRs still need someone else's. Absent: everyone counts
+    * as a developer. */
+   developerTeams?: Record<string, string[]>;
    /** names the frontend build the server is serving (absent without a build);
     * a different one on a later initialize means the board was redeployed */
    build?: string;

From 0ec1d61bb8cd40d6fd224c7183614e82f14c161f Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:13:59 -0700
Subject: [PATCH 02/17] Keep stamps through base merges, read team requests

The self-review policy needs a few things from the server:

1) A clean merge of master into a PR no longer voids its CR and QA
   stamps, the way GitHub keeps an approval across one. The commit
   list is only fetched when a stamp actually predates the head, to
   spare the API quota. A merge that resolved conflicts reads the
   same as a clean one; the code says so.
2) Review requests to GitHub teams (requested_teams) are stored and
   sent to the board, which counts one as a request to everyone on the
   roster team of that name.
3) "Input hints": which areas a PR's diff touches that usually deserve
   team input (CI, migrations, alerting, agent docs, deploy config,
   dependencies), from its changed paths, fetched once per head.
4) The board gets the developer roster, the server-side derive uses
   it, and /api/v1 adds review.own, asked_of and asked_at.
5) Stats history's time to first CR only counts someone other than the
   author.

Migration 0033 adds the two columns; run it before this code. The
dummy board seeds team requests, request times, self-stamped pulls and
input hints.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 controllers/api.js                            |  1 +
 controllers/githubHooks.js                    |  4 +-
 controllers/stats.js                          | 15 +--
 frontend-v2/src/backend/dummy.ts              | 91 ++++++++++++++++++-
 lib/base-merge.js                             | 33 +++++++
 lib/git-manager.js                            | 70 +++++++++++++-
 lib/input-hints.js                            | 34 +++++++
 lib/pull-manager.js                           |  3 +
 lib/review-model.js                           | 17 +++-
 lib/schema-check.js                           |  6 ++
 ...pulls--add-requested-teams-input-hints.sql |  3 +
 migrations/schema.sql                         |  2 +
 models/db_pull.js                             |  9 ++
 models/pull.js                                | 17 ++++
 shared/index.ts                               |  1 +
 test/api.test.js                              |  1 +
 test/base-merge.test.js                       | 35 +++++++
 test/git-manager-refresh.test.js              | 64 +++++++++++++
 test/input-hints.test.js                      | 56 ++++++++++++
 test/stats.test.js                            | 13 +++
 20 files changed, 453 insertions(+), 22 deletions(-)
 create mode 100644 lib/base-merge.js
 create mode 100644 lib/input-hints.js
 create mode 100644 migrations/0033-pulls--add-requested-teams-input-hints.sql
 create mode 100644 test/base-merge.test.js
 create mode 100644 test/input-hints.test.js

diff --git a/controllers/api.js b/controllers/api.js
index 8a679df2..3f04a27c 100644
--- a/controllers/api.js
+++ b/controllers/api.js
@@ -34,6 +34,7 @@ function toRecord(d) {
          cr: { req: p.status.cr_req, have: d.crHave, by: d.crBy, recr_by: d.recrBy },
          qa: { req: p.status.qa_req, have: d.qaHave, by: d.qaBy },
       },
+      review: { own: d.ownReview, asked_of: d.askedOf, asked_at: d.askedAt },
       dev_blocked_by: d.devBlockedBy,
       deploy_blocked_by: d.deployBlockedBy,
       head_sha: p.head.sha,
diff --git a/controllers/githubHooks.js b/controllers/githubHooks.js
index 70f82bf3..37beca0a 100644
--- a/controllers/githubHooks.js
+++ b/controllers/githubHooks.js
@@ -316,8 +316,8 @@ function handleLabelEvents(body) {
  * Record one `review_requested` / `review_request_removed` webhook's
  * metadata onto the in-memory review_requests cache (models/pull.js) --
  * memory-only, no DB write. `body.requested_reviewer` is absent for a team
- * review request, which Pulldasher doesn't track per-reviewer, so that's a
- * no-op.
+ * review request, which isn't a per-reviewer clock (the team's slug rides on
+ * the pull payload's requested_teams, saved with the pull), so that's a no-op.
  */
 function recordReviewRequestMetadata(body) {
    const reviewer = body.requested_reviewer;
diff --git a/controllers/stats.js b/controllers/stats.js
index bedc03a6..779efa26 100644
--- a/controllers/stats.js
+++ b/controllers/stats.js
@@ -72,7 +72,9 @@ function queryMergeAgeByDay() {
 
 /**
  * Per-pull hours from open to first CR signature, for merged pulls in the
- * last 12 months. One row per (repo, number) — used both to compute the
+ * last 12 months. Only someone other than the author counts: under
+ * self-review the author's own CR would read as zero, and a pull with only
+ * that has no first review and drops out. One row per (repo, number) — used both to compute the
  * monthly average in SQL and, in JS, the monthly median (MySQL has no
  * MEDIAN aggregate, and the row count here is small enough — thousands, not
  * millions — that pulling the raw latencies and sorting in JS is simpler
@@ -86,10 +88,11 @@ function queryFirstCrLatencies() {
              (cr.min_date - p.date) AS latency_seconds \
         FROM pulls p \
         JOIN ( \
-          SELECT repo, number, MIN(date) AS min_date \
-            FROM pull_signatures \
-           WHERE type = 'CR' \
-           GROUP BY repo, number \
+          SELECT s.repo, s.number, MIN(s.date) AS min_date \
+            FROM pull_signatures s \
+            JOIN pulls o ON o.repo = s.repo AND o.number = s.number \
+           WHERE s.type = 'CR' AND s.user <> o.owner \
+           GROUP BY s.repo, s.number \
         ) cr ON cr.repo = p.repo AND cr.number = p.number \
        WHERE p.date_merged >= ? \
          AND cr.min_date > p.date";
@@ -209,7 +212,7 @@ function loadHistory() {
 // factored out so they're independently testable without a live DB connection
 // (mirrors lib/refresh.js exporting processIssueItem/processPullItem for the
 // same reason).
-export { firstCrByMonth, median, formatDate, formatIsoWeek, round1 };
+export { queryFirstCrLatencies, firstCrByMonth, median, formatDate, formatIsoWeek, round1 };
 
 export default {
    /**
diff --git a/frontend-v2/src/backend/dummy.ts b/frontend-v2/src/backend/dummy.ts
index d7e91e02..147a8069 100644
--- a/frontend-v2/src/backend/dummy.ts
+++ b/frontend-v2/src/backend/dummy.ts
@@ -44,7 +44,7 @@ export async function loadDummy(): Promise<InitializePayload> {
    const withBody = (p: PullData, i: number): PullData =>
       p.body === 'pull request dummy body' ? { ...p, body: BODIES[i % BODIES.length] } : p;
    const pulls = withSyntheticStacks(raw).map((p, i) =>
-      withProject(withBody(withSizes(redate(p, i), i), i), i)
+      withProject(withBody(withSizes(withSelfReviewDemos(redate(p, i), i), i), i), i)
    );
    // ?projects=100 adds that many projects in flight, to design at real size
    const scaled = new URLSearchParams(location.search).has('projects')
@@ -65,6 +65,7 @@ export async function loadDummy(): Promise<InitializePayload> {
          'size: XL': 'XL',
       },
       projectLabelPrefix: DUMMY_PROJECT_PREFIX,
+      developerTeams: dummyDeveloperTeams(pulls),
       // The fixture carries almost no closed/merged pulls and no diff sizes, so
       // the Stats lens (merge-time-by-size, leaderboards over shipped work) has
       // nothing to show. Synthesize a fortnight of merged PRs across the size
@@ -73,6 +74,20 @@ export async function loadDummy(): Promise<InitializePayload> {
    };
 }
 
+// The roster of developers (config projects.developerTeams): every dummy author
+// but two, who stay outside contributors whose pulls still need someone else's
+// review. The viewer is always on it.
+const OUTSIDE_CONTRIBUTORS = new Set(['notme', 'Michelle5102']);
+function dummyDeveloperTeams(pulls: PullData[]): Record<string, string[]> {
+   const logins = [...new Set([dummyUser(), ...pulls.map(p => p.user.login)])].filter(
+      l => !OUTSIDE_CONTRIBUTORS.has(l) && !l.endsWith('[bot]')
+   );
+   const names = ['Store Front', 'Platform', 'Community'];
+   const teams: Record<string, string[]> = Object.fromEntries(names.map(n => [n, []]));
+   logins.forEach((l, i) => teams[names[i % names.length]].push(l));
+   return teams;
+}
+
 export const DUMMY_PROJECT_PREFIX = 'project:';
 
 // The Projects tab reads project labels off the pulls, and the fixture
@@ -244,8 +259,8 @@ function participantsFor(pull: PullData, i: number): string[] {
       i === CHANGES_REQUESTED_INDEX
          ? ['grumpy-reviewer']
          : i === COMMENTED_INDEX
-           ? ['curious-commenter']
-           : ['silent-lurker'];
+         ? ['curious-commenter']
+         : ['silent-lurker'];
    return [...new Set([...(pull.participants ?? []), ...stampers, ...extra])];
 }
 
@@ -269,6 +284,72 @@ const wantsReviewRequest = (pull: PullData, i: number): boolean =>
    pull.user.login !== dummyUser() && i % 3 === 1;
 const ASSIGNEE_INDEXES = new Set([6, 12]);
 
+// The self-review policy demos, keyed by index like the rest: team requests
+// (one for a team nobody is on the roster of), requests of the viewer with a
+// clock in hours (one past four), developers' own stamped pulls, an author
+// whose own stamp went stale, and input hints from the diff's paths.
+const TEAM_REQUESTS: Record<number, string[]> = {
+   2: ['store-front'],
+   9: ['store-front'],
+   17: ['platform'],
+   20: ['community'],
+   30: ['design'],
+};
+const OWN_STAMPED = new Set([3, 8, 21]);
+const OWN_STALE_STAMP = 24;
+const INPUT_HINTS: Record<number, string[]> = {
+   4: ['migrations'],
+   18: ['ci', 'agent-docs'],
+   26: ['deploy', 'dependencies'],
+   33: ['alerting'],
+};
+
+function withSelfReviewDemos(pull: PullData, i: number): PullData {
+   const now = Date.now();
+   const author = pull.user;
+   const stamp = (type: 'CR' | 'QA', active: boolean, hoursAgo: number) => ({
+      data: {
+         repo: pull.repo,
+         number: pull.number,
+         user: { id: 1, ...author },
+         type,
+         created_at: new Date(now - hoursAgo * 3_600_000).toISOString(),
+         active: active ? 1 : 0,
+         comment_id: 900000000 + i * 10 + (type === 'CR' ? 1 : 2),
+      },
+   });
+   const meAsked = (pull.requested_reviewers ?? []).includes(dummyUser());
+   let out: PullData = {
+      ...pull,
+      requested_teams: TEAM_REQUESTS[i] ?? [],
+      input_hints: INPUT_HINTS[i] ?? [],
+      // asked hours ago; the one at 7 is past the four hours reviewers answer in
+      review_requests: meAsked
+         ? [
+              {
+                 login: dummyUser(),
+                 at: Math.floor(now / 1000) - (i === 7 ? 5 : 1 + (i % 3)) * 3600,
+                 self: false,
+              },
+           ]
+         : pull.review_requests,
+   };
+   if (OWN_STAMPED.has(i) || i === OWN_STALE_STAMP) {
+      out = {
+         ...out,
+         requested_reviewers: [],
+         requested_teams: [],
+         review_requests: [],
+         status: {
+            ...out.status,
+            allCR: [stamp('CR', i !== OWN_STALE_STAMP, 6)],
+            allQA: i === OWN_STALE_STAMP ? [] : [stamp('QA', true, 5)],
+         },
+      };
+   }
+   return out;
+}
+
 function withSyntheticStacks(pulls: PullData[]): PullData[] {
    const out = [...pulls];
    const rebase = (i: number, baseRef: string) => {
@@ -329,8 +410,8 @@ function redate(pull: PullData, i: number): PullData {
       deletions,
       requested_reviewers: wantsReviewRequest(pull, i)
          ? [dummyUser()]
-         : (pull.requested_reviewers ?? []),
-      assignees: ASSIGNEE_INDEXES.has(i) ? [dummyUser()] : (pull.assignees ?? []),
+         : pull.requested_reviewers ?? [],
+      assignees: ASSIGNEE_INDEXES.has(i) ? [dummyUser()] : pull.assignees ?? [],
    };
 }
 
diff --git a/lib/base-merge.js b/lib/base-merge.js
new file mode 100644
index 00000000..661401ae
--- /dev/null
+++ b/lib/base-merge.js
@@ -0,0 +1,33 @@
+const escape = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * Whether a commit is a merge of the PR's base branch into the PR branch:
+ * two parents and git's or GitHub's merge message, e.g. "Merge branch
+ * 'master' into foo", "Merge branch 'master' of github.com:o/r into foo",
+ * "Merge remote-tracking branch 'origin/master' into foo".
+ */
+export function isBaseMerge(commit, baseRef) {
+   if (!commit.parents || commit.parents.length !== 2) return false;
+   const subject = String(commit.commit?.message ?? '').split('\n')[0];
+   return new RegExp(
+      `^Merge (?:remote-tracking )?branch '(?:[\\w.-]+/)?${escape(
+         baseRef
+      )}'(?: of \\S+)?(?: into .+)?$`
+   ).test(subject);
+}
+
+/**
+ * Whether a CR/QA stamp left at `stampAt` survives the commits since: true
+ * when every commit made after it is a merge of the base into the PR, the way
+ * GitHub keeps an approval across one. `commits` is pulls.listCommits output.
+ *
+ * ponytail: the message can't tell a clean merge from one that resolved
+ * conflicts, so a conflict-resolving merge keeps the stamp too. Upgrade path:
+ * compare the merge commit's tree with a fresh merge of its parents, or the
+ * PR's file patches before and after.
+ */
+export function stampSurvivesBaseMerges(stampAt, commits, baseRef) {
+   return commits
+      .filter(c => new Date(c.commit.committer.date) > stampAt)
+      .every(c => isBaseMerge(c, baseRef));
+}
diff --git a/lib/git-manager.js b/lib/git-manager.js
index 4313d192..366c8d2a 100644
--- a/lib/git-manager.js
+++ b/lib/git-manager.js
@@ -15,6 +15,8 @@ import Status from '../models/status.js';
 import Signature from '../models/signature.js';
 import getLogin from './get-user-login.js';
 import { noopPacer } from './pacer.js';
+import { stampSurvivesBaseMerges } from './base-merge.js';
+import { inputHints, rememberHints, recalledHints } from './input-hints.js';
 import { DEFAULT_PROJECT_PREFIX } from '../shared/dist/index.js';
 
 const MyOctokit = Octokit.plugin(throttling, retry);
@@ -398,7 +400,7 @@ export default {
          reviews,
          botLogin,
          diffStats,
-      ]).then(function (results) {
+      ]).then(async function (results) {
          var reviewComments = results[0],
             comments = results[1],
             headCommit = results[2],
@@ -441,16 +443,40 @@ export default {
          // signature, which means the approval is still valid. Re-applying the
          // commit-date check would drop approvals GitHub deliberately kept.
          var headCommitDate = new Date(headCommit.commit.committer.date);
+         var predatesHead = signature =>
+            (signature.data.type === 'CR' || signature.data.type === 'QA') &&
+            !signature.data.fromGithubApproval &&
+            new Date(signature.data.created_at) < headCommitDate;
+         // A stamp also stays when every commit since is a merge of the base
+         // branch into the PR (GitHub keeps approvals across one). The commit
+         // list costs a call, so only ask when a stamp actually predates the head.
+         var commits = signatures.some(predatesHead)
+            ? await getPullCommits(repo, githubPull.number)
+            : [];
          signatures.forEach(function (signature) {
             if (
-               (signature.data.type === 'CR' || signature.data.type === 'QA') &&
-               !signature.data.fromGithubApproval &&
-               new Date(signature.data.created_at) < headCommitDate
+               predatesHead(signature) &&
+               !stampSurvivesBaseMerges(
+                  new Date(signature.data.created_at),
+                  commits,
+                  githubPull.base.ref
+               )
             ) {
                signature.data.active = false;
             }
          });
 
+         // Which areas the diff touches, refetched only when the head moved
+         // since the stored hints were computed
+         if (githubPull.state === 'open') {
+            var hints = recalledHints(repo, githubPull.number, githubPull.head.sha);
+            if (!hints) {
+               hints = inputHints(await getPullFilePaths(repo, githubPull.number));
+               rememberHints(repo, githubPull.number, githubPull.head.sha, hints);
+            }
+            githubPull.input_hints = hints;
+         }
+
          // Array of Comment objects.
          comments = comments.map(function (commentData) {
             commentData.number = githubPull.number;
@@ -759,7 +785,8 @@ export function deriveReviewRequests(events, requestedReviewerLogins, botLogin)
 
    const activeByLogin = new Map();
    ordered.forEach(event => {
-      // Team review requests have no individual reviewer to attribute this to.
+      // A team request has no individual to attribute this to; the team's
+      // slug rides on the pull's requested_teams instead.
       if (!event.requested_reviewer) {
          return;
       }
@@ -897,6 +924,39 @@ function getPullReviewComments(repo, number) {
    );
 }
 
+// oldest first, with parents and committer dates; GitHub lists at most 250
+function getPullCommits(repo, number) {
+   return logErrors(
+      github.paginate(
+         githubRest.pulls.listCommits,
+         params({ pull_number: number, per_page: 100 }, repo)
+      ),
+      'Getting commits for pull %s:%s',
+      repo,
+      number
+   );
+}
+
+function getPullFilePaths(repo, number) {
+   return logErrors(
+      (async () => {
+         const paths = [];
+         let page = 1;
+         for (; page <= 3; page++) {
+            const res = await githubRest.pulls.listFiles(
+               params({ pull_number: number, per_page: 100, page }, repo)
+            );
+            paths.push(...res.data.map(f => f.filename));
+            if (res.data.length < 100) break;
+         }
+         return paths;
+      })(),
+      'Getting changed files for pull %s:%s',
+      repo,
+      number
+   );
+}
+
 function getCommit(repo, sha) {
    return logErrors(
       githubRest.repos.getCommit(params({ ref: sha }, repo)).then(res => res.data),
diff --git a/lib/input-hints.js b/lib/input-hints.js
new file mode 100644
index 00000000..de45b9b2
--- /dev/null
+++ b/lib/input-hints.js
@@ -0,0 +1,34 @@
+const HINTS = [
+   [
+      'ci',
+      /(^|\/)(\.github|\.circleci|\.buildkite)\/|(^|\/)Jenkinsfile[^/]*$|(^|\/)lefthook[^/]*\.ya?ml$/,
+   ],
+   ['migrations', /(^|\/)migrations\/|(^|\/)schema\.sql$|\.sql$/i],
+   ['alerting', /(^|[/._-])(alert\w*|prometheus|grafana|datadog|pagerduty|sentry)([/._-]|$)/i],
+   ['agent-docs', /(^|\/)(AGENTS|CLAUDE)\.md$|(^|\/)\.(agents|claude|cursor|codex)\//],
+   [
+      'deploy',
+      /(^|\/)(Dockerfile[^/]*|docker-compose[^/]*|Capfile)$|(^|\/)(deploy|terraform|helm|k8s)\/|(^|\/)config\/deploy|\.tf$/,
+   ],
+   [
+      'dependencies',
+      /(^|\/)(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|composer\.(json|lock)|Gemfile(\.lock)?|go\.(mod|sum)|requirements[^/]*\.txt|pyproject\.toml)$/,
+   ],
+];
+
+/** Areas a diff touches that usually deserve team input, from its changed
+ * paths, in a fixed order and each once. */
+export function inputHints(paths) {
+   return HINTS.filter(([, re]) => paths.some(p => re.test(p))).map(([key]) => key);
+}
+
+// repo#number -> { sha, hints }: what the stored hints were computed for, so
+// a restart (Pull.fromDB seeds it) or a repeat refresh doesn't refetch the files
+const memo = new Map();
+const key = (repo, number) => `${repo}#${number}`;
+export const rememberHints = (repo, number, sha, hints) =>
+   memo.set(key(repo, number), { sha, hints });
+export const recalledHints = (repo, number, sha) => {
+   const m = memo.get(key(repo, number));
+   return m && m.sha === sha ? m.hints : null;
+};
diff --git a/lib/pull-manager.js b/lib/pull-manager.js
index c4b63af6..47129983 100644
--- a/lib/pull-manager.js
+++ b/lib/pull-manager.js
@@ -5,6 +5,7 @@ import _ from 'underscore';
 import dbManager from './db-manager.js';
 import Pull from '../models/pull.js';
 import { projectSettings } from './projects.js';
+import { developerTeams } from './review-model.js';
 import buildId from './build-id.js';
 
 const pmDebug = debug('pulldasher:pull-manager');
@@ -79,6 +80,8 @@ function sendInitialData(socket) {
       // the project label prefix, sent only when this install uses projects
       // (config.js `projects`); the board shows its Projects tab only then
       projectLabelPrefix: projectSettings()?.prefix,
+      // who reviews their own pulls, and what a team request means (shared reviewPolicy)
+      developerTeams: developerTeams(),
       // names the served frontend build, so an open tab can tell a deploy happened
       build: buildId,
    });
diff --git a/lib/review-model.js b/lib/review-model.js
index 2414b735..d5197ce3 100644
--- a/lib/review-model.js
+++ b/lib/review-model.js
@@ -1,5 +1,6 @@
 import config from './config-loader.js';
-import { derive, isBotLogin, parseWeightLabels } from '../shared/dist/index.js';
+import { derive, isBotLogin, parseWeightLabels, reviewPolicy } from '../shared/dist/index.js';
+import { savedSetting } from './settings.js';
 
 // Org config from config.js -- the single source. The board receives the same
 // values over the socket (see lib/pull-manager sendInitialData), so the API and
@@ -35,15 +36,22 @@ export function toWire(pull) {
    return JSON.parse(JSON.stringify(pull.toObject()));
 }
 
+/** The roster of developers (teams saved from the board win over config.js's),
+ * which decides whose pulls they review themselves; unset means everyone. */
+export const developerTeams = () =>
+   savedSetting('developer_teams') ?? config.projects?.developerTeams;
+
+const currentPolicy = () => reviewPolicy(developerTeams());
+
 /**
  * Derive one Pull into its DerivedPull (status bucket, CI verdict, weight,
  * sign-off counts, staleness, age, ...). Weight uses the org's weightLabels
  * (an auto/manual label overrides the diff-size guess), falling back to the
  * size heuristic for a pull carrying none.
  */
-export function derivePull(pull, now = Date.now() / 1000) {
+export function derivePull(pull, now = Date.now() / 1000, policy = currentPolicy()) {
    const wire = toWire(pull);
-   return derive(wire, specForRepo(wire.repo), now, undefined, weightLabels);
+   return derive(wire, specForRepo(wire.repo), now, undefined, weightLabels, policy);
 }
 
 /** Whether a login is a bot -- the `[bot]` suffix GitHub Apps carry, or the
@@ -55,5 +63,6 @@ export function isBot(login) {
 /** Derive a list of Pulls against one shared `now` (a consistent clock for a
  * single request/snapshot). */
 export function deriveAll(pulls, now = Date.now() / 1000) {
-   return pulls.map(pull => derivePull(pull, now));
+   const policy = currentPolicy();
+   return pulls.map(pull => derivePull(pull, now, policy));
 }
diff --git a/lib/schema-check.js b/lib/schema-check.js
index d2190b3e..921e8d99 100644
--- a/lib/schema-check.js
+++ b/lib/schema-check.js
@@ -29,6 +29,12 @@ export const MIGRATIONS = [
       table: 'roadmap_items',
       column: 'end_kind',
    },
+   // one statement adds both columns, so one stands for the pair
+   {
+      file: '0033-pulls--add-requested-teams-input-hints.sql',
+      table: 'pulls',
+      column: 'input_hints',
+   },
 ];
 
 /** The migration files this database hasn't had yet, oldest first. */
diff --git a/migrations/0033-pulls--add-requested-teams-input-hints.sql b/migrations/0033-pulls--add-requested-teams-input-hints.sql
new file mode 100644
index 00000000..2f40882d
--- /dev/null
+++ b/migrations/0033-pulls--add-requested-teams-input-hints.sql
@@ -0,0 +1,3 @@
+ALTER TABLE `pulls`
+  ADD COLUMN `requested_teams` json DEFAULT NULL AFTER `requested_reviewers`,
+  ADD COLUMN `input_hints` json DEFAULT NULL AFTER `requested_teams`;
diff --git a/migrations/schema.sql b/migrations/schema.sql
index dfd5222b..6512beb5 100644
--- a/migrations/schema.sql
+++ b/migrations/schema.sql
@@ -145,6 +145,8 @@ CREATE TABLE IF NOT EXISTS `pulls` (
   `owner` varchar(255) COLLATE utf8mb4_general_ci NOT NULL,
   `assignees` json DEFAULT NULL,
   `requested_reviewers` json DEFAULT NULL,
+  `requested_teams` json DEFAULT NULL,
+  `input_hints` json DEFAULT NULL,
   `cr_req` int NOT NULL DEFAULT '2',
   `qa_req` int NOT NULL DEFAULT '1',
   `date` int unsigned DEFAULT NULL,
diff --git a/models/db_pull.js b/models/db_pull.js
index 2d6b4830..374e260b 100644
--- a/models/db_pull.js
+++ b/models/db_pull.js
@@ -28,6 +28,7 @@ function DBPull(pull) {
       // Serialize to a JSON string; MySQL parses it into the JSON column.
       assignees: JSON.stringify(pullData.assignees || []),
       requested_reviewers: JSON.stringify(pullData.requested_reviewers || []),
+      requested_teams: JSON.stringify(pullData.requested_teams || []),
       cr_req: pullData.cr_req,
       qa_req: pullData.qa_req,
       closes: pullData.closes,
@@ -36,6 +37,14 @@ function DBPull(pull) {
       deletions: pullData.deletions,
       changed_files: pullData.changed_files,
    };
+   // only a full refresh computed them; the column holds {sha, hints} so a
+   // restart knows which head they were for
+   if (pullData.input_hints) {
+      this.data.input_hints = JSON.stringify({
+         sha: pullData.input_hints_sha,
+         hints: pullData.input_hints,
+      });
+   }
 }
 
 DBPull.prototype.save = function () {
diff --git a/models/pull.js b/models/pull.js
index 9d274543..13eea6e2 100644
--- a/models/pull.js
+++ b/models/pull.js
@@ -5,6 +5,7 @@ import queue from '../lib/pull-queue.js';
 import debug from '../lib/debug.js';
 import DBPull from './db_pull.js';
 import getLogin from '../lib/get-user-login.js';
+import { recalledHints, rememberHints } from '../lib/input-hints.js';
 import { isBot } from '../lib/review-model.js';
 
 const log = debug('pulldasher:pull');
@@ -155,6 +156,7 @@ class Pull {
       var data = _.extend({}, this.data);
       data.status = this.getStatus();
       data.labels = this.labels.map(label => label.data);
+      delete data.input_hints_sha;
       data.review_requests = getReviewRequests(data.repo, data.number, data.requested_reviewers);
       return data;
    }
@@ -318,6 +320,14 @@ class Pull {
          },
          assignees: (data.assignees || []).map(a => getLogin(a)),
          requested_reviewers: (data.requested_reviewers || []).map(r => getLogin(r)),
+         requested_teams: (data.requested_teams || []).map(t => t.slug),
+         // parse() fills input_hints on a full refresh; a webhook's body
+         // can't, so reuse what was computed for this same head
+         input_hints:
+            data.input_hints ??
+            recalledHints(data.base.repo.full_name, data.number, data.head.sha) ??
+            undefined,
+         input_hints_sha: data.head.sha,
          additions: data.additions,
          deletions: data.deletions,
          changed_files: data.changed_files,
@@ -392,6 +402,10 @@ class Pull {
     * Pull object.
     */
    static getFromDB(data, signatures, comments, reviews, commitStatuses, labels) {
+      // seed what the stored hints were computed for (see lib/input-hints.js)
+      if (data.input_hints?.sha) {
+         rememberHints(data.repo, data.number, data.input_hints.sha, data.input_hints.hints);
+      }
       var pullData = {
          repo: data.repo,
          number: data.number,
@@ -439,6 +453,9 @@ class Pull {
          // mysql2 auto-parses the JSON column, so this is already an array (or null).
          assignees: data.assignees ?? [],
          requested_reviewers: data.requested_reviewers ?? [],
+         requested_teams: data.requested_teams ?? [],
+         input_hints: data.input_hints?.hints ?? [],
+         input_hints_sha: data.input_hints?.sha,
          cr_req: data.cr_req,
          qa_req: data.qa_req,
          // read back with cr_req, or the constructor skips the body parse
diff --git a/shared/index.ts b/shared/index.ts
index 70fd57be..6836b71f 100644
--- a/shared/index.ts
+++ b/shared/index.ts
@@ -12,6 +12,7 @@
  */
 export {
    derive,
+   reviewPolicy,
    ciVerdict,
    ciFailing,
    headStatuses,
diff --git a/test/api.test.js b/test/api.test.js
index 24a76b68..f2a3f5cc 100644
--- a/test/api.test.js
+++ b/test/api.test.js
@@ -153,6 +153,7 @@ test('serves the board classified server-side (/pulls)', async () => {
    assert.equal(rec.signoffs.cr.req, 2);
    assert.equal(rec.signoffs.cr.have, 0);
    assert.equal(rec.url, 'https://github.com/test/repo-a/pull/42');
+   assert.deepEqual(rec.review, { own: true, asked_of: [], asked_at: null });
    assert.equal(rec.is_bot, false); // bob isn't a configured bot
    const botRec = body.pulls.find(p => p.id === 'test/repo-a#43');
    assert.equal(botRec.is_bot, true); // fixture-bot is, via config.js bots
diff --git a/test/base-merge.test.js b/test/base-merge.test.js
new file mode 100644
index 00000000..b5732eb2
--- /dev/null
+++ b/test/base-merge.test.js
@@ -0,0 +1,35 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { isBaseMerge, stampSurvivesBaseMerges } from '../lib/base-merge.js';
+
+const commit = (message, parents, date = '2026-10-02T00:00:00Z') => ({
+   parents: parents.map(sha => ({ sha })),
+   commit: { message, committer: { date } },
+});
+
+test('recognises git and GitHub merges of the base into the branch', () => {
+   for (const message of [
+      "Merge branch 'master' into foo",
+      "Merge branch 'master' of github.com:iFixit/ifixit into foo",
+      "Merge remote-tracking branch 'origin/master' into foo",
+      "Merge branch 'master' into foo\n\n# Conflicts:\n#\tapp.js",
+   ]) {
+      assert.ok(isBaseMerge(commit(message, ['a', 'b']), 'master'), message);
+   }
+   assert.ok(isBaseMerge(commit("Merge branch 'main' into foo", ['a', 'b']), 'main'));
+});
+
+test('other merges and plain commits are not base merges', () => {
+   assert.ok(!isBaseMerge(commit("Merge branch 'master' into foo", ['a']), 'master'));
+   assert.ok(!isBaseMerge(commit("Merge branch 'other' into foo", ['a', 'b']), 'master'));
+   assert.ok(!isBaseMerge(commit("Merge branch 'master2' into foo", ['a', 'b']), 'master'));
+   assert.ok(!isBaseMerge(commit('Fix the thing', ['a', 'b']), 'master'));
+});
+
+test('a stamp survives only when every later commit is a base merge', () => {
+   const stamp = new Date('2026-10-01T00:00:00Z');
+   const before = commit('Work', ['a'], '2026-09-30T00:00:00Z');
+   const merge = commit("Merge branch 'master' into foo", ['a', 'b']);
+   assert.ok(stampSurvivesBaseMerges(stamp, [before, merge, merge], 'master'));
+   assert.ok(!stampSurvivesBaseMerges(stamp, [before, merge, commit('More', ['c'])], 'master'));
+});
diff --git a/test/git-manager-refresh.test.js b/test/git-manager-refresh.test.js
index 8a81979f..e79fb91d 100644
--- a/test/git-manager-refresh.test.js
+++ b/test/git-manager-refresh.test.js
@@ -1,6 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import gitManager from "../lib/git-manager.js";
+import { rememberHints } from "../lib/input-hints.js";
 
 // Stand in for api.github.com: each route answers by path (and, for GraphQL,
 // by query), and every call made is recorded as "METHOD /path".
@@ -72,6 +73,7 @@ function parseRoutes(checkRuns) {
       }),
     ],
     [/\/pulls\/3\/reviews$/, () => ({ body: [] })],
+    [/\/pulls\/3\/files$/, () => ({ body: [] })],
   ];
 }
 
@@ -270,3 +272,65 @@ test("getPullsToCompare reads both lists in one call, then only the one with mor
     },
   ]);
 });
+
+// A CR stamp from before the head commit (10:00): kept when only base merges
+// came after it, dropped when real work did.
+function stampRoutes(commits, files = [], stamped = true) {
+  const routes = parseRoutes(() => ({ body: { total_count: 0, check_runs: [] } }));
+  // first match wins, so these shadow parseRoutes' empty ones
+  routes.unshift(
+    [/\/pulls\/3\/commits$/, () => ({ body: commits })],
+    [/\/pulls\/3\/files$/, () => ({ body: files.map((filename) => ({ filename })) })],
+    [
+      /\/issues\/3\/comments$/,
+      () => ({
+        body: stamped
+          ? [{ id: 1, body: "CR :+1:", user: { login: "rev" }, created_at: "2026-09-20T09:00:00Z" }]
+          : [],
+      }),
+    ]
+  );
+  return routes;
+}
+const gitCommit = (message, parents, date) => ({
+  parents: parents.map((sha) => ({ sha })),
+  commit: { message, committer: { date } },
+});
+
+test("parse keeps a stamp across a base merge and drops it after real work", async (t) => {
+  const merge = gitCommit("Merge branch 'master' into f", ["a", "b"], "2026-09-20T10:00:00Z");
+  const work = gitCommit("Fix", ["a"], "2026-09-20T09:30:00Z");
+  fakeGithub(t, stampRoutes([merge]));
+  let pull = await gitManager.parse(githubPull());
+  assert.equal(pull.signatures[0].data.active, true);
+
+  t.mock.restoreAll();
+  fakeGithub(t, stampRoutes([merge, work]));
+  pull = await gitManager.parse(githubPull());
+  assert.equal(pull.signatures[0].data.active, false);
+});
+
+test("parse only lists commits when a stamp predates the head", async (t) => {
+  const calls = fakeGithub(t, stampRoutes([], [], false));
+  await gitManager.parse(githubPull());
+  assert.ok(!calls.some((c) => c.endsWith("/pulls/3/commits")));
+});
+
+test("parse reads input hints from the changed files once per head", async (t) => {
+  rememberHints("test/repo-a", 3, "older", []); // earlier tests left hints for abc
+  const calls = fakeGithub(t, stampRoutes([], ["db/migrations/1.sql"]));
+  const gh = { ...githubPull(), head: { ...githubPull().head, sha: "abc" } };
+  const first = await gitManager.parse(gh);
+  assert.deepEqual(first.toObject().input_hints, ["migrations"]);
+  await gitManager.parse(githubPull());
+  assert.equal(calls.filter((c) => c.endsWith("/pulls/3/files")).length, 1);
+});
+
+test("parse saves the slugs of requested teams", async (t) => {
+  fakeGithub(t, stampRoutes([]));
+  const pull = await gitManager.parse({
+    ...githubPull(),
+    requested_teams: [{ slug: "store-front", name: "Store Front" }],
+  });
+  assert.deepEqual(pull.toObject().requested_teams, ["store-front"]);
+});
diff --git a/test/input-hints.test.js b/test/input-hints.test.js
new file mode 100644
index 00000000..28280767
--- /dev/null
+++ b/test/input-hints.test.js
@@ -0,0 +1,56 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { inputHints, rememberHints, recalledHints } from '../lib/input-hints.js';
+
+test('names each area once, in a fixed order', () => {
+   assert.deepEqual(
+      inputHints([
+         'package.json',
+         'apps/web/package.json',
+         '.claude/skills/x/SKILL.md',
+         'Migrations/0001.sql',
+         '.github/workflows/ci.yml',
+      ]),
+      ['ci', 'migrations', 'agent-docs', 'dependencies']
+   );
+});
+
+test('each area matches its paths', () => {
+   const cases = {
+      ci: ['.circleci/config.yml', 'Jenkinsfile', 'lefthook-local.yml', '.buildkite/p.yml'],
+      migrations: ['db/migrations/1.php', 'migrations/schema.sql', 'x/y.sql'],
+      alerting: ['ops/alerts/db.yml', 'grafana/dash.json', 'lib/sentry.js', 'Prometheus.yml'],
+      'agent-docs': ['AGENTS.md', 'a/b/CLAUDE.md', '.agents/x.md', '.cursor/r', '.codex/c'],
+      deploy: [
+         'Dockerfile',
+         'Dockerfile.dev',
+         'docker-compose.yml',
+         'deploy/x',
+         'Capfile',
+         'config/deploy.rb',
+         'main.tf',
+         'helm/c.yaml',
+         'k8s/d.yaml',
+      ],
+      dependencies: [
+         'pnpm-lock.yaml',
+         'composer.lock',
+         'go.mod',
+         'requirements-dev.txt',
+         'pyproject.toml',
+      ],
+   };
+   for (const [hint, paths] of Object.entries(cases)) {
+      for (const path of paths) assert.deepEqual(inputHints([path]), [hint], path);
+   }
+});
+
+test('ordinary files get no hint', () => {
+   assert.deepEqual(inputHints(['src/app.js', 'README.md', 'docs/package-notes.md']), []);
+});
+
+test('remembered hints are recalled only for the same head', () => {
+   rememberHints('o/r', 1, 'abc', ['ci']);
+   assert.deepEqual(recalledHints('o/r', 1, 'abc'), ['ci']);
+   assert.equal(recalledHints('o/r', 1, 'def'), null);
+});
diff --git a/test/stats.test.js b/test/stats.test.js
index 933d480c..046ca5d2 100644
--- a/test/stats.test.js
+++ b/test/stats.test.js
@@ -5,7 +5,9 @@ import assert from "node:assert/strict";
 // importing lib/db.js (transitively, via controllers/stats.js) doesn't blow
 // up at module-load time. Nothing here actually queries the DB — only the
 // pure reducer functions below are exercised.
+const db = (await import("../lib/db.js")).default;
 const {
+  queryFirstCrLatencies,
   firstCrByMonth,
   median,
   formatDate,
@@ -61,3 +63,14 @@ test("firstCrByMonth groups per-pull latencies into sorted monthly avg+median ro
 test("firstCrByMonth returns an empty array for no rows", () => {
   assert.deepEqual(firstCrByMonth([]), []);
 });
+
+test("first-review latency ignores the author's own CR stamp", async (t) => {
+  let sql;
+  t.mock.method(db, "query", async (q) => {
+    sql = q;
+    return [];
+  });
+  await queryFirstCrLatencies();
+  assert.match(sql, /s\.user <> o\.owner/);
+  assert.match(sql, /JOIN pulls o ON o\.repo = s\.repo AND o\.number = s\.number/);
+});

From 7ae41c892c9ee7f14699a473158a6b980b0a3e2b Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:13:59 -0700
Subject: [PATCH 03/17] Rework Stats for self-review

With authors stamping their own PRs, "time to first CR" drops to about
zero and review debt counts work nobody owes.

The Stats tab now shows the time to answer a review request (median
and slowest 10%, in hours), who's waiting on someone (open requests by
hours, outside contributors' PRs by days), and how merged PRs were
reviewed: asked, by someone else, self-reviewed, or not stamped, with
a rough count of reverts and quick follow-up fixes after self-reviewed
merges. Open PRs by author and repo say "in self-review" and "waiting
on others"; stamps per day count only stamps on other people's PRs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/stats.test.ts           | 224 ++++++++++-----
 frontend-v2/src/model/stats.ts                | 264 ++++++++++++------
 frontend-v2/src/views/Stats.tsx               |  28 +-
 .../src/views/stats/AuthorLoadCard.tsx        |  14 +-
 frontend-v2/src/views/stats/DebtCard.tsx      |  51 ----
 frontend-v2/src/views/stats/RepoLoadCard.tsx  |  10 +-
 .../src/views/stats/SelfReviewCard.tsx        |  48 ++++
 .../src/views/stats/ShippingPulseCard.tsx     |  27 +-
 .../src/views/stats/StarvationCard.tsx        |  56 ----
 frontend-v2/src/views/stats/WaitingCard.tsx   |  75 +++++
 10 files changed, 499 insertions(+), 298 deletions(-)
 delete mode 100644 frontend-v2/src/views/stats/DebtCard.tsx
 create mode 100644 frontend-v2/src/views/stats/SelfReviewCard.tsx
 delete mode 100644 frontend-v2/src/views/stats/StarvationCard.tsx
 create mode 100644 frontend-v2/src/views/stats/WaitingCard.tsx

diff --git a/frontend-v2/src/model/stats.test.ts b/frontend-v2/src/model/stats.test.ts
index c0bb980a..c4e1cd64 100644
--- a/frontend-v2/src/model/stats.test.ts
+++ b/frontend-v2/src/model/stats.test.ts
@@ -4,18 +4,18 @@ import type { DerivedPull, Status, Weight } from '../../../shared/model/status';
 import {
    ageMix,
    authorLoad,
-   crStarvation,
    effortMix,
-   firstCrLatency,
    friction,
    humanHours,
    mergedPerDay,
    mergeTimeBySize,
    reciprocity,
    repoBreakdown,
-   reviewDebt,
+   requestAnswerTimes,
+   selfReviewMix,
    signoffLeaders,
    stampsPerDay,
+   waitingOnSomeone,
 } from './stats';
 
 function sig(login: string) {
@@ -78,22 +78,6 @@ describe('signoffLeaders', () => {
    });
 });
 
-describe('crStarvation', () => {
-   it('sums open-days by author over CR-incomplete PRs, tracking the worst', () => {
-      const pulls = [
-         open({ author: 'alice', status: 'needs_cr', ageDays: 10, n: 1 }),
-         open({ author: 'alice', status: 'needs_recr', ageDays: 4, n: 2 }),
-         open({ author: 'bob', status: 'needs_cr', ageDays: 20, n: 3 }),
-         open({ author: 'carol', status: 'ready', ageDays: 99, n: 4 }), // not starving
-      ];
-      const s = crStarvation(pulls);
-      expect(s.map(x => x.login)).toEqual(['bob', 'alice']); // bob 20 > alice 14
-      const alice = s.find(x => x.login === 'alice')!;
-      expect(alice).toMatchObject({ count: 2, totalDays: 14, worstDays: 10 });
-      expect(s.find(x => x.login === 'carol')).toBeUndefined();
-   });
-});
-
 describe('mergeTimeBySize', () => {
    it('buckets merged PRs by weight and reports count and medians, skipping unsized', () => {
       const closed = [
@@ -154,6 +138,12 @@ function full(over: {
    recrBy?: string[];
    reqaBy?: string[];
    qaing?: string | null;
+   ownReview?: boolean;
+   title?: string;
+   body?: string;
+   requested?: string[];
+   requests?: { login: string; at: number | null; self: boolean }[];
+   reviews?: { login: string; date: number }[];
    conflict?: boolean;
    deployBlockedBy?: string[];
    devBlockedBy?: string[];
@@ -171,6 +161,7 @@ function full(over: {
       recrBy: over.recrBy ?? [],
       reqaBy: over.reqaBy ?? [],
       qaingLogin: over.qaing ?? null,
+      ownReview: over.ownReview ?? true,
       conflict: over.conflict ?? false,
       deployBlockedBy: over.deployBlockedBy ?? [],
       devBlockedBy: over.devBlockedBy ?? [],
@@ -179,6 +170,10 @@ function full(over: {
       data: {
          repo: over.repo ?? 'iFixit/ifixit',
          number: over.n ?? 1,
+         title: over.title ?? 't',
+         body: over.body ?? '',
+         requested_reviewers: over.requested ?? [],
+         review_requests: over.requests ?? [],
          additions: over.additions === undefined ? 100 : over.additions,
          deletions: over.deletions === undefined ? 20 : over.deletions,
          user: { login: over.author ?? 'alice' },
@@ -187,6 +182,7 @@ function full(over: {
             qa_req: over.qaReq ?? 1,
             allCR: over.allCR ?? [],
             allQA: over.allQA ?? [],
+            unstamped_reviewers: over.reviews ?? [],
          },
       },
    } as unknown as DerivedPull;
@@ -218,12 +214,20 @@ describe('stampsPerDay', () => {
          }),
       ];
       const closed = [
-         { status: { allCR: [sigAt('carol', NOON - 3 * HOUR)], allQA: [] } },
+         {
+            user: { login: 'zed' },
+            status: { allCR: [sigAt('carol', NOON - 3 * HOUR)], allQA: [] },
+         },
       ] as unknown as PullData[];
       const days = stampsPerDay(pulls, closed, 3, NOON);
       expect(days[2].count).toBe(3); // today: bob, dave, carol
       expect(days[1].count).toBe(1); // yesterday: bob's earlier stamp
    });
+
+   it("skips the author's own stamps, which are normal under self-review", () => {
+      const pulls = [full({ author: 'alice', allCR: [sigAt('alice', NOON), sigAt('bob', NOON)] })];
+      expect(stampsPerDay(pulls, [], 1, NOON)[0].count).toBe(1);
+   });
 });
 
 describe('ageMix', () => {
@@ -253,49 +257,119 @@ describe('effortMix', () => {
    });
 });
 
-describe('reviewDebt', () => {
-   it('sums missing stamps, restamps owed, and unclaimed QA', () => {
-      const debt = reviewDebt([
-         full({ status: 'needs_cr', crReq: 2, crHave: 0 }), // 2 CR slots
-         full({ status: 'needs_recr', crReq: 2, crHave: 1, recrBy: ['bob'] }), // 1 slot + 1 restamp
-         full({ status: 'needs_qa', qaReq: 1, qaHave: 0 }), // 1 QA slot, unclaimed
-         full({ status: 'needs_qa', qaReq: 1, qaHave: 0, qaing: 'dave' }), // claimed
-         full({ status: 'needs_qa', qaReq: 1, qaHave: 0, reqaBy: ['eve'] }), // re-QA owed
-         full({ status: 'ready' }), // no debt
-      ]);
-      expect(debt).toEqual({ crSlots: 3, qaSlots: 3, restamps: 2, unclaimedQa: 1 });
+const AT = NOON / 1000; // request time, epoch secs
+const ask = (login: string, hoursAgo: number) => ({ login, at: AT - hoursAgo * 3600, self: false });
+
+describe('requestAnswerTimes', () => {
+   it('measures request to the asked person first stamp or review after it', () => {
+      const pulls = [
+         // bob answers with a stamp 2h after the request, carol with a review 6h after
+         full({
+            n: 1,
+            requests: [ask('bob', 10), ask('carol', 10)],
+            allCR: [sigAt('bob', NOON - 8 * HOUR)],
+            reviews: [{ login: 'carol', date: AT - 4 * 3600 }],
+         }),
+         // dave's only stamp predates his request, erin never answered, a claim is no request
+         full({
+            n: 2,
+            requests: [ask('dave', 5), ask('erin', 5), { ...ask('fay', 5), self: true }],
+            allCR: [sigAt('dave', NOON - 9 * HOUR), sigAt('fay', NOON - HOUR)],
+         }),
+      ];
+      const t = requestAnswerTimes(pulls, []);
+      expect(t.sampled).toBe(2);
+      expect(t.medianHours).toBe(4);
+      expect(t.p90Hours).toBe(6);
+   });
+
+   it('is empty without requests', () => {
+      expect(requestAnswerTimes([full({})], [])).toEqual({
+         medianHours: 0,
+         p90Hours: 0,
+         sampled: 0,
+      });
    });
 });
 
-describe('firstCrLatency', () => {
-   it('measures created→first CR on merged pulls only', () => {
-      const closed = [
-         {
-            merged_at: new Date(NOON).toISOString(),
-            created_at: new Date(NOON - 10 * HOUR).toISOString(),
-            status: {
-               allCR: [sigAt('bob', NOON - 6 * HOUR), sigAt('carol', NOON - 2 * HOUR)],
-               allQA: [],
-            },
-         }, // first CR after 4h
-         {
-            merged_at: new Date(NOON).toISOString(),
-            created_at: new Date(NOON - 10 * HOUR).toISOString(),
-            status: { allCR: [sigAt('bob', NOON - 4 * HOUR)], allQA: [] },
-         }, // 6h
-         {
-            merged_at: null,
-            created_at: new Date(NOON - 10 * HOUR).toISOString(),
-            status: { allCR: [sigAt('bob', NOON)], allQA: [] },
-         }, // unmerged, ignored
-      ] as unknown as PullData[];
-      const lat = firstCrLatency(closed);
-      expect(lat.sampled).toBe(2);
-      expect(lat.medianHours).toBe(5);
-      expect(lat.avgHours).toBe(5);
+describe('waitingOnSomeone', () => {
+   it('lists unanswered requests by hours and outside pulls by days, never self-review', () => {
+      const w = waitingOnSomeone(
+         [
+            full({ n: 1, requests: [ask('bob', 30), ask('carol', 2)], allCR: [] }),
+            full({
+               n: 2,
+               requests: [ask('dave', 4)],
+               allCR: [sigAt('dave', NOON - HOUR)], // answered
+            }),
+            full({ n: 3, ownReview: false, ageDays: 6, author: 'zed' }), // outside, unasked
+            full({ n: 4, ownReview: false, ageDays: 9, requested: ['bob'] }), // asked: not outside
+            full({ n: 5, ageDays: 20 }), // own review: nobody owes it
+            full({ n: 6, ownReview: false, ageDays: 1, status: 'ready' }), // not short of CR
+         ],
+         AT
+      );
+      expect(w.requests.map(r => [r.number, r.login, r.hours])).toEqual([
+         [1, 'bob', 30],
+         [1, 'carol', 2],
+      ]);
+      expect(w.outside).toEqual([
+         { repo: 'iFixit/ifixit', number: 3, title: 't', author: 'zed', days: 6 },
+      ]);
    });
 });
 
+function mergedPull(over: {
+   n: number;
+   author?: string;
+   title?: string;
+   body?: string;
+   at?: number;
+   cr?: string[];
+   reviewers?: string[];
+   teams?: string[];
+}): PullData {
+   return {
+      repo: 'iFixit/ifixit',
+      number: over.n,
+      title: over.title ?? 'Add a thing',
+      body: over.body ?? '',
+      merged_at: new Date(over.at ?? NOON).toISOString(),
+      user: { login: over.author ?? 'alice' },
+      requested_teams: over.teams ?? [],
+      requested_reviewers: over.reviewers ?? [],
+      review_requests: [],
+      status: { allCR: (over.cr ?? []).map(l => sigAt(l, NOON)), allQA: [] },
+   } as unknown as PullData;
+}
+
+describe('selfReviewMix', () => {
+   it('sorts merged pulls into asked, reviewed by others, self-reviewed, and unstamped', () => {
+      const mix = selfReviewMix([
+         mergedPull({ n: 1, reviewers: ['bob'], cr: ['alice'] }), // asked wins
+         mergedPull({ n: 2, teams: ['store'] }),
+         mergedPull({ n: 3, cr: ['bob'] }),
+         mergedPull({ n: 4, cr: ['alice'] }),
+         mergedPull({ n: 5, cr: ['alice'] }),
+         mergedPull({ n: 6 }),
+         { ...mergedPull({ n: 7 }), merged_at: null } as unknown as PullData, // closed unmerged
+      ]);
+      expect(mix).toMatchObject({ merged: 6, asked: 2, byOthers: 1, self: 2, unstamped: 1 });
+   });
+
+   it('flags reverts and fix-ups of a self-reviewed pull within a week', () => {
+      const mix = selfReviewMix([
+         mergedPull({ n: 10, cr: ['alice'], at: NOON - 2 * 86_400_000 }), // self-reviewed
+         mergedPull({ n: 11, title: 'Revert "Add a thing"', body: 'Reverts #10', at: NOON }),
+         mergedPull({ n: 12, body: 'Fixes #10', at: NOON }),
+         mergedPull({ n: 13, body: 'Fixes #99', at: NOON }), // not on the board
+         mergedPull({ n: 14, title: 'Revert the thing', at: NOON }), // revert, no known source
+         mergedPull({ n: 15, cr: ['alice'], at: NOON - 20 * 86_400_000 }),
+         mergedPull({ n: 16, body: 'Fixes #15', at: NOON }), // 20 days later: not close
+      ]);
+      expect(mix.risk).toEqual({ reverts: 2, afterSelfReview: 2 });
+   });
+});
 describe('reciprocity', () => {
    it('pairs distinct PRs reviewed against stamps received, ignoring self-stamps', () => {
       const pulls = [
@@ -316,26 +390,44 @@ describe('reciprocity', () => {
 });
 
 describe('authorLoad', () => {
-   it('counts open PRs per author with their oldest and awaiting-CR share', () => {
+   it('splits pulls short of CR into self-review and waiting on others', () => {
       const rows = authorLoad([
-         full({ author: 'alice', n: 1, ageDays: 3, status: 'needs_cr' }),
+         full({ author: 'alice', n: 1, ageDays: 3, status: 'needs_cr' }), // own review
          full({ author: 'alice', n: 2, ageDays: 9, status: 'ready' }),
-         full({ author: 'bob', n: 3, ageDays: 1, status: 'needs_recr' }),
+         full({ author: 'bob', n: 3, ageDays: 1, status: 'needs_recr', ownReview: false }),
       ]);
-      expect(rows[0]).toEqual({ login: 'alice', count: 2, awaitingCr: 1, oldestDays: 9 });
-      expect(rows[1]).toEqual({ login: 'bob', count: 1, awaitingCr: 1, oldestDays: 1 });
+      expect(rows[0]).toEqual({
+         login: 'alice',
+         count: 2,
+         inSelfReview: 1,
+         waitingOnOthers: 0,
+         oldestDays: 9,
+      });
+      expect(rows[1]).toEqual({
+         login: 'bob',
+         count: 1,
+         inSelfReview: 0,
+         waitingOnOthers: 1,
+         oldestDays: 1,
+      });
    });
 });
 
 describe('repoBreakdown', () => {
-   it('splits each repo pile into total, awaiting-CR, and oldest', () => {
+   it('splits each repo pile into total, self-review, waiting on others, and oldest', () => {
       const rows = repoBreakdown([
          full({ repo: 'iFixit/a', status: 'needs_cr', ageDays: 5 }),
          full({ repo: 'iFixit/a', status: 'ready', ageDays: 2 }),
-         full({ repo: 'iFixit/b', status: 'needs_recr', ageDays: 1 }),
+         full({ repo: 'iFixit/b', status: 'needs_recr', ageDays: 1, ownReview: false }),
       ]);
-      expect(rows[0]).toEqual({ repo: 'iFixit/a', count: 2, awaitingCr: 1, oldestDays: 5 });
-      expect(rows[1]).toEqual({ repo: 'iFixit/b', count: 1, awaitingCr: 1, oldestDays: 1 });
+      expect(rows[0]).toEqual({
+         repo: 'iFixit/a',
+         count: 2,
+         inSelfReview: 1,
+         waitingOnOthers: 0,
+         oldestDays: 5,
+      });
+      expect(rows[1]).toMatchObject({ repo: 'iFixit/b', inSelfReview: 0, waitingOnOthers: 1 });
    });
 });
 
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index 54fbd2ba..a63e7e85 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -65,38 +65,6 @@ export function signoffLeaders(
       .sort((a, b) => b.count - a.count || a.login.localeCompare(b.login));
 }
 
-export interface Starved {
-   login: string;
-   /** their open PRs still short of full CR */
-   count: number;
-   /** summed open-days across those PRs (the waiting they're carrying) */
-   totalDays: number;
-   /** the single longest-waiting one */
-   worstDays: number;
-}
-
-/**
- * Whose authored PRs are waiting longest for CR. A pull counts while it's
- * CR-incomplete (needs_cr or needs_recr); the author is ranked by the total
- * open-days their unreviewed PRs have piled up, with the worst single wait
- * alongside so one ancient PR and ten fresh ones read differently.
- */
-export function crStarvation(pulls: DerivedPull[]): Starved[] {
-   const by = new Map<string, { count: number; totalDays: number; worstDays: number }>();
-   for (const p of pulls) {
-      if (!CR_INCOMPLETE.includes(p.status)) continue;
-      const login = p.data.user.login;
-      const cur = by.get(login) ?? { count: 0, totalDays: 0, worstDays: 0 };
-      cur.count += 1;
-      cur.totalDays += p.ageDays;
-      cur.worstDays = Math.max(cur.worstDays, p.ageDays);
-      by.set(login, cur);
-   }
-   return [...by.entries()]
-      .map(([login, v]) => ({ login, ...v }))
-      .sort((a, b) => b.totalDays - a.totalDays || b.worstDays - a.worstDays);
-}
-
 export interface MergeBucket {
    weight: Weight;
    count: number;
@@ -181,8 +149,9 @@ export function mergedPerDay(closed: PullData[], days: number, now: number): Day
 
 /**
  * CR+QA stamps landed per local day — the board's review pulse. Counts every
- * signature (a re-stamp is new review work), across open pulls and the closed
- * window, so a day reads "how much reviewing happened", not "how much survived".
+ * signature (a re-stamp is new review work) on someone else's pull, across open
+ * pulls and the closed window; an author's own stamp is normal under
+ * self-review and says nothing about reviewing.
  */
 export function stampsPerDay(
    pulls: DerivedPull[],
@@ -193,6 +162,7 @@ export function stampsPerDay(
    const buckets = dayBuckets(days, now);
    const add = (d: PullData) => {
       for (const s of [...d.status.allCR, ...d.status.allQA]) {
+         if (s.data.user.login === d.user.login) continue;
          const t = Date.parse(String(s.data.created_at));
          if (Number.isFinite(t)) bump(buckets, t);
       }
@@ -238,64 +208,172 @@ export function effortMix(pulls: DerivedPull[]): EffortMix {
    return { buckets: WEIGHT_ORDER.map(weight => ({ weight, count: by.get(weight)! })), estimated };
 }
 
-export interface ReviewDebt {
-   /** CR stamps still needed across CR-incomplete pulls */
-   crSlots: number;
-   /** QA stamps still needed across pulls at the QA gate */
-   qaSlots: number;
-   /** stamps a push invalidated that haven't been refreshed (re-CR + re-QA) */
-   restamps: number;
-   /** needs-QA pulls nobody has claimed or owes a re-QA on */
-   unclaimedQa: number;
+const sec = (iso: unknown) => Date.parse(String(iso)) / 1000;
+
+/** epoch secs of every stamp or GitHub review by `login` on this pull */
+function answersBy(d: PullData, login: string): number[] {
+   const stamps = [...d.status.allCR, ...d.status.allQA]
+      .filter(s => s.data.user.login === login)
+      .map(s => sec(s.data.created_at));
+   const reviews = (d.status.unstamped_reviewers ?? [])
+      .filter(r => r.login === login)
+      .map(r => r.date);
+   return [...stamps, ...reviews].filter(Number.isFinite);
+}
+
+/** requests someone else made of a person, with a known time */
+function openedRequests(d: PullData) {
+   return (d.review_requests ?? []).filter(
+      r => !r.self && r.at != null && r.login !== d.user.login
+   ) as { login: string; at: number }[];
+}
+
+export interface AnswerTime {
+   medianHours: number;
+   p90Hours: number;
+   /** requests with a known time that the asked person answered */
+   sampled: number;
 }
 
 /**
- * What the board is owed, in stamps: the reviewer-hours of standing debt. The
- * restamp count is the cheapest debt to clear — the reviewer already knows
- * the code.
+ * How long a review request takes to get answered: from the request to that
+ * person's first stamp or GitHub review after it. The policy says hours.
+ * GitHub drops a request once the person reviews, so closed pulls rarely keep
+ * their requests; what's measured is every request still on the wire, open
+ * pulls and the closed window alike. A person's comment that isn't a stamp
+ * or a review isn't on the board, so it doesn't count as an answer.
  */
-export function reviewDebt(pulls: DerivedPull[]): ReviewDebt {
-   const debt = { crSlots: 0, qaSlots: 0, restamps: 0, unclaimedQa: 0 };
-   for (const p of pulls) {
-      if (CR_INCOMPLETE.includes(p.status))
-         debt.crSlots += Math.max(p.data.status.cr_req - p.crHave, 0);
-      if (p.status === 'needs_qa') {
-         debt.qaSlots += Math.max(p.data.status.qa_req - p.qaHave, 0);
-         if (!p.qaingLogin && !p.reqaBy.length) debt.unclaimedQa += 1;
+export function requestAnswerTimes(pulls: DerivedPull[], closed: PullData[]): AnswerTime {
+   const hours: number[] = [];
+   for (const d of [...pulls.map(p => p.data), ...closed]) {
+      for (const r of openedRequests(d)) {
+         const first = Math.min(...answersBy(d, r.login).filter(t => t >= r.at));
+         if (Number.isFinite(first)) hours.push((first - r.at) / 3600);
       }
-      debt.restamps += p.recrBy.length + p.reqaBy.length;
    }
-   return debt;
+   return { medianHours: median(hours), p90Hours: percentile(hours, 0.9), sampled: hours.length };
 }
 
-export interface Latency {
-   medianHours: number;
-   avgHours: number;
-   /** merged pulls that had a first CR stamp with a usable timestamp */
-   sampled: number;
+function percentile(xs: number[], q: number): number {
+   if (!xs.length) return 0;
+   const s = [...xs].sort((a, b) => a - b);
+   return s[Math.min(s.length - 1, Math.ceil(q * s.length) - 1)];
+}
+
+export interface PullRef {
+   repo: string;
+   number: number;
+   title: string;
+}
+
+export interface OpenRequest extends PullRef {
+   /** who was asked */
+   login: string;
+   hours: number;
+}
+
+export interface OutsideWait extends PullRef {
+   author: string;
+   days: number;
+}
+
+export interface WaitingOnSomeone {
+   /** open requests nobody has answered yet, longest first */
+   requests: OpenRequest[];
+   /** pulls from outside the dev team waiting on a first review, oldest first */
+   outside: OutsideWait[];
 }
 
 /**
- * How long a merged PR waited for its FIRST CR — the responsiveness number,
- * distinct from time-to-merge (which includes the author's own iteration).
+ * What's waiting on a person who isn't the author: review requests with no
+ * answer yet (hours since the request) and pulls from outside the dev team
+ * that nobody was asked to review (days open). An author's own review of their
+ * own pull is not waiting on anyone, so it never shows here.
  */
-export function firstCrLatency(closed: PullData[]): Latency {
-   const hours: number[] = [];
-   for (const d of closed) {
-      if (!d.merged_at || !d.status.allCR.length) continue;
-      const first = Math.min(
-         ...d.status.allCR.map(s => Date.parse(String(s.data.created_at)) || Infinity)
-      );
-      const h = (first - Date.parse(d.created_at)) / 3_600_000;
-      if (Number.isFinite(h) && h > 0) hours.push(h);
+export function waitingOnSomeone(pulls: DerivedPull[], now: number): WaitingOnSomeone {
+   const requests: OpenRequest[] = [];
+   const outside: OutsideWait[] = [];
+   for (const p of pulls) {
+      const d = p.data;
+      const ref = { repo: d.repo, number: d.number, title: d.title };
+      for (const r of openedRequests(d)) {
+         if (answersBy(d, r.login).some(t => t >= r.at)) continue;
+         requests.push({ ...ref, login: r.login, hours: Math.max(0, (now - r.at) / 3600) });
+      }
+      const asked = (d.requested_reviewers ?? []).length || (d.requested_teams ?? []).length;
+      if (!p.ownReview && !asked && CR_INCOMPLETE.includes(p.status))
+         outside.push({ ...ref, author: d.user.login, days: p.ageDays });
    }
    return {
-      medianHours: median(hours),
-      avgHours: hours.length ? hours.reduce((a, b) => a + b, 0) / hours.length : 0,
-      sampled: hours.length,
+      requests: requests.sort((a, b) => b.hours - a.hours),
+      outside: outside.sort((a, b) => b.days - a.days),
    };
 }
 
+export interface SelfReviewMix {
+   /** merged in the window */
+   merged: number;
+   /** a request was on record (person or team) */
+   asked: number;
+   /** no request on record, but someone other than the author stamped or reviewed */
+   byOthers: number;
+   /** only the author's own stamp */
+   self: number;
+   /** merged with no stamp or review at all */
+   unstamped: number;
+   /** rough risk signal over the self-reviewed merges */
+   risk: { reverts: number; afterSelfReview: number };
+}
+
+const REF = /\b(?:fix(?:e[sd])?|revert(?:s|ed)?)\s+(?:[\w.-]+\/[\w.-]+)?#(\d+)/gi;
+const WEEK_SECS = 7 * 86400;
+
+/**
+ * Of the pulls merged in the window, who reviewed them: asked for a review,
+ * someone else stamped it unasked, or the author alone. GitHub clears a
+ * request once it's answered, so "asked" undercounts: an answered request
+ * lands in "reviewed by someone else". The risk signal is rough on purpose:
+ * titles that start with "Revert", and any merge that says "Fixes #n" or
+ * "Reverts #n" of a self-reviewed pull in the same repo merged up to a week
+ * before it. It sees only what the title and description say.
+ */
+export function selfReviewMix(closed: PullData[]): SelfReviewMix {
+   const mergedAt = (d: PullData) => sec(d.merged_at);
+   const mix = { merged: 0, asked: 0, byOthers: 0, self: 0, unstamped: 0 };
+   const selfMerged = new Map<string, number>();
+   const mergedPulls = closed.filter(d => d.merged_at);
+   for (const d of mergedPulls) {
+      mix.merged += 1;
+      const author = d.user.login;
+      const asked =
+         (d.requested_teams ?? []).length ||
+         (d.requested_reviewers ?? []).length ||
+         (d.review_requests ?? []).some(r => !r.self);
+      const stampers = [...d.status.allCR, ...d.status.allQA].map(s => s.data.user.login);
+      const reviewers = (d.status.unstamped_reviewers ?? []).map(r => r.login);
+      const others = [...stampers, ...reviewers].some(l => l !== author);
+      if (asked) mix.asked += 1;
+      else if (others) mix.byOthers += 1;
+      else if (stampers.includes(author)) {
+         mix.self += 1;
+         selfMerged.set(`${d.repo}#${d.number}`, mergedAt(d));
+      } else mix.unstamped += 1;
+   }
+   let reverts = 0;
+   let afterSelfReview = 0;
+   for (const d of mergedPulls) {
+      const isRevert = /^revert\b/i.test(d.title);
+      if (isRevert) reverts += 1;
+      const text = `${d.title}\n${d.body ?? ''}`;
+      const hitsSelf = [...text.matchAll(REF)].some(m => {
+         const at = selfMerged.get(`${d.repo}#${m[1]}`);
+         return at != null && mergedAt(d) >= at && mergedAt(d) - at <= WEEK_SECS;
+      });
+      if (hitsSelf) afterSelfReview += 1;
+   }
+   return { ...mix, risk: { reverts, afterSelfReview } };
+}
+
 export interface Reciprocity {
    login: string;
    /** distinct PRs this person stamped (CR or QA) for someone else */
@@ -336,21 +414,37 @@ export function reciprocity(pulls: DerivedPull[], closed: PullData[]): Reciproci
       );
 }
 
+interface Load {
+   count: number;
+   inSelfReview: number;
+   waitingOnOthers: number;
+   oldestDays: number;
+}
+const emptyLoad = (): Load => ({ count: 0, inSelfReview: 0, waitingOnOthers: 0, oldestDays: 0 });
+/** a pull short of CR is the author's own to review, or waits on someone else */
+function countReview(load: Load, p: DerivedPull) {
+   if (!CR_INCOMPLETE.includes(p.status)) return;
+   if (p.ownReview) load.inSelfReview += 1;
+   else load.waitingOnOthers += 1;
+}
+
 export interface AuthorLoad {
    login: string;
    count: number;
-   /** how many of those still need CR (the reviewer-facing share) */
-   awaitingCr: number;
+   /** needing review, and the author's own to do under self-review */
+   inSelfReview: number;
+   /** needing review from someone who was asked, or from outside the dev team */
+   waitingOnOthers: number;
    oldestDays: number;
 }
 
 /** who has the most open PRs on the board (work-in-progress load). */
 export function authorLoad(pulls: DerivedPull[]): AuthorLoad[] {
-   const by = new Map<string, { count: number; awaitingCr: number; oldestDays: number }>();
+   const by = new Map<string, Load>();
    for (const p of pulls) {
-      const cur = by.get(p.data.user.login) ?? { count: 0, awaitingCr: 0, oldestDays: 0 };
+      const cur = by.get(p.data.user.login) ?? emptyLoad();
       cur.count += 1;
-      if (CR_INCOMPLETE.includes(p.status)) cur.awaitingCr += 1;
+      countReview(cur, p);
       cur.oldestDays = Math.max(cur.oldestDays, p.ageDays);
       by.set(p.data.user.login, cur);
    }
@@ -365,18 +459,18 @@ export function authorLoad(pulls: DerivedPull[]): AuthorLoad[] {
 export interface RepoLoad {
    repo: string;
    count: number;
-   /** how many of those still need CR (the reviewer-facing share) */
-   awaitingCr: number;
+   inSelfReview: number;
+   waitingOnOthers: number;
    oldestDays: number;
 }
 
 /** where the open PRs live, and how much of each repo's pile is review work. */
 export function repoBreakdown(pulls: DerivedPull[]): RepoLoad[] {
-   const by = new Map<string, { count: number; awaitingCr: number; oldestDays: number }>();
+   const by = new Map<string, Load>();
    for (const p of pulls) {
-      const cur = by.get(p.data.repo) ?? { count: 0, awaitingCr: 0, oldestDays: 0 };
+      const cur = by.get(p.data.repo) ?? emptyLoad();
       cur.count += 1;
-      if (CR_INCOMPLETE.includes(p.status)) cur.awaitingCr += 1;
+      countReview(cur, p);
       cur.oldestDays = Math.max(cur.oldestDays, p.ageDays);
       by.set(p.data.repo, cur);
    }
diff --git a/frontend-v2/src/views/Stats.tsx b/frontend-v2/src/views/Stats.tsx
index dbd8090f..60771497 100644
--- a/frontend-v2/src/views/Stats.tsx
+++ b/frontend-v2/src/views/Stats.tsx
@@ -3,18 +3,18 @@ import type { DerivedPull } from '../../../shared/model/status';
 import {
    ageMix,
    authorLoad,
-   crStarvation,
    effortMix,
-   firstCrLatency,
    friction,
    mergedPerDay,
    mergeTimeBySize,
    reciprocity,
+   requestAnswerTimes,
    repoBreakdown,
-   reviewDebt,
+   selfReviewMix,
    signoffLeaders,
    stampsPerDay,
    statusBreakdown,
+   waitingOnSomeone,
 } from '../model/stats';
 import { fillMonthGaps, useStatsHistory, weeklyTimeInReview } from '../model/statsHistory';
 import { ageRotDays as deriveAgeRotDays, useSettings } from '../settings';
@@ -22,7 +22,6 @@ import type { PullData } from '../../../shared/types';
 import { EmptyState, STATUS_DOT, STATUS_LABEL } from '../components/bits';
 import { AgeMixCard } from './stats/AgeMixCard';
 import { AuthorLoadCard } from './stats/AuthorLoadCard';
-import { DebtCard } from './stats/DebtCard';
 import { EffortMixCard } from './stats/EffortMixCard';
 import { FrictionCard } from './stats/FrictionCard';
 import { Leaderboard } from './stats/Leaderboard';
@@ -30,10 +29,11 @@ import { MergeSizeCard } from './stats/MergeSizeCard';
 import { MonthlyThroughputCard } from './stats/MonthlyThroughputCard';
 import { ReciprocityCard } from './stats/ReciprocityCard';
 import { RepoLoadCard } from './stats/RepoLoadCard';
+import { SelfReviewCard } from './stats/SelfReviewCard';
 import { ShippingPulseCard } from './stats/ShippingPulseCard';
-import { StarvationCard } from './stats/StarvationCard';
 import { StatusBar } from './stats/StatusBar';
 import { TimeInReviewCard } from './stats/TimeInReviewCard';
+import { WaitingCard } from './stats/WaitingCard';
 
 const WINDOW_DAYS = 14;
 
@@ -85,14 +85,15 @@ export function Stats({
    );
    // flow — the closed window plus stamp timestamps
    const perDay = useMemo(() => mergedPerDay(closed, WINDOW_DAYS, Date.now()), [closed]);
-   const firstCr = useMemo(() => firstCrLatency(closed), [closed]);
+   const answer = useMemo(() => requestAnswerTimes(pulls, closed), [pulls, closed]);
+   const selfMix = useMemo(() => selfReviewMix(closed), [closed]);
    const pulse = useMemo(
       () => stampsPerDay(pulls, closed, WINDOW_DAYS, Date.now()),
       [pulls, closed]
    );
    const merge = useMemo(() => mergeTimeBySize(closed), [closed]);
    // the board right now
-   const debt = useMemo(() => reviewDebt(pulls), [pulls]);
+   const waiting = useMemo(() => waitingOnSomeone(pulls, Date.now() / 1000), [pulls]);
    const ages = useMemo(() => ageMix(pulls), [pulls]);
    const effort = useMemo(() => effortMix(pulls), [pulls]);
    const stuck = useMemo(() => friction(pulls), [pulls]);
@@ -102,7 +103,6 @@ export function Stats({
    const crLeaders = useMemo(() => signoffLeaders(pulls, closed, 'CR'), [pulls, closed]);
    const qaLeaders = useMemo(() => signoffLeaders(pulls, closed, 'QA'), [pulls, closed]);
    const giveTake = useMemo(() => reciprocity(pulls, closed), [pulls, closed]);
-   const starved = useMemo(() => crStarvation(pulls), [pulls]);
    const settings = useSettings();
    // the heaviest text tier follows the warn threshold automatically, same
    // derivation as app.tsx's rowOpts — see ageWarnDays in settings.ts
@@ -138,7 +138,7 @@ export function Stats({
       <div className="flex flex-col gap-6">
          <StatusBar items={breakdown} total={pulls.length} />
          <Group title="The board right now">
-            <DebtCard debt={debt} />
+            <WaitingCard waiting={waiting} me={me} onPerson={onPerson} />
             <FrictionCard friction={stuck} />
             <AgeMixCard buckets={ages} warnDays={settings.ageWarnDays} rotDays={ageRotDays} />
             <EffortMixCard mix={effort} />
@@ -146,17 +146,11 @@ export function Stats({
             <RepoLoadCard rows={repos} />
          </Group>
          <Group title="Flow · last 14 days">
-            <ShippingPulseCard perDay={perDay} pulse={pulse} firstCr={firstCr} />
+            <ShippingPulseCard perDay={perDay} pulse={pulse} answer={answer} />
+            <SelfReviewCard mix={selfMix} />
             <MergeSizeCard buckets={merge.buckets} sampled={merge.sampled} merged={merge.merged} />
          </Group>
          <Group title="People">
-            <StarvationCard
-               rows={starved}
-               me={me}
-               onPerson={onPerson}
-               warnDays={settings.ageWarnDays}
-               rotDays={ageRotDays}
-            />
             <ReciprocityCard rows={giveTake} me={me} onPerson={onPerson} />
             <Leaderboard
                title="CR leaderboard"
diff --git a/frontend-v2/src/views/stats/AuthorLoadCard.tsx b/frontend-v2/src/views/stats/AuthorLoadCard.tsx
index bbb3713b..4835e391 100644
--- a/frontend-v2/src/views/stats/AuthorLoadCard.tsx
+++ b/frontend-v2/src/views/stats/AuthorLoadCard.tsx
@@ -3,7 +3,7 @@ import { PersonCell, SplitBarRow, StatsCard } from './parts';
 
 /**
  * Who's carrying the most open PRs. The bar splits into the author's whole
- * pile and the amber share of it still awaiting CR, so a big-but-moving
+ * pile and the amber share of it waiting on someone else's review, so a big-but-moving
  * author reads differently from one whose PRs are all stuck waiting.
  */
 export function AuthorLoadCard({
@@ -21,22 +21,26 @@ export function AuthorLoadCard({
    const max = Math.max(...rows.map(r => r.count), 1);
    const more = rows.length - shown.length;
    return (
-      <StatsCard title="Open PRs by author" sub="total · awaiting CR · oldest">
+      <StatsCard
+         title="Open PRs by author"
+         sub="total · in self-review · waiting on others · oldest"
+      >
          <div className="mt-3 flex flex-col gap-2">
             {shown.map(r => (
                <SplitBarRow
                   key={r.login}
                   pct={(r.count / max) * 100}
-                  splitPct={r.count > 0 ? (r.awaitingCr / r.count) * 100 : 0}
+                  splitPct={r.count > 0 ? (r.waitingOnOthers / r.count) * 100 : 0}
                   color="var(--slate)"
                   splitColor="var(--warn)"
-                  title={`${r.login}: ${r.count} open, ${r.awaitingCr} awaiting CR, oldest ${r.oldestDays}d`}
+                  title={`${r.login}: ${r.count} open, ${r.inSelfReview} in self-review, ${r.waitingOnOthers} waiting on others, oldest ${r.oldestDays}d`}
                   lead={<PersonCell login={r.login} me={me} onPerson={onPerson} />}
                   trail={
                      <span className="flex-none text-right text-ink-2 tabular-nums">
                         {r.count}
                         <span className="ml-1 text-ink-3">
-                           · {r.awaitingCr} CR · oldest {r.oldestDays}d
+                           · {r.inSelfReview} self · {r.waitingOnOthers} waiting · oldest{' '}
+                           {r.oldestDays}d
                         </span>
                      </span>
                   }
diff --git a/frontend-v2/src/views/stats/DebtCard.tsx b/frontend-v2/src/views/stats/DebtCard.tsx
deleted file mode 100644
index 10c131cc..00000000
--- a/frontend-v2/src/views/stats/DebtCard.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { ReviewDebt } from '../../model/stats';
-import { MiniMeter, StatsCard } from './parts';
-
-/**
- * The board's standing review debt, in stamps. Re-stamps get the amber tint
- * when nonzero: they're the cheapest debt on the board (the reviewer already
- * knows the code) and the most commonly forgotten. Each number carries a thin
- * meter scaled to the card's shared max, so relative size is glanceable
- * without reading four digits and doing the comparison in your head.
- */
-export function DebtCard({ debt }: { debt: ReviewDebt }) {
-   const max = Math.max(debt.crSlots, debt.qaSlots, debt.restamps, debt.unclaimedQa, 1);
-   const cell = (value: number, label: string, hint: string, hot?: boolean) => (
-      <div title={hint}>
-         <div
-            className="text-xl font-semibold tabular-nums"
-            style={{ color: value === 0 ? 'var(--ink-3)' : hot ? 'var(--warn)' : 'var(--ink)' }}
-         >
-            {value}
-         </div>
-         <div className="text-xs text-ink-3">{label}</div>
-         <MiniMeter
-            pct={(value / max) * 100}
-            color={value === 0 ? 'var(--secondary)' : hot ? 'var(--warn)' : 'var(--ink-3)'}
-         />
-      </div>
-   );
-   return (
-      <StatsCard title="Review debt" sub="stamps the board is owed right now">
-         <div className="mt-3 grid grid-cols-2 gap-x-4 gap-y-3">
-            {cell(
-               debt.crSlots,
-               'CR stamps needed',
-               'CR sign-offs still missing across CR-incomplete PRs'
-            )}
-            {cell(
-               debt.qaSlots,
-               'QA stamps needed',
-               'QA sign-offs still missing across PRs at the QA gate'
-            )}
-            {cell(
-               debt.restamps,
-               're-stamps owed',
-               'stamps a push invalidated; the reviewer already knows the code',
-               true
-            )}
-            {cell(debt.unclaimedQa, 'QA unclaimed', 'needs-QA PRs nobody has picked up')}
-         </div>
-      </StatsCard>
-   );
-}
diff --git a/frontend-v2/src/views/stats/RepoLoadCard.tsx b/frontend-v2/src/views/stats/RepoLoadCard.tsx
index e47fe638..672c904f 100644
--- a/frontend-v2/src/views/stats/RepoLoadCard.tsx
+++ b/frontend-v2/src/views/stats/RepoLoadCard.tsx
@@ -4,21 +4,21 @@ import { SplitBarRow, StatsCard } from './parts';
 
 /**
  * Where the open PRs live. The bar splits into the repo's whole pile and the
- * amber share of it still awaiting CR — the reviewer-facing debt, not just
- * the total count — plus the oldest age trailing.
+ * amber share of it waiting on someone else's review (self-reviews aren't
+ * debt to anyone) — plus the oldest age trailing.
  */
 export function RepoLoadCard({ rows, cap = 10 }: { rows: RepoLoad[]; cap?: number }) {
    const shown = rows.slice(0, cap);
    const max = Math.max(...rows.map(r => r.count), 1);
    const more = rows.length - shown.length;
    return (
-      <StatsCard title="Open PRs by repo" sub="count · awaiting CR · oldest">
+      <StatsCard title="Open PRs by repo" sub="count · in self-review · waiting on others · oldest">
          <div className="mt-3 flex flex-col gap-2">
             {shown.map(r => (
                <SplitBarRow
                   key={r.repo}
                   pct={(r.count / max) * 100}
-                  splitPct={r.count > 0 ? (r.awaitingCr / r.count) * 100 : 0}
+                  splitPct={r.count > 0 ? (r.waitingOnOthers / r.count) * 100 : 0}
                   color="var(--ink-3)"
                   splitColor="var(--warn)"
                   title={r.repo}
@@ -31,7 +31,7 @@ export function RepoLoadCard({ rows, cap = 10 }: { rows: RepoLoad[]; cap?: numbe
                      <span className="flex-none text-right text-ink-2 tabular-nums">
                         {r.count}
                         <span className="ml-1 text-ink-3">
-                           · {r.awaitingCr} CR · {r.oldestDays}d
+                           · {r.inSelfReview} self · {r.waitingOnOthers} waiting · {r.oldestDays}d
                         </span>
                      </span>
                   }
diff --git a/frontend-v2/src/views/stats/SelfReviewCard.tsx b/frontend-v2/src/views/stats/SelfReviewCard.tsx
new file mode 100644
index 00000000..2810ab1b
--- /dev/null
+++ b/frontend-v2/src/views/stats/SelfReviewCard.tsx
@@ -0,0 +1,48 @@
+import type { SelfReviewMix } from '../../model/stats';
+import { BarRow, StatsCard } from './parts';
+
+/**
+ * How the pulls merged in the window were reviewed. The risk line is a rough
+ * signal: it only sees what titles and descriptions say.
+ */
+export function SelfReviewCard({ mix }: { mix: SelfReviewMix }) {
+   const rows = [
+      { label: 'Self-reviewed', n: mix.self, color: 'var(--ink-3)' },
+      { label: 'Asked for review', n: mix.asked, color: 'var(--brand)' },
+      { label: 'Reviewed by someone else', n: mix.byOthers, color: 'var(--ok)' },
+      { label: 'No stamp', n: mix.unstamped, color: 'var(--secondary)' },
+   ];
+   return (
+      <StatsCard title="Self-reviewed vs asked" sub="merged, last 14 days">
+         {mix.merged === 0 ? (
+            <div className="mt-3 text-[13px] text-ink-3">Nothing merged in this window.</div>
+         ) : (
+            <div className="mt-3 flex flex-col gap-2">
+               {rows.map(r => (
+                  <BarRow
+                     key={r.label}
+                     pct={(r.n / mix.merged) * 100}
+                     color={r.color}
+                     lead={<span className="w-44 flex-none truncate text-ink">{r.label}</span>}
+                     trail={
+                        <span className="flex-none text-right text-ink-2 tabular-nums">
+                           {r.n}
+                           <span className="ml-1 text-ink-3">
+                              · {Math.round((r.n / mix.merged) * 100)}%
+                           </span>
+                        </span>
+                     }
+                  />
+               ))}
+               <div
+                  className="mt-1 text-xs text-ink-3"
+                  title="Reverts by title, and merges saying Fixes or Reverts of a self-reviewed pull merged up to a week earlier"
+               >
+                  Rough signal: {mix.risk.reverts} {mix.risk.reverts === 1 ? 'revert' : 'reverts'},{' '}
+                  {mix.risk.afterSelfReview} fix-up or revert of a self-reviewed pull within a week
+               </div>
+            </div>
+         )}
+      </StatsCard>
+   );
+}
diff --git a/frontend-v2/src/views/stats/ShippingPulseCard.tsx b/frontend-v2/src/views/stats/ShippingPulseCard.tsx
index 7614d5a1..d7193a9b 100644
--- a/frontend-v2/src/views/stats/ShippingPulseCard.tsx
+++ b/frontend-v2/src/views/stats/ShippingPulseCard.tsx
@@ -1,22 +1,21 @@
-import { humanHours, type DayCount, type Latency } from '../../model/stats';
+import { humanHours, type DayCount, type AnswerTime } from '../../model/stats';
 import { type AxisTick, LineChart, StatsCard } from './parts';
 
 /**
  * Volume vs. speed, one panel: merges per day (bars, left axis) against
  * CR+QA stamps per day (line, right axis) — the Shipping and Review-pulse
  * cards fused, since "how much shipped" only means something next to "how
- * much reviewing happened" the same days. First-CR median rides along as the
- * responsiveness number time-to-merge (which includes the author's own
- * iteration) hides.
+ * much reviewing happened" the same days. Time to answer a review request rides
+ * along as the responsiveness number: requests are answered in hours.
  */
 export function ShippingPulseCard({
    perDay,
    pulse,
-   firstCr,
+   answer,
 }: {
    perDay: DayCount[];
    pulse: DayCount[];
-   firstCr: Latency;
+   answer: AnswerTime;
 }) {
    const total = perDay.reduce((a, d) => a + d.count, 0);
    const half = Math.floor(perDay.length / 2);
@@ -95,15 +94,17 @@ export function ShippingPulseCard({
                   </span>
                )}
             </span>
-            {firstCr.sampled > 0 && (
-               <span
-                  title={`avg ${humanHours(firstCr.avgHours)} · ${firstCr.sampled} merged PRs with a CR`}
-               >
-                  first CR in{' '}
+            {answer.sampled > 0 && (
+               <span title={`${answer.sampled} review requests answered`}>
+                  requests answered in{' '}
                   <b className="font-semibold text-ink tabular-nums">
-                     {humanHours(firstCr.medianHours)}
+                     {humanHours(answer.medianHours)}
                   </b>{' '}
-                  median
+                  median,{' '}
+                  <b className="font-semibold text-ink tabular-nums">
+                     {humanHours(answer.p90Hours)}
+                  </b>{' '}
+                  p90
                </span>
             )}
          </div>
diff --git a/frontend-v2/src/views/stats/StarvationCard.tsx b/frontend-v2/src/views/stats/StarvationCard.tsx
deleted file mode 100644
index ed41620f..00000000
--- a/frontend-v2/src/views/stats/StarvationCard.tsx
+++ /dev/null
@@ -1,56 +0,0 @@
-import { BarRow, PersonCell, StatsCard } from './parts';
-
-export function StarvationCard({
-   rows,
-   me,
-   onPerson,
-   warnDays,
-   rotDays,
-   cap = 10,
-}: {
-   rows: { login: string; count: number; totalDays: number; worstDays: number }[]; // sorted desc by totalDays
-   me?: string;
-   onPerson?: (login: string) => void;
-   /** worstDays >= warnDays => amber heat; >= rotDays => red heat */
-   warnDays: number;
-   rotDays: number;
-   cap?: number;
-}) {
-   const shown = rows.slice(0, cap);
-   const max = rows[0]?.totalDays ?? 0;
-
-   return (
-      <StatsCard
-         title="Waiting longest for CR"
-         sub="by author · total open-days their PRs sit unreviewed"
-      >
-         {shown.length === 0 ? (
-            <div className="mt-3 text-[13px] text-ink-3">Nothing has been waiting long for CR.</div>
-         ) : (
-            <div className="mt-3 flex flex-col gap-2">
-               {shown.map(row => {
-                  const heat =
-                     row.worstDays >= rotDays
-                        ? 'var(--bad)'
-                        : row.worstDays >= warnDays
-                          ? 'var(--warn)'
-                          : 'var(--ink-3)';
-                  return (
-                     <BarRow
-                        key={row.login}
-                        pct={max > 0 ? (row.totalDays / max) * 100 : 0}
-                        color={heat}
-                        lead={<PersonCell login={row.login} me={me} onPerson={onPerson} />}
-                        trail={
-                           <span className="flex-none text-right text-ink-3 tabular-nums">
-                              {row.count} {row.count === 1 ? 'PR' : 'PRs'} · worst {row.worstDays}d
-                           </span>
-                        }
-                     />
-                  );
-               })}
-            </div>
-         )}
-      </StatsCard>
-   );
-}
diff --git a/frontend-v2/src/views/stats/WaitingCard.tsx b/frontend-v2/src/views/stats/WaitingCard.tsx
new file mode 100644
index 00000000..844dd870
--- /dev/null
+++ b/frontend-v2/src/views/stats/WaitingCard.tsx
@@ -0,0 +1,75 @@
+import { shortRepo } from '../../../../shared/format';
+import { humanHours, type PullRef, type WaitingOnSomeone } from '../../model/stats';
+import { PersonCell, StatsCard } from './parts';
+
+const link = (p: PullRef) => (
+   <a
+      className="min-w-0 flex-1 truncate text-ink hover:underline"
+      href={`https://github.com/${p.repo}/pull/${p.number}`}
+      target="_blank"
+      rel="noreferrer"
+      title={p.title}
+   >
+      {shortRepo(p.repo)}#{p.number} {p.title}
+   </a>
+);
+
+/**
+ * Review owed to a person other than the author: requests nobody has
+ * answered (hours, the policy's clock) and pulls from outside the dev team
+ * (days). An author's own review of their own pull is not waiting on anyone.
+ */
+export function WaitingCard({
+   waiting,
+   me,
+   onPerson,
+   cap = 6,
+}: {
+   waiting: WaitingOnSomeone;
+   me?: string;
+   onPerson?: (login: string) => void;
+   cap?: number;
+}) {
+   const { requests, outside } = waiting;
+   const empty = !requests.length && !outside.length;
+   return (
+      <StatsCard title="Waiting on someone" sub="review requests and outside pulls">
+         {empty ? (
+            <div className="mt-3 text-[13px] text-ink-3">Nobody is waiting on a review.</div>
+         ) : (
+            <div className="mt-3 flex flex-col gap-1.5 text-[13px]">
+               {requests.slice(0, cap).map(r => (
+                  <div
+                     key={`${r.repo}#${r.number}@${r.login}`}
+                     className="flex items-baseline gap-2"
+                  >
+                     {link(r)}
+                     <PersonCell login={r.login} me={me} onPerson={onPerson} />
+                     <span className="flex-none text-ink-3 tabular-nums">
+                        {humanHours(r.hours)}
+                     </span>
+                  </div>
+               ))}
+               {requests.length > cap && (
+                  <div className="text-ink-3">+{requests.length - cap} more requests</div>
+               )}
+               {outside.length > 0 && (
+                  <div className="mt-2 text-xs font-semibold text-ink-3">
+                     From outside the dev team
+                  </div>
+               )}
+               {outside.slice(0, cap).map(o => (
+                  <div key={`${o.repo}#${o.number}`} className="flex items-baseline gap-2">
+                     {link(o)}
+                     <span className="flex-none text-ink-3">{o.author}</span>
+                     <span className="flex-none text-ink-3 tabular-nums">{o.days}d</span>
+                  </div>
+               ))}
+               {outside.length > cap && (
+                  <div className="text-ink-3">+{outside.length - cap} more pulls</div>
+               )}
+            </div>
+         )}
+      </StatsCard>
+   );
+}

From c47c2f61a7819ccecc684d0fa9f53ba203035f3c Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:31:11 -0700
Subject: [PATCH 04/17] Never count a bot as a developer

A bot's PR still needs someone else's review, but derive() only knew
the [bot] suffix, so with no roster configured a config-listed bot
like ifixit-systems counted as reviewing its own. The review policy now
carries config.bots, on the board and the server.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/status.test.ts | 16 ++++++++++++++++
 frontend-v2/src/store.ts             |  2 +-
 lib/review-model.js                  |  2 +-
 shared/model/status.ts               | 17 +++++++++++++----
 4 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index 1d8cddbb..6fd57d2f 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -472,6 +472,22 @@ describe('the self-review policy', () => {
       expect(d.ownReview).toBe(false);
       expect(isDeveloper(OUTSIDER, 'R')).toBe(true);
    });
+
+   it('a bot is never a developer, by suffix or by config', () => {
+      const policy = reviewPolicy(undefined, ['ifixit-systems']);
+      expect(isDeveloper(policy, 'dependabot[bot]')).toBe(false);
+      expect(isDeveloper(policy, 'iFixit-Systems')).toBe(false);
+      expect(isDeveloper(policy, 'someone')).toBe(true);
+      const d = derive(
+         pull({ user: { login: 'ifixit-systems' } }),
+         undefined,
+         NOW,
+         undefined,
+         undefined,
+         policy
+      );
+      expect(d.ownReview).toBe(false);
+   });
 });
 
 describe('starvation and weight', () => {
diff --git a/frontend-v2/src/store.ts b/frontend-v2/src/store.ts
index c48d98d6..fd639fd1 100644
--- a/frontend-v2/src/store.ts
+++ b/frontend-v2/src/store.ts
@@ -327,7 +327,7 @@ function start() {
          repoSpecs = payload.repos;
          // server-owned config rides with the board (see shared/types)
          weightLabels = parseWeightLabels(payload.weightLabels);
-         policy = reviewPolicy(payload.developerTeams);
+         policy = reviewPolicy(payload.developerTeams, payload.bots);
          extraBots = new Set(payload.bots ?? []);
          projectLabelPrefix = payload.projectLabelPrefix || null;
          firstBuild ??= payload.build;
diff --git a/lib/review-model.js b/lib/review-model.js
index d5197ce3..158ef0e4 100644
--- a/lib/review-model.js
+++ b/lib/review-model.js
@@ -41,7 +41,7 @@ export function toWire(pull) {
 export const developerTeams = () =>
    savedSetting('developer_teams') ?? config.projects?.developerTeams;
 
-const currentPolicy = () => reviewPolicy(developerTeams());
+const currentPolicy = () => reviewPolicy(developerTeams(), config.bots || []);
 
 /**
  * Derive one Pull into its DerivedPull (status bucket, CI verdict, weight,
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 5c780309..157c41c0 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -266,11 +266,17 @@ export interface ReviewPolicy {
    /** roster team name, lowercased and slugged like GitHub's ("Store
     * Front" -> "store-front"), to its logins */
    teams: ReadonlyMap<string, string[]>;
+   /** config `bots` beyond the `[bot]` suffix: never developers, so their
+    * PRs still need someone else's review */
+   bots: ReadonlySet<string>;
 }
 
 const slug = (name: string) => name.trim().toLowerCase().replace(/\s+/g, '-');
 
-export function reviewPolicy(developerTeams?: Record<string, string[]> | null): ReviewPolicy {
+export function reviewPolicy(
+   developerTeams?: Record<string, string[]> | null,
+   bots: readonly string[] = []
+): ReviewPolicy {
    const teams = new Map<string, string[]>();
    const developers = new Set<string>();
    for (const [name, logins] of Object.entries(developerTeams ?? {})) {
@@ -278,13 +284,16 @@ export function reviewPolicy(developerTeams?: Record<string, string[]> | null):
       teams.set(slug(name), logins);
       logins.forEach(l => developers.add(l.toLowerCase()));
    }
-   return { developers, teams };
+   return { developers, teams, bots: new Set(bots.map(b => b.toLowerCase())) };
 }
 
-const EVERYONE_DEVELOPS: ReviewPolicy = { developers: new Set(), teams: new Map() };
+const EVERYONE_DEVELOPS: ReviewPolicy = reviewPolicy();
 
+/** a bot never reviews its own PRs, whatever the roster says */
 export const isDeveloper = (policy: ReviewPolicy, login: string) =>
-   !policy.developers.size || policy.developers.has(login.toLowerCase());
+   !isSuffixBot(login) &&
+   !policy.bots.has(login.toLowerCase()) &&
+   (!policy.developers.size || policy.developers.has(login.toLowerCase()));
 
 export function derive(
    pull: PullData,

From b85cd66f1f200a5f5629f0a6d18c5650b605d791 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:31:12 -0700
Subject: [PATCH 05/17] Rework the board's review flow for self-review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Developers review their own PRs unless they ask, so the board stops
treating every unstamped PR as someone else's job.

1) Nothing assigns review: the rotation, "your turn" alerts and cheers,
   and "Return the favor" are gone.
2) The review queue and Needs QA hold only PRs that asked you (by name
   or team), ones you said you'd review, and PRs from outside the dev
   team or bots. Requests lead Waiting on you, oldest first, with
   "asked 3h ago"; a new request sends a desktop alert.
3) Your own PRs say what you owe: Stamp CR, Stamp QA, Re-stamp, or
   "waiting on bob · asked 3h ago", turning into "Nudge bob" after 4
   hours. "Find a QA-er", "Nudge for a review" and "in the CR queue"
   are gone, and so is the "Getting QA is a to-do" setting.
4) Claim reads "I'll review" and "Drop it".
5) New: "Could use your input", a closed-by-default fold of other
   people's self-reviews in your code regions or repos you review,
   with no counts; and a quiet "worth asking for review?" hint on your
   PRs that touch CI, migrations, alerting, agent docs, deploy config
   or dependencies.
6) Words across Review, My work, Team, CI, Classic, Projects stages,
   cheers and PR jail now match the policy, and "is:asked" finds
   requests of you.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/app.tsx                       |  47 +-
 frontend-v2/src/components/JailMode.test.tsx  |  42 +-
 frontend-v2/src/components/JailMode.tsx       |  42 +-
 frontend-v2/src/components/Legend.tsx         |  14 +-
 frontend-v2/src/components/RegionHint.tsx     |   4 +-
 frontend-v2/src/components/Row.tsx            |  91 ++--
 frontend-v2/src/components/Settings.tsx       |  26 +-
 frontend-v2/src/components/StatePopover.tsx   |  71 +--
 frontend-v2/src/components/WordGroups.tsx     |  28 +-
 frontend-v2/src/model/actions.test.ts         | 283 ++++++++----
 frontend-v2/src/model/actions.ts              | 410 +++++++++---------
 frontend-v2/src/model/cheers.test.ts          | 180 ++++----
 frontend-v2/src/model/cheers.ts               | 212 +++------
 frontend-v2/src/model/deal.test.ts            |  21 +-
 frontend-v2/src/model/deal.ts                 |  35 +-
 .../src/model/notificationRelevance.ts        |   8 +-
 frontend-v2/src/model/portfolio.ts            |   2 +-
 frontend-v2/src/model/query.test.ts           |   9 +
 frontend-v2/src/model/query.ts                |   8 +-
 frontend-v2/src/model/reviewLanes.test.ts     | 199 ++++++---
 frontend-v2/src/model/reviewLanes.ts          | 221 +++++-----
 frontend-v2/src/model/reviewers.test.ts       |  34 --
 frontend-v2/src/model/reviewers.ts            |  54 +--
 frontend-v2/src/model/rotation.test.ts        | 112 -----
 frontend-v2/src/model/rotation.ts             |  99 -----
 frontend-v2/src/model/sort.test.ts            |  18 +
 frontend-v2/src/model/sort.ts                 |  18 +-
 frontend-v2/src/model/stage.test.ts           |  52 ++-
 frontend-v2/src/model/stage.ts                |  43 +-
 frontend-v2/src/model/team.test.ts            |  13 +
 frontend-v2/src/model/team.ts                 |  18 +-
 frontend-v2/src/model/toast.ts                |   6 -
 frontend-v2/src/model/updateDraft.test.ts     |   4 +-
 frontend-v2/src/notifications.ts              |  47 +-
 frontend-v2/src/settings.ts                   |  11 +-
 frontend-v2/src/toasts.tsx                    |  77 +---
 frontend-v2/src/views/Ci.tsx                  |  17 +-
 frontend-v2/src/views/MyWork.tsx              |  11 +-
 frontend-v2/src/views/Review.tsx              | 196 +++++----
 frontend-v2/src/views/Team.tsx                |  72 ++-
 frontend-v2/src/views/projects/Portfolio.tsx  |   2 +-
 frontend-v2/src/views/projects/Work.tsx       |   7 +-
 42 files changed, 1314 insertions(+), 1550 deletions(-)
 delete mode 100644 frontend-v2/src/model/reviewers.test.ts
 delete mode 100644 frontend-v2/src/model/rotation.test.ts
 delete mode 100644 frontend-v2/src/model/rotation.ts

diff --git a/frontend-v2/src/app.tsx b/frontend-v2/src/app.tsx
index 0fff1684..338a9eaa 100644
--- a/frontend-v2/src/app.tsx
+++ b/frontend-v2/src/app.tsx
@@ -11,16 +11,15 @@ import {
 } from 'react';
 import { ago, closedEpoch, n, pullKey, shortRepo } from '../../shared/format';
 import type { ActionStateKey } from './model/actions';
-import { actionState } from './model/actions';
+import { actionState, askedOf } from './model/actions';
 import { DEFAULT_RANGE, DEFAULT_SORT, LENS_LABELS, ORIGIN_KEYS, ZOOM_KEY, type Lens } from './lens';
 import type { DerivedPull } from '../../shared/model/status';
 import { matchesWeightFilter } from '../../shared/model/status';
 import { buildParentLookup } from './model/stack';
-import { buildReviewerPools, turnFor } from './model/rotation';
 import { shipRelevance, shippedToast } from './model/shipped';
 import { notificationStale } from './model/notificationRelevance';
 import type { Toast } from './model/toast';
-import { claimReview, isSnoozed, refreshAllText, usePulldasher } from './store';
+import { isSnoozed, refreshAllText, usePulldasher } from './store';
 import { primeScope, useScope } from './prefs';
 import { useBoardHotkeys, useHeaderHeightVar } from './hooks';
 import { ageRotDays, getSettings, type Settings as SettingsShape, useSettings } from './settings';
@@ -28,7 +27,6 @@ import { useNotifications } from './notifications';
 import { ToastStack, useToasts } from './toasts';
 import { requestNames, useNames } from './model/names';
 import { CRYO_KEY, isBotLogin, personHidden, repoHidden } from '../../shared/model/visibility';
-import { reviewRequestedFrom } from './model/reviewers';
 import { CornerBadge, QuietButton, textInputClass } from './components/bits';
 import { foldDomId, openFold } from './components/Lane';
 import { Legend } from './components/Legend';
@@ -300,12 +298,6 @@ export function App() {
       snoozed,
       projectLabelPrefix,
    } = usePulldasher();
-   // per-repo reviewer pools and whose turn each starved, unclaimed pull is —
-   // computed ONCE over the whole board and shared by the rows (rowOpts),
-   // desktop notifications, and the cheers evaluator, so the three surfaces
-   // can never disagree about the rotation (and never re-derive it in
-   // parallel; buildReviewerPools walks every pull's signatures)
-   const pools = useMemo(() => buildReviewerPools(pulls), [pulls]);
    // Publish the widest CR/QA required counts on the board so every row's pip
    // slot pads to them (styles.css .pd-pip-slot-*) and the marks line up in a
    // column. Over ALL open pulls, not the filtered view: simpler, and the
@@ -324,14 +316,6 @@ export function App() {
       root.setProperty('--cr-slots', String(maxCrReq));
       root.setProperty('--qa-slots', String(maxQaReq));
    }, [maxCrReq, maxQaReq]);
-   const turns = useMemo(() => {
-      const m = new Map<string, string>();
-      for (const p of pulls) {
-         const who = turnFor(p, pools, pulls);
-         if (who) m.set(pullKey(p.data), who);
-      }
-      return m;
-   }, [pulls, pools]);
    // resolve every author on the board to a human display name (batched,
    // cached — model/names.ts): the person hover-cards, the people pickers,
    // and name-aware search all read from this one map
@@ -625,7 +609,7 @@ export function App() {
             p.data.draft &&
             p.data.user.login !== me &&
             !revealedAuthor(p.data.user.login) &&
-            !reviewRequestedFrom(p, me);
+            !askedOf(p).includes(me);
          return hidden || cryoHidden || draftHidden;
       },
       [
@@ -700,7 +684,7 @@ export function App() {
    );
    // desktop notifications watch the whole board (minus the standing hidden
    // settings above), not the current filter
-   useNotifications(nudgeablePulls, me, turns, initialized);
+   useNotifications(nudgeablePulls, me, initialized);
 
    // scope + hidden, but deliberately NOT free text: a query drives the global
    // Search lens (App renders <Search> instead of the current lens), so
@@ -840,7 +824,7 @@ export function App() {
       const c = { parked: 0, drafts: 0, hiddenRepos: 0, hiddenPeople: 0, bots: 0, hiddenNow: 0 };
       for (const p of pulls) {
          if (p.cryo) c.parked++;
-         if (p.data.draft && p.data.user.login !== me && !reviewRequestedFrom(p, me)) c.drafts++;
+         if (p.data.draft && p.data.user.login !== me && !askedOf(p).includes(me)) c.drafts++;
          if (repoHidden(p.data.repo, settings.repoPrefs)) c.hiddenRepos++;
          if (
             p.data.user.login !== me &&
@@ -930,8 +914,6 @@ export function App() {
          compact: settings.density === 'compact',
          laneCap: settings.laneCapByLens[lens] ?? settings.laneCap,
          parentOf,
-         pools,
-         turns,
          isBotAuthor,
          onProject,
       }),
@@ -947,8 +929,6 @@ export function App() {
          settings.laneCapByLens,
          lens,
          parentOf,
-         pools,
-         turns,
          isBotAuthor,
          onProject,
       ]
@@ -1047,15 +1027,6 @@ export function App() {
       setLens('review');
       setWeightSel(['XS', 'S']);
    }, []);
-   // the "your turn" toast's Claim button: claim the review straight from the
-   // nudge (which also adds you as a GitHub reviewer, same as any claim)
-   const onClaimTurn = useCallback(
-      (repo: string, number: number) => {
-         const p = pulls.find(x => x.data.repo === repo && x.data.number === number);
-         if (p) claimReview(p.data);
-      },
-      [pulls]
-   );
    // pull keys the viewer snoozed in Review, so cheers skips them the way the
    // Review lane does — a snooze is "not today", not "nudge me anyway"
    const snoozedKeys = useMemo(
@@ -1072,11 +1043,9 @@ export function App() {
    } = useToasts(
       nudgeablePulls,
       me,
-      turns,
       shippedExtras,
       closed,
       onQuickWins,
-      onClaimTurn,
       initialized,
       names,
       snoozedKeys,
@@ -1084,7 +1053,7 @@ export function App() {
    );
 
    // A fired nudge outlives the PR it points at: once that PR merges or closes
-   // it drops off the board, so a bell entry like "return the favor on
+   // it drops off the board, so a bell entry like "review requested on
    // fixbot#3116" is left pointing at a dead link. Drop any panel record whose
    // PR has left the open board -- notificationStale is general across every
    // kind, and exempts the retrospective shipped recap and board-wide rewards.
@@ -1328,11 +1297,11 @@ export function App() {
                   sessionActive={sessionActive}
                   inputProps={{
                      'aria-label':
-                        'Search all PRs, open and closed: text, #number, label:x, status:x, older:5, repo:x, author:x, weight:xs, has:action, is:draft, is:mine, is:restamp, is:blocked, is:bot',
+                        'Search all PRs, open and closed: text, #number, label:x, status:x, older:5, repo:x, author:x, weight:xs, has:action, is:draft, is:mine, is:restamp, is:asked, is:blocked, is:bot',
                      // "/" finds within a view that has its own find box
                      // (hooks.ts), so the hint only shows where "/" comes here
                      placeholder: viewFinds ? 'Search all PRs' : 'Search all PRs (press /)',
-                     title: 'text, #number, label:x, status:x, older:5, repo:x, author:x, weight:xs, has:action, is:draft, is:mine, is:restamp, is:blocked, is:bot',
+                     title: 'text, #number, label:x, status:x, older:5, repo:x, author:x, weight:xs, has:action, is:draft, is:mine, is:restamp, is:asked, is:blocked, is:bot',
                      className: `w-[210px] max-w-full grow pr-2.5 pl-8 sm:grow-0 ${textInputClass}`,
                   }}
                />
diff --git a/frontend-v2/src/components/JailMode.test.tsx b/frontend-v2/src/components/JailMode.test.tsx
index 5e0e5a84..476084a8 100644
--- a/frontend-v2/src/components/JailMode.test.tsx
+++ b/frontend-v2/src/components/JailMode.test.tsx
@@ -12,8 +12,12 @@ import { JailMode } from './JailMode';
 
 let n = 0;
 /** One of my open PRs, run through the real derive; `ready` waives CR and
- * QA so it can merge now, otherwise it waits on CR. */
-const pull = (ageDays = 1, { ready = false } = {}): DerivedPull => {
+ * QA so it can merge now, otherwise it needs CR: my own to stamp (self-review),
+ * or `asked`'s, whom I requested a review from an hour ago. */
+const pull = (
+   ageDays = 1,
+   { ready = false, asked = [] as string[], hints = [] as string[] } = {}
+): DerivedPull => {
    n += 1;
    const at = new Date(Date.now() - ageDays * 86400_000 - 60_000).toISOString();
    const data: PullData = {
@@ -47,6 +51,9 @@ const pull = (ageDays = 1, { ready = false } = {}): DerivedPull => {
       },
       labels: [],
       participants: [],
+      requested_reviewers: asked,
+      review_requests: asked.map(login => ({ login, at: Date.now() / 1000 - 3600, self: false })),
+      input_hints: hints,
    };
    return derive(data, undefined);
 };
@@ -101,7 +108,8 @@ describe('JailMode while the cell is down', () => {
    it('lifts ready PRs to the top and counts them in the why line', () => {
       const ready = pull(2, { ready: true });
       render([...many(7), ready]);
-      expect(headers()).toEqual(['Ready to merge', 'Waiting on others']);
+      // the rest are mine to stamp under self-review
+      expect(headers()).toEqual(['Ready to merge', 'Your move']);
       expect(document.querySelector('[role="dialog"] li a')?.textContent).toContain(
          ready.data.title
       );
@@ -164,20 +172,38 @@ describe('JailMode while the cell is down', () => {
       expect(listed()).toBe(8);
    });
 
-   it('copies a nudge listing the PRs waiting on others', async () => {
+   it('copies a nudge listing only the PRs waiting on people I asked, naming them', async () => {
       const writeText = vi.fn(() => Promise.resolve());
       Object.assign(navigator, { clipboard: { writeText } });
-      const first = pull(3);
-      render([first, ...many(7)]);
+      const first = pull(3, { asked: ['bob'] });
+      const second = pull(2, { asked: ['cy', 'dee'] });
+      render([first, second, ...many(6)]);
+      expect(headers()).toEqual(['Your move', 'Waiting on others']);
       const copy = [...document.querySelectorAll<HTMLButtonElement>('[role="dialog"] button')].find(
          b => b.textContent === 'Copy a nudge'
       );
       await act(async () => copy?.click());
       const text = (writeText.mock.calls[0] as unknown as [string])[0];
-      expect(text.split('\n')).toHaveLength(9);
+      expect(text.split('\n')).toHaveLength(3);
       expect(text).toContain(
-         `• ${first.data.title} https://github.com/iFixit/ifixit/pull/${first.data.number}`
+         `• ${first.data.title} https://github.com/iFixit/ifixit/pull/${first.data.number} (bob)`
       );
+      expect(text).toContain(`(cy, dee)`);
       expect(copy?.textContent).toBe('Copied');
    });
+
+   it('offers no nudge when I asked nobody: a self-review waits on no one', () => {
+      render(many(8));
+      const copy = [...document.querySelectorAll('[role="dialog"] button')].find(
+         b => b.textContent === 'Copy a nudge'
+      );
+      expect(copy).toBeUndefined();
+   });
+
+   it('hints when a self-reviewed PR touches what usually deserves team input', () => {
+      render([pull(1, { hints: ['ci', 'migrations'] }), ...many(7)]);
+      expect(dialog()?.textContent).toContain(
+         'touches CI and migrations · worth asking for review?'
+      );
+   });
 });
diff --git a/frontend-v2/src/components/JailMode.tsx b/frontend-v2/src/components/JailMode.tsx
index 7360958d..22062086 100644
--- a/frontend-v2/src/components/JailMode.tsx
+++ b/frontend-v2/src/components/JailMode.tsx
@@ -3,7 +3,7 @@ import { createPortal } from 'react-dom';
 import { Lock } from 'lucide-react';
 import type { DerivedPull } from '../../../shared/model/status';
 import { githubUrl } from '../../../shared/format';
-import { rowNote, rowWord } from '../model/actions';
+import { askedOf, askForInputHint, rowNote, rowWord } from '../model/actions';
 import { STAGE_WORDS } from '../model/stage';
 import {
    jailCase,
@@ -477,22 +477,21 @@ function useLeaving(pulls: DerivedPull[]): DerivedPull[] {
    return leaving.filter(p => !pulls.some(q => pullId(q) === pullId(p)));
 }
 
-/** Slack-ready text asking for the reviews your waiting PRs need: each
- * title, its link, and who it waits on. */
-function nudgeText(rows: { pull: DerivedPull }[], me: string): string {
+/** Slack-ready text chasing the reviews you asked for: each title, its
+ * link, and who was asked. Only PRs with a request: a self-reviewed PR waits
+ * on nobody, so there's no one to nudge about it. */
+function nudgeText(rows: { pull: DerivedPull }[]): string {
    return [
-      'A few of my PRs are waiting on a review or a stamp:',
-      ...rows.map(({ pull: p }) => {
-         const who = rowNote(p, me).context;
-         return `• ${p.data.title} ${githubUrl(p.data.repo, p.data.number)}${
-            who ? ` (${who})` : ''
-         }`;
-      }),
+      'A few of my PRs are waiting on a review I asked for:',
+      ...rows.map(
+         ({ pull: p }) =>
+            `• ${p.data.title} ${githubUrl(p.data.repo, p.data.number)} (${askedOf(p).join(', ')})`
+      ),
    ].join('\n');
 }
 
 /** Copies nudgeText, and says whether it worked. */
-function CopyNudge({ rows, me }: { rows: { pull: DerivedPull }[]; me: string }) {
+function CopyNudge({ rows }: { rows: { pull: DerivedPull }[] }) {
    const [copied, setCopied] = useState<'copied' | 'failed' | null>(null);
    const done = (result: 'copied' | 'failed') => {
       setCopied(result);
@@ -502,7 +501,7 @@ function CopyNudge({ rows, me }: { rows: { pull: DerivedPull }[]; me: string })
       <QuietButton
          onClick={() => {
             if (!navigator.clipboard) return done('failed');
-            navigator.clipboard.writeText(nudgeText(rows, me)).then(
+            navigator.clipboard.writeText(nudgeText(rows)).then(
                () => done('copied'),
                () => done('failed')
             );
@@ -526,16 +525,21 @@ function JailList({ pulls, me, maxDays }: { pulls: DerivedPull[]; me: string; ma
       ? jailGroups(all, me)
       : { ready: [], move: [], waiting: all.map(pull => ({ pull })) };
    const live = (rows: { pull: DerivedPull }[]) => rows.filter(r => !gone.has(pullId(r.pull)));
+   // the PRs waiting on people you asked, wherever they sit (a request gone
+   // quiet past 4 hours is Your move); the copy button rides on the first
+   // section holding one
+   const asked = (rows: { pull: DerivedPull }[]) => live(rows).filter(r => askedOf(r.pull).length);
+   const nudgeRows = asked([...groups.move, ...groups.waiting]);
    const sections = [
       { title: STAGE_WORDS.ready, sub: 'Merge these first', rows: groups.ready, ready: true },
       { title: 'Your move', sub: 'Waiting on you', rows: groups.move },
       {
          title: 'Waiting on others',
-         sub: 'Nudge them, or close what you don’t need',
+         sub: 'Nudge whoever you asked, or close what you don’t need',
          rows: groups.waiting,
-         nudge: true,
       },
    ].filter(g => g.rows.length);
+   const nudgeOn = sections.find(g => !g.ready && asked(g.rows).length)?.title;
    return (
       <div className="flex flex-col gap-6">
          {sections.map(g => (
@@ -546,11 +550,7 @@ function JailList({ pulls, me, maxDays }: { pulls: DerivedPull[]; me: string; ma
                      title={g.title}
                      sub={g.sub}
                      count={live(g.rows).length}
-                     headerExtra={
-                        g.nudge && live(g.rows).length ? (
-                           <CopyNudge rows={live(g.rows)} me={me} />
-                        ) : undefined
-                     }
+                     headerExtra={g.title === nudgeOn ? <CopyNudge rows={nudgeRows} /> : undefined}
                   />
                )}
                <ul className="m-0 flex list-none flex-col divide-y divide-line p-0">
@@ -597,6 +597,7 @@ function JailRow({
    // stands in when there's no detail
    const move = word?.kind === 'do' ? word.word : null;
    const detail = context ?? (word?.kind === 'wait' ? word.word : null);
+   const hint = mine && !ready ? askForInputHint(p) : null;
    const old = p.ageDays > maxDays;
    return (
       <li
@@ -631,6 +632,7 @@ function JailRow({
             {!ready && <CiGlyph pull={p} />}
             {detail && <span className="min-w-0">{detail}</span>}
          </span>
+         {hint && <span className="text-xs text-ink-3">{hint}</span>}
       </li>
    );
 }
diff --git a/frontend-v2/src/components/Legend.tsx b/frontend-v2/src/components/Legend.tsx
index ef319df2..2a3b0695 100644
--- a/frontend-v2/src/components/Legend.tsx
+++ b/frontend-v2/src/components/Legend.tsx
@@ -147,16 +147,16 @@ export function Legend() {
 
          <Group title="Coordination">
             <Item
-               term={<span className="text-xs font-medium text-brand">Claim</span>}
-               def="hover a row for its verbs. Claiming adds you as a reviewer on the PR, so GitHub and the board both show you’re on it; the row moves to Waiting on you until you submit, release, or are removed"
+               term={<span className="text-ink-2 italic">self-review</span>}
+               def="a developer reviews and tests their own PR unless they ask for a review. Nobody else owes it anything"
             />
             <Item
                term={<span className="text-ink-2 italic">review requested</span>}
-               def="someone requested your review on GitHub. Lands in Waiting on you, and the board quiets its own suggestions for that PR"
+               def="the author asked people (or a team) for a review on GitHub. It leads their Waiting on you; answer within hours"
             />
             <Item
-               term={<span className="text-ink-2 italic">your turn</span>}
-               def="a review that sat too long, pointed at the best-matched reviewer. A nudge, not a lock: anyone can take it"
+               term={<span className="text-xs font-medium text-brand">I’ll review</span>}
+               def="hover a row for its verbs. It adds you as a reviewer on the PR, so GitHub and the board both show you’re on it; the row moves to Waiting on you until you submit, drop it, or are removed"
             />
          </Group>
 
@@ -173,6 +173,10 @@ export function Legend() {
                term={<code className="font-mono text-[11px] text-ink-2">is:restamp</code>}
                def="a push undid your stamp and the PR is reviewable again"
             />
+            <Item
+               term={<code className="font-mono text-[11px] text-ink-2">is:asked</code>}
+               def="someone asked you for a review"
+            />
             <Item
                term={<code className="font-mono text-[11px] text-ink-2">is:blocked</code>}
                def="under a dev or deploy block, whoever holds it"
diff --git a/frontend-v2/src/components/RegionHint.tsx b/frontend-v2/src/components/RegionHint.tsx
index 0a605fc4..40f3c2a2 100644
--- a/frontend-v2/src/components/RegionHint.tsx
+++ b/frontend-v2/src/components/RegionHint.tsx
@@ -30,8 +30,8 @@ export function RegionHint() {
          </span>
          <span className="min-w-0 flex-1">
             Review a particular area? Add <b className="font-semibold">code regions</b> in Settings.
-            A region is plain text matched against a PR’s title, labels, branch, and repo; matches
-            gather in their own section above the queue.
+            A region is plain text matched against a PR’s title, labels, branch, and repo; other
+            people’s self-reviews that match gather under Could use your input.
          </span>
          <button
             type="button"
diff --git a/frontend-v2/src/components/Row.tsx b/frontend-v2/src/components/Row.tsx
index ba5f3cdf..d3ee2f05 100644
--- a/frontend-v2/src/components/Row.tsx
+++ b/frontend-v2/src/components/Row.tsx
@@ -12,11 +12,11 @@ import {
 } from 'lucide-react';
 import type { DerivedPull } from '../../../shared/model/status';
 import { isIterating, lastPushEpoch } from '../../../shared/model/status';
-import { type Claim, rowNote } from '../model/actions';
+import { askForInputHint, type Claim, rowNote } from '../model/actions';
 import { matchedRegions } from '../model/regions';
 import { claimFor } from '../model/reviewers';
 import type { ParentRef } from '../model/stack';
-import { ago, epoch, pullKey, rowDomId, shortRepo } from '../../../shared/format';
+import { ago, epoch, githubUrl, pullKey, rowDomId, shortRepo } from '../../../shared/format';
 import { setRepoPref, toggleHiddenPerson, useSettings } from '../settings';
 import {
    claimReview,
@@ -62,20 +62,13 @@ export interface RowOptions {
     * lens' scope), so the 'stacked' flag can name it instead of just saying
     * "based on <ref>". */
    parentOf?: (p: DerivedPull) => ParentRef | null;
-   /** per-repo reviewer pool for the deterministic turn rotation
-    * (model/rotation.ts), memoized once in app.tsx over the whole board. */
-   pools?: ReadonlyMap<string, string[]>;
-   /** pull key → whose turn it is (the best-fit reviewer for a starved,
-    * unclaimed PR), computed once in app.tsx so the row just looks it up. */
-   turns?: ReadonlyMap<string, string>;
+   /** your own self-reviewed rows say when the diff touches what usually
+    * deserves team input (model/actions.ts askForInputHint): My work sets it */
+   askHint?: boolean;
    /** one plain-words line on why this pull sits where it does in a ranked
     * lane (Review's queue / Needs QA) — rendered in the state popover, never
     * inline on the card. */
    rankReason?: (p: DerivedPull) => string | null;
-   /** the two "In your code regions" lanes (Review, Team) set this true on
-    * their own rows: the lane header already says "this is your region," so
-    * the region mark would be redundant on every card inside it. */
-   hideRegionMark?: boolean;
    /** bot detection for the avatar's square-tile shape (app.tsx's config-fed
     * isBotLogin — the row can't know the config's extra-bots list itself) */
    isBotAuthor?: (login: string) => boolean;
@@ -147,7 +140,9 @@ function rowFlags(
          key: 'deploy-block',
          tone: 'warn',
          label: 'deploy block',
-         detail: `${p.deployBlockedBy.join(', ')} put a deploy block on it; don’t ship without asking.`,
+         detail: `${p.deployBlockedBy.join(
+            ', '
+         )} put a deploy block on it; don’t ship without asking.`,
       });
    if (p.externalBlock)
       flags.push({
@@ -239,7 +234,9 @@ function RowDetails({ flags }: { flags: Flag[] }) {
                {flags.map(f => (
                   <span
                      key={f.key}
-                     className={`whitespace-nowrap ${f.tone === 'warn' ? 'flag-warn' : 'flag-note'}`}
+                     className={`whitespace-nowrap ${
+                        f.tone === 'warn' ? 'flag-warn' : 'flag-note'
+                     }`}
                   >
                      {f.label}
                   </span>
@@ -299,12 +296,12 @@ function useRowActions(pull: DerivedPull) {
 }
 
 /**
- * The row's two workflow buttons — Snooze and Claim — floating left of the
- * data rail (zero standing geometry; the right edge stays the facts').
+ * The row's two workflow buttons — Snooze and "I'll review" — floating left
+ * of the data rail (zero standing geometry; the right edge stays the facts').
  * Each is its own chip with one rule: a button STANDS when it records a
- * choice you made — a claimed row always shows "Release", a snoozed row
- * always shows "Unsnooze", both in place with no hover — and reveals on
- * row hover/focus when it merely OFFERS one ("Claim", "Snooze"). If both
+ * choice you made — a row you said you'd review always shows "Drop it", a
+ * snoozed row always shows "Unsnooze", both in place with no hover — and
+ * reveals on row hover/focus when it merely OFFERS one. If both
  * states are yours, both chips stand. Opacity-only reveal (motion stays
  * reserved for state changes), pointer-events following it so a hidden
  * offer can't steal a click. Touch has no hover: offers live in the kebab
@@ -339,10 +336,10 @@ function VerbDock({
       ? 'wake it: back on your Review tab now'
       : 'snooze: off your Review tab until tomorrow or until it changes';
    const claimWords = mine
-      ? 'release your claim'
+      ? 'drop it: you’re no longer reviewing this'
       : claim
-        ? `claim review, currently ${claim.login}'s`
-        : 'claim this review: adds you as a reviewer on the PR itself, so GitHub and the board both show you’re on it';
+      ? `I’ll review: ${claim.login} said they would too`
+      : 'I’ll review: adds you as a reviewer on the PR itself, so GitHub and the board both show you’re on it';
    return (
       <span className="pd-verbs absolute top-1/2 right-full z-10 mr-1.5 flex -translate-y-1/2 items-center gap-1.5">
          {showSnoozeChip && (
@@ -433,14 +430,12 @@ function RowActionsKebab({
                aria-pressed={claimedByMe}
                title={
                   claimedByMe
-                     ? 'release your claim'
-                     : claim
-                       ? `claim review, currently ${claim.login}'s`
-                       : "claim this review, flags that you're reading it"
+                     ? 'you’re no longer reviewing this'
+                     : 'adds you as a reviewer on the PR itself'
                }
             >
                <Icon icon={Hand} />
-               {claimedByMe ? 'Release claim' : 'Claim review'}
+               {claimedByMe ? 'Drop it' : 'I’ll review'}
             </button>
          )}
          {showSnooze && (
@@ -660,15 +655,12 @@ function RowImpl({
    const d = pull.data;
    const key = pullKey(d);
    const fresh = freshKind(pull, opts);
-   // who's claimed to review this pull, and whose turn the rotation names —
-   // both optional, so a lens that hasn't threaded them (yet) just sees null
-   // and rowNote falls back to its base (pre-coordination) note
+   // who said they'd review this pull
    const claim = claimFor(d);
-   const turn = opts.turns?.get(key) ?? null;
-   const poolSize = opts.pools?.get(d.repo)?.length ?? 0;
    // the viewer-relative note (model/actions.ts): never both-null for an open
    // pull, so the one badge below always has something to say
-   const note = rowNote(pull, opts.me, { claim, turn });
+   const note = rowNote(pull, opts.me, { claim });
+   const askHint = opts.askHint && d.user.login === opts.me ? askForInputHint(pull) : null;
    // the wait badge may itself carry a "last commit …" — don't say it twice
    const showIterating = isIterating(pull) && !(note.context ?? '').includes('last commit');
    // the smallest clean marker for a teammate: a tiny heart over their
@@ -680,7 +672,7 @@ function RowImpl({
    const regions = matchedRegions(pull, settings.codeRegions);
    // only worth asking the whole-board lookup when this row is stacked but
    // rendering flat (its parent isn't visible right above it already)
-   const orphanParent = pull.dependent && depth === 0 ? (opts.parentOf?.(pull) ?? null) : null;
+   const orphanParent = pull.dependent && depth === 0 ? opts.parentOf?.(pull) ?? null : null;
    return (
       <CardShell
          login={d.user.login}
@@ -695,14 +687,18 @@ function RowImpl({
          compact={opts.compact}
          depth={depth}
          stackStub={pull.dependent && depth === 0}
-         className={`${flashOnce(key, !!fresh) ? 'row-fresh' : ''} transition-[background-color] duration-150 ease-out motion-reduce:transition-none`}
+         className={`${
+            flashOnce(key, !!fresh) ? 'row-fresh' : ''
+         } transition-[background-color] duration-150 ease-out motion-reduce:transition-none`}
          avatarBadge={
             // your own rows never wear it: the you-star owns that corner,
             // and a heart-on-yourself would double the glyph
             rosters.length > 0 &&
             d.user.login !== opts.me && (
                <span
-                  title={`on ${rosters.length ? rosters.join(' & ') : 'your team'}: their PRs lead your review queue`}
+                  title={`on ${
+                     rosters.length ? rosters.join(' & ') : 'your team'
+                  }: their PRs lead your review queue`}
                   // seated on a surface-colored disc so the brand heart reads as
                   // a distinct mark instead of muddying into the avatar's colored
                   // face — the visible separation the you-star gets from its
@@ -730,15 +726,13 @@ function RowImpl({
                   pull={pull}
                   me={opts.me}
                   claim={claim}
-                  turn={turn}
-                  poolSize={poolSize}
                   whyHere={opts.rankReason?.(pull) ?? null}
                   onProject={opts.onProject}
                   title="see the full state"
                >
                   <RepoRef repo={d.repo} number={d.number} />
                </StatePopover>
-               {regions.length > 0 && !opts.hideRegionMark && (
+               {regions.length > 0 && (
                   // the brand diamond leads and the matched region is NAMED in
                   // quiet ink beside it — which of your regions hit must read
                   // without a hover (a bare glyph hid it; owner call). No
@@ -756,7 +750,9 @@ function RowImpl({
                         <button
                            {...t}
                            type="button"
-                           aria-label={`in your code ${regions.length > 1 ? 'regions' : 'region'}: ${regions.join(', ')}`}
+                           aria-label={`in your code ${
+                              regions.length > 1 ? 'regions' : 'region'
+                           }: ${regions.join(', ')}`}
                            className={`pressable flex min-w-0 flex-none items-center gap-1 px-0.5 ${railTriggerClass}`}
                         >
                            <span aria-hidden className="text-brand">
@@ -780,6 +776,18 @@ function RowImpl({
                <RowDetails flags={rowFlags(pull, showIterating, depth, orphanParent)} />
                {/* a line of its own, and the last one, even in compact's one
                    flowing line, where the rail comes before it */}
+               {askHint && (
+                  // quiet on purpose: a suggestion, not a debt. It opens the
+                  // PR, where the reviewers picker is
+                  <a
+                     href={githubUrl(d.repo, d.number)}
+                     target="_blank"
+                     rel="noopener noreferrer"
+                     className="pd-raise order-last basis-full text-xs text-ink-3 hover:underline"
+                  >
+                     {askHint}
+                  </a>
+               )}
                {footnote && <span className="order-last basis-full">{footnote}</span>}
             </>
          }
@@ -822,8 +830,7 @@ export const Row = memo(
       a.opts.ageDisplay === b.opts.ageDisplay &&
       a.opts.showSnooze === b.opts.showSnooze &&
       a.opts.parentOf === b.opts.parentOf &&
-      a.opts.pools === b.opts.pools &&
-      a.opts.turns === b.opts.turns &&
+      a.opts.askHint === b.opts.askHint &&
       a.opts.isBotAuthor === b.opts.isBotAuthor &&
       a.opts.onProject === b.opts.onProject &&
       a.opts.noHide === b.opts.noHide &&
diff --git a/frontend-v2/src/components/Settings.tsx b/frontend-v2/src/components/Settings.tsx
index e117aa53..748315fe 100644
--- a/frontend-v2/src/components/Settings.tsx
+++ b/frontend-v2/src/components/Settings.tsx
@@ -54,8 +54,8 @@ function LaneCapByLensRow({ lensId, label }: { lensId: string; label: string })
    );
 }
 
-/** Free-text editor for the code regions that float matching PRs to the top of
- * the review queue. Arbitrary strings (not a known set), so it's a plain input
+/** Free-text editor for the code regions that put matching self-reviews into
+ * Review's Could use your input. Arbitrary strings (not a known set), so it's a plain input
  * plus removable chips, not a candidate picker. */
 function CodeRegionsGroup() {
    const regions = useSettings().codeRegions;
@@ -67,8 +67,8 @@ function CodeRegionsGroup() {
    return (
       <Group title="Code regions">
          <span className="text-xs text-ink-3">
-            Areas you own or care about. A PR whose title, description, labels, branch, or repo
-            contains one floats to the top of your review queue.
+            Areas you own or care about. Someone’s self-reviewed PR whose title, description,
+            labels, branch, or repo contains one shows under Could use your input on Review.
          </span>
          <div className="flex gap-2">
             <input
@@ -397,22 +397,8 @@ export function Settings({
                            </QuietButton>
                         </Field>
                         <Field
-                           label="Getting QA is a to-do"
-                           hint="For teams that self-review, no separate CR gate means lining up QA is the real stall, so “Find a QA-er” on your own PRs shows in Waiting on you. Off keeps it in My work only."
-                        >
-                           <Segmented
-                              ariaLabel="getting QA is a to-do"
-                              value={s.selfReview ? 'on' : 'off'}
-                              options={[
-                                 ['off', 'Off'],
-                                 ['on', 'On'],
-                              ]}
-                              onChange={v => set({ selfReview: v === 'on' })}
-                           />
-                        </Field>
-                        <Field
-                           label="Nudge me about a claim"
-                           hint="When an unfinished claim of yours starts nagging you to finish it or hand it back. Claims themselves don't expire on a timer; they clear when the review is submitted, released, or removed on GitHub."
+                           label="Nudge me about a review I said I’d do"
+                           hint="When a review you said you’d do starts nagging you to finish it or drop it. It doesn't expire on a timer; it clears when the review is submitted, dropped, or you're removed on GitHub."
                         >
                            <Segmented
                               ariaLabel="claim warning time"
diff --git a/frontend-v2/src/components/StatePopover.tsx b/frontend-v2/src/components/StatePopover.tsx
index 4c6f347e..fef03624 100644
--- a/frontend-v2/src/components/StatePopover.tsx
+++ b/frontend-v2/src/components/StatePopover.tsx
@@ -3,7 +3,7 @@ import { headStatuses, type DerivedPull } from '../../../shared/model/status';
 // the small module, so the board's rows don't load the projects model
 import { MISC_SLUG } from '../../../shared/model/projectLabel';
 import type { Claim, RowNote } from '../model/actions';
-import { rowNote } from '../model/actions';
+import { askedAgo, askedOf, rowNote, selfReviewed } from '../model/actions';
 import { projectOfPull, useProjectStanding } from '../model/standing';
 import type { PullData } from '../../../shared/types';
 import { ago, closedEpoch, epoch, githubUrl, issueUrl, signatureUrl } from '../../../shared/format';
@@ -86,22 +86,19 @@ function stateExplanation(pull: DerivedPull, note: RowNote): string {
 }
 
 /** Section 1: what this pull's badge means, restated in a sentence, plus the
- * viewer's own move when they have one. Claim/turn must flow into rowNote
- * here exactly as they do on the row itself — otherwise the popover asserts
- * "your next step: Review it" on a pull someone else has already claimed, flatly
- * contradicting the row's own (rightly silent) do-pill. */
+ * viewer's own move when they have one. The claim flows into rowNote here
+ * exactly as it does on the row itself, so the popover never asserts a next
+ * step the row doesn't. */
 function StateSection({
    pull,
    me,
    claim,
-   turn,
 }: {
    pull: DerivedPull;
    me: string;
    claim?: Claim | null;
-   turn?: string | null;
 }) {
-   const note = rowNote(pull, me, { claim, turn });
+   const note = rowNote(pull, me, { claim });
    return (
       <div className="border-b border-secondary px-1 pb-2">
          <p className="font-semibold text-ink">{STATUS_LABEL[pull.status]}</p>
@@ -113,20 +110,16 @@ function StateSection({
    );
 }
 
-/** Section 2: the sign-off/CI facts every row's rail hints at, spelled out —
- * plus, when review coordination applies, who's claimed it or whose turn the
- * rotation names (see model/rotation.ts, model/actions.ts's withCoordination). */
+/** Section 2: the sign-off/CI facts every row's rail hints at, spelled out,
+ * plus who reviews it: who said they'd review it, who was asked, or the
+ * author's own self-review. */
 function FactsSection({
    pull,
    claim,
-   turn,
-   poolSize,
    onProject,
 }: {
    pull: DerivedPull;
    claim?: Claim | null;
-   turn?: string | null;
-   poolSize?: number;
    /** open its project's page; unset on that page itself */
    onProject?: (slug: string) => void;
 }) {
@@ -143,10 +136,10 @@ function FactsSection({
       pull.ci === 'failing'
          ? 'failing'
          : pull.ci === 'pending'
-           ? 'running'
-           : pull.ci === 'success'
-             ? 'passed'
-             : 'no checks required';
+         ? 'running'
+         : pull.ci === 'success'
+         ? 'passed'
+         : 'no checks required';
    // a failing check's name links straight to its run log (the status's
    // target_url) — "which check, and show me" without a GitHub detour
    const redLogs = new Map(
@@ -247,20 +240,20 @@ function FactsSection({
                )}
             </p>
          )}
-         {/* a claim always trumps the rotation guess — same precedence as
-             model/actions.ts's withCoordination */}
-         {claim ? (
+         {claim && (
             <p>
-               claimed by <b className="font-medium text-ink">{claim.login}</b>
+               <b className="font-medium text-ink">{claim.login}</b> said they’d review it
                {claim.at != null && <> · {ago(claim.at)} ago</>}
             </p>
+         )}
+         {askedOf(pull).length > 0 ? (
+            <p>
+               review asked of <b className="font-medium text-ink">{askedOf(pull).join(', ')}</b>
+               {askedAgo(pull) && <> · {askedAgo(pull)}</>}
+            </p>
          ) : (
-            turn && (
-               <p>
-                  rotation: <b className="font-medium text-ink">{turn}</b>’s turn · pool of{' '}
-                  {poolSize ?? 0}
-               </p>
-            )
+            !claim &&
+            selfReviewed(pull) && <p>self-review: {d.user.login} stamps it, nobody was asked</p>
          )}
       </div>
    );
@@ -302,29 +295,19 @@ function StatePopoverBody({
    pull,
    me,
    claim,
-   turn,
-   poolSize,
    whyHere,
    onProject,
 }: {
    pull: DerivedPull;
    me: string;
    claim?: Claim | null;
-   turn?: string | null;
-   poolSize?: number;
    whyHere?: string | null;
    onProject?: (slug: string) => void;
 }) {
    return (
       <>
-         <StateSection pull={pull} me={me} claim={claim} turn={turn} />
-         <FactsSection
-            pull={pull}
-            claim={claim}
-            turn={turn}
-            poolSize={poolSize}
-            onProject={onProject}
-         />
+         <StateSection pull={pull} me={me} claim={claim} />
+         <FactsSection pull={pull} claim={claim} onProject={onProject} />
          <FeedbackSection pull={pull} />
          {/* ranked lanes explain their pick per-card here — behind the same
              door as everything else, never inline on the row */}
@@ -365,8 +348,6 @@ export function StatePopover({
    pull,
    me,
    claim,
-   turn,
-   poolSize,
    whyHere,
    onProject,
    title = 'see the full state',
@@ -375,8 +356,6 @@ export function StatePopover({
    pull: DerivedPull;
    me: string;
    claim?: Claim | null;
-   turn?: string | null;
-   poolSize?: number;
    /** a ranked lane's one-line reason this pull sits where it does */
    whyHere?: string | null;
    /** open the PR's project page (RowOptions.onProject) */
@@ -402,8 +381,6 @@ export function StatePopover({
             pull={pull}
             me={me}
             claim={claim}
-            turn={turn}
-            poolSize={poolSize}
             whyHere={whyHere}
             onProject={onProject}
          />
diff --git a/frontend-v2/src/components/WordGroups.tsx b/frontend-v2/src/components/WordGroups.tsx
index dfde7c18..06c7d5e7 100644
--- a/frontend-v2/src/components/WordGroups.tsx
+++ b/frontend-v2/src/components/WordGroups.tsx
@@ -18,32 +18,38 @@ export { eyebrowText } from './Lane';
 const WORD_GLOSS: Record<string, string> = {
    // do-words: the next step is yours
    'Re-stamp':
-      'You approved this PR, then new commits landed and undid your approval. Check the changes and approve again.',
+      'You stamped this PR, then new commits landed and undid your stamp. Check the changes and stamp again.',
    'Re-QA': 'You tested this PR, then new commits landed. Test it again.',
    'Finish QA': 'You started testing these. Finish and stamp.',
    'Finish CR': 'You started reviewing; your stamp isn’t in yet.',
    'Re-review': 'You asked for changes and they pushed. Take another look.',
    Merge: 'Fully signed off and green. Your merge button.',
-   'Fix CI': 'Your PR with a failing build. Nobody can review it until it’s green.',
+   'Fix CI': 'Your PR with a failing build. Fix it before you stamp or merge.',
    Respond: 'A reviewer left feedback that waits on your answer.',
    Unblock: 'A block of yours is what holds it. Lift it when you’re ready.',
    Rebase: 'Your PR conflicts with its base branch.',
-   'Nudge CR': 'Your PR, and nobody has reviewed it yet. Worth a ping.',
-   'Find a QA-er':
-      'Your PR doesn’t need more code review, it needs someone to test it. Line a tester up.',
-   Review: 'Open PRs you could code review.',
-   QA: 'Open PRs you could test.',
+   'Stamp CR':
+      'Your PR, and nobody else was asked: review it yourself and stamp CR, or request a review on GitHub.',
+   'Stamp QA':
+      'Your PR, and nobody else was asked: test it yourself and stamp QA, or request a review on GitHub.',
+   Nudge: 'You asked for a review over 4 hours ago and it hasn’t come. Worth a ping.',
+   Review: 'PRs whose review is yours: asked of you first, oldest request first.',
+   QA: 'PRs whose testing is yours: asked of you, or from outside the dev team.',
    Undraft: 'Your draft. Mark it ready on GitHub when you want review.',
    // wait-words: why the pull sits
    'waiting on re-CR':
       'A reviewer approved it, then new commits landed. Waiting on them to approve again.',
-   'waiting on CR': 'Waiting for someone to code review it.',
+   'review requested':
+      'The author asked people for a review on GitHub. Requests are answered in hours.',
+   'waiting on CR':
+      'Needs someone else’s code review (an author outside the dev team, say), and nobody is on it yet.',
    'with author': 'Changes were requested; the next push is the author’s.',
    'waiting on re-QA': 'Someone tested it, then new commits landed. Waiting on them to test again.',
-   'waiting on QA': 'Waiting for someone to test it.',
+   'waiting on QA': 'Needs someone else to test it, and nobody is on it yet.',
    'in QA':
       'Someone is testing it right now: they added the QAing label on GitHub. Add it yourself to claim a QA.',
-   claimed: 'Someone flagged they’re reading it.',
+   claimed: 'Someone said they’d review it.',
+   'self-review': 'Its author reviews and tests it themselves. Nobody else owes it anything.',
    stamped: 'Your stamp is in; waiting on the rest of the sign-offs.',
    'CI running': 'CI checks are still running on the latest push.',
    'CI failing':
@@ -56,7 +62,7 @@ const WORD_GLOSS: Record<string, string> = {
    'on hold': 'Blocked on something outside this repo.',
    parked:
       'Labeled Cryogenic Storage: shelved on purpose. Nothing is asked of anyone while it’s parked.',
-   ready: 'Fully signed off and green; anyone can merge it, usually the author does.',
+   ready: 'Fully signed off and green; its author merges it.',
    draft: 'Not up for review yet.',
    waiting: 'Waiting on something GitHub’s data doesn’t name. Open the PR to see.',
 };
diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index 973209f5..c4e4be8b 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -5,18 +5,29 @@ import { STATUS_ORDER } from '../../../shared/model/status';
 import {
    actionState,
    alertMove,
+   askForInputHint,
    authorMove,
    DO_WORD,
    DO_WORD_RANK,
    reviewerMove,
    rowNote,
+   reviewIsMine,
    rowWord,
    waitWord,
    WAIT_WORD_RANK,
 } from './actions';
 
-/** A DerivedPull with only the fields the move functions read. */
+/** A DerivedPull with only the fields the move functions read. By default an
+ * author outside the dev team (ownReview false, nobody asked): someone else
+ * reviews it, which is the shape the board's review rules were built on.
+ * `ownReview: true` is a developer's own unrequested pull. */
 function dp(o: {
+   ownReview?: boolean;
+   askedOf?: string[];
+   askedAt?: number | null;
+   /** a claim: who said they'd review it (review_requests self === true) */
+   claimedBy?: { login: string; at: number | null };
+   inputHints?: string[];
    author?: string;
    status: Status;
    conflict?: boolean;
@@ -50,7 +61,12 @@ function dp(o: {
             qa_req: o.qaReq ?? 1,
             unstamped_reviewers: o.unstampedReviewers,
          },
+         review_requests: o.claimedBy ? [{ ...o.claimedBy, self: true }] : [],
+         input_hints: o.inputHints,
       },
+      ownReview: o.ownReview ?? false,
+      askedOf: o.askedOf ?? [],
+      askedAt: o.askedAt ?? null,
       status: o.status,
       conflict: o.conflict ?? false,
       dependent: o.dependent ?? false,
@@ -104,9 +120,25 @@ describe('alertMove — which transitions earn a desktop nudge', () => {
    });
 
    it('does not alert on self-initiated / standing states', () => {
-      // "Find a QA-er" and "Finish the draft" are conditions, not events
-      expect(alertMove(dp({ author: 'me', status: 'needs_qa' }), 'me')).toBeNull();
+      // your own stamp to give, a draft, a request gone quiet: conditions, not events
+      expect(alertMove(dp({ author: 'me', status: 'needs_qa', ownReview: true }), 'me')).toBeNull();
+      expect(alertMove(dp({ author: 'me', status: 'needs_cr', ownReview: true }), 'me')).toBeNull();
       expect(alertMove(dp({ author: 'me', status: 'draft' }), 'me')).toBeNull();
+      const longAgo = Date.now() / 1000 - 6 * 3600;
+      expect(
+         alertMove(
+            dp({ author: 'me', status: 'needs_cr', askedOf: ['bob'], askedAt: longAgo }),
+            'me'
+         )
+      ).toBeNull();
+   });
+
+   it('alerts a reviewer when the author asks them for a review', () => {
+      expect(alertMove(dp({ author: 'a', status: 'needs_cr', askedOf: ['me'] }), 'me')).toBe(
+         'Review it'
+      );
+      // asked of someone else: not yours
+      expect(alertMove(dp({ author: 'a', status: 'needs_cr', askedOf: ['bob'] }), 'me')).toBeNull();
    });
 
    it('alerts a reviewer only for re-CR / re-QA that fell to them', () => {
@@ -232,7 +264,10 @@ describe('rowNote — the author matrix', () => {
    });
 
    it('needs_qa: unclaimed, testing, and re-QA-fell-through', () => {
-      expect(note({ status: 'needs_qa' }, me)).toEqual({ action: 'Find a QA-er', context: null });
+      expect(note({ status: 'needs_qa' }, me)).toEqual({
+         action: null,
+         context: 'waiting on a tester',
+      });
       expect(note({ status: 'needs_qa', qaingLogin: 'eve' }, me)).toEqual({
          action: null,
          context: 'eve is testing it',
@@ -283,7 +318,7 @@ describe('rowNote — the author matrix', () => {
             },
             me
          )
-      ).toEqual({ action: null, context: 'in the CR queue' });
+      ).toEqual({ action: null, context: 'waiting on a review' });
    });
 
    it('needs_cr: a dismissed review no longer stands, so it owes no answer', () => {
@@ -295,7 +330,7 @@ describe('rowNote — the author matrix', () => {
             },
             me
          )
-      ).toEqual({ action: null, context: 'in the CR queue' });
+      ).toEqual({ action: null, context: 'waiting on a review' });
       // a human verdict beside them still asks
       expect(
          note(
@@ -319,21 +354,14 @@ describe('rowNote — the author matrix', () => {
       });
    });
 
-   it('needs_cr: untouched and starved chases a review', () => {
+   it('needs_cr from outside the dev team: waits on a review, never a nudge to chase one', () => {
       expect(note({ status: 'needs_cr', starved: true, ageDays: 12 }, me)).toEqual({
-         action: 'Nudge for a review',
-         context: 'unreviewed 12d',
-      });
-   });
-
-   it('needs_cr: fresh and untouched sits in the queue', () => {
-      expect(note({ status: 'needs_cr' }, me)).toEqual({
          action: null,
-         context: 'in the CR queue',
+         context: 'waiting on a review',
       });
       expect(note({ status: 'needs_cr', crHave: 1, crReq: 2 }, me)).toEqual({
          action: null,
-         context: 'in the CR queue · 1 of 2',
+         context: 'waiting on a review · 1 of 2',
       });
    });
 
@@ -604,7 +632,7 @@ describe('rowNote — the non-author matrix', () => {
    it('needs_cr: qualifiers are mutually exclusive, in priority order', () => {
       expect(note({ author, status: 'needs_cr', starved: true, ageDays: 9 }, me)).toEqual({
          action: 'Review it',
-         context: 'unreviewed 9d',
+         context: 'waiting 9d',
       });
       expect(note({ author, status: 'needs_cr', crHave: 1, crReq: 2 }, me)).toEqual({
          action: 'Review it',
@@ -660,10 +688,10 @@ describe('rowNote — the non-author matrix', () => {
       });
    });
 
-   it('ready nudges the author by name', () => {
+   it('ready: its author merges it', () => {
       expect(note({ author, status: 'ready' }, me)).toEqual({
          action: null,
-         context: 'ready · nudge auth if it sits',
+         context: 'ready · auth merges it',
       });
    });
 
@@ -794,70 +822,33 @@ describe('actionState — one bucket per (pull, viewer)', () => {
    });
 });
 
-describe('rowNote — claim/turn coordination (reviewer path only)', () => {
+describe('rowNote — claims (reviewer path only)', () => {
    const p = (o: Partial<Parameters<typeof dp>[0]> = {}) =>
       dp({ author: 'auth', status: 'needs_cr', starved: true, ageDays: 29, ...o });
 
-   it('a claim by me: "Finish your review", with when I claimed it', () => {
+   it('a claim by me: "Finish your review", with when I said so', () => {
       const at = Date.now() / 1000 - 5 * 60; // 5 minutes ago, in epoch secs (the wire unit)
       const note = rowNote(p(), 'me', { claim: { login: 'me', at } });
       expect(note.action).toBe('Finish your review');
-      expect(note.context).toBe(`you claimed it · ${ago(at)} ago`);
+      expect(note.context).toBe(`you said you’d review it · ${ago(at)} ago`);
    });
 
-   it('a claim by me with no timestamp: "you claimed it", no age', () => {
+   it('a claim by me with no timestamp: no age', () => {
       const note = rowNote(p(), 'me', { claim: { login: 'me', at: null } });
       expect(note.action).toBe('Finish your review');
-      expect(note.context).toBe('you claimed it');
+      expect(note.context).toBe('you said you’d review it');
    });
 
-   it('a fresh claim by someone else absolves me: no action, who is reading it', () => {
-      const at = Date.now() / 1000 - 10 * 60; // well under the 2h stale window
-      const note = rowNote(p(), 'me', { claim: { login: 'alice', at } });
-      expect(note.action).toBeNull();
-      expect(note.context).toBe('alice is reading it');
-   });
-
-   it('a claim by someone else with no timestamp: treated as fresh, absolves me', () => {
-      const note = rowNote(p(), 'me', { claim: { login: 'alice', at: null } });
-      expect(note.action).toBeNull();
-      expect(note.context).toBe('alice is reading it');
-   });
-
-   it('a stale claim (>2h) stops absolving: "Review it" comes back', () => {
-      const at = Date.now() / 1000 - 3 * 3600; // 3h ago
-      const note = rowNote(p(), 'me', { claim: { login: 'alice', at } });
-      expect(note.action).toBe('Review it');
-      expect(note.context).toBe(`alice claimed it ${ago(at)} ago, pick it up?`);
-   });
-
-   it('claim beats turn — a claim by someone else wins even when it is also my turn', () => {
-      const at = Date.now() / 1000 - 10 * 60;
-      const note = rowNote(p(), 'me', { claim: { login: 'alice', at }, turn: 'me' });
-      expect(note.action).toBeNull();
-      expect(note.context).toBe('alice is reading it');
-   });
-
-   it('my turn, no claim: keeps "Review it", context leads with "your turn"', () => {
-      const note = rowNote(p(), 'me', { turn: 'me' });
-      expect(note.action).toBe('Review it');
-      expect(note.context).toBe('your turn · unreviewed 29d');
-   });
-
-   it("someone else's turn, no claim: appends whose turn to the existing context", () => {
-      const note = rowNote(p(), 'me', { turn: 'bob' });
-      expect(note.action).toBe('Review it');
-      expect(note.context).toBe("unreviewed 29d · bob's turn");
+   it('reads the claim off the pull itself when the caller passes none', () => {
+      const note = rowNote(p({ claimedBy: { login: 'me', at: null } }), 'me');
+      expect(note.action).toBe('Finish your review');
    });
 
-   it('needs_recr: my turn upgrades the plain wait into a "Review it" nudge', () => {
-      const note = rowNote(
-         dp({ author: 'auth', status: 'needs_recr', starved: true, recrBy: ['someone-else'] }),
-         'me',
-         { turn: 'me' }
-      );
-      expect(note.action).toBe('Review it');
-      expect(note.context).toBe('your turn · waiting on someone-else');
+   it('a claim by someone else absolves me, fresh or stale: they took it on', () => {
+      for (const at of [null, Date.now() / 1000 - 10 * 60, Date.now() / 1000 - 3 * 3600]) {
+         const note = rowNote(p(), 'me', { claim: { login: 'alice', at } });
+         expect(note).toEqual({ action: null, context: 'alice is reviewing it' });
+      }
    });
 
    it('needs_recr: a claim by me still reads "Finish your review"', () => {
@@ -868,21 +859,148 @@ describe('rowNote — claim/turn coordination (reviewer path only)', () => {
          { claim: { login: 'me', at } }
       );
       expect(note.action).toBe('Finish your review');
-      expect(note.context).toBe(`you claimed it · ${ago(at)} ago`);
    });
 
-   it('the author path is unaffected by claim/turn extras', () => {
-      const at = Date.now();
+   it('the author path is unaffected by claim extras', () => {
       const note = rowNote(dp({ author: 'me', status: 'ready' }), 'me', {
-         claim: { login: 'someone', at },
-         turn: 'someone',
+         claim: { login: 'someone', at: Date.now() },
       });
       expect(note.action).toBe('Merge it');
    });
+});
+
+describe('self-review: a developer CRs and QAs their own unrequested pull', () => {
+   it('the author stamps CR, then QA, in their own words', () => {
+      expect(rowNote(dp({ author: 'me', status: 'needs_cr', ownReview: true }), 'me')).toEqual({
+         action: 'Stamp CR',
+         context: 'review it yourself, or request a review',
+      });
+      expect(rowNote(dp({ author: 'me', status: 'needs_qa', ownReview: true }), 'me')).toEqual({
+         action: 'Stamp QA',
+         context: 'test it yourself, or request a review',
+      });
+      expect(rowWord(dp({ author: 'me', status: 'needs_cr', ownReview: true }), 'me')).toEqual({
+         kind: 'do',
+         word: 'Stamp CR',
+      });
+   });
+
+   it('a push that undid the author’s own stamp is a re-stamp, whoever else was asked', () => {
+      for (const o of [
+         { status: 'needs_recr' as const, recrBy: ['me'] },
+         { status: 'needs_qa' as const, reqaBy: ['me'] },
+         { status: 'needs_recr' as const, recrBy: ['me', 'bob'], askedOf: ['bob'] },
+      ]) {
+         expect(rowNote(dp({ author: 'me', ownReview: true, ...o }), 'me')).toEqual({
+            action: 'Re-stamp',
+            context: 'new commits since your stamp',
+         });
+      }
+   });
 
-   it('no claim, no turn: behaves exactly like the two-arg call', () => {
-      expect(rowNote(p(), 'me', {})).toEqual(rowNote(p(), 'me'));
-      expect(rowNote(p(), 'me', { claim: null, turn: null })).toEqual(rowNote(p(), 'me'));
+   it('nobody else owes it anything: no review, no QA, out of everyone’s queue', () => {
+      const own = (status: 'needs_cr' | 'needs_qa' | 'needs_recr') =>
+         dp({ author: 'alice', status, ownReview: true, starved: true, ageDays: 20 });
+      for (const status of ['needs_cr', 'needs_qa'] as const) {
+         expect(rowNote(own(status), 'me')).toEqual({ action: null, context: 'in self-review' });
+         expect(rowWord(own(status), 'me')).toEqual({ kind: 'wait', word: 'self-review' });
+         expect(actionState(own(status), 'me')).toBe('waiting');
+         expect(reviewIsMine(own(status), 'me')).toBe(false);
+      }
+   });
+
+   it('a bot is never a developer, whatever ownReview says', () => {
+      const bot = dp({ author: 'dependabot[bot]', status: 'needs_cr', ownReview: true });
+      expect(rowNote(bot, 'me').action).toBe('Review it');
+      expect(reviewIsMine(bot, 'me')).toBe(true);
+   });
+});
+
+describe('review requests: asked of people, answered in hours', () => {
+   const hoursAgo = (h: number) => Date.now() / 1000 - h * 3600;
+
+   it('asked of me: Review it (or QA it), with the request’s age', () => {
+      expect(
+         rowNote(
+            dp({ author: 'a', status: 'needs_cr', askedOf: ['me'], askedAt: hoursAgo(3.5) }),
+            'me'
+         )
+      ).toEqual({ action: 'Review it', context: 'asked 3h ago' });
+      expect(
+         rowNote(
+            dp({ author: 'a', status: 'needs_qa', askedOf: ['me'], askedAt: hoursAgo(0.2) }),
+            'me'
+         )
+      ).toEqual({ action: 'QA it', context: 'asked just now' });
+      expect(rowNote(dp({ author: 'a', status: 'needs_cr', askedOf: ['me'] }), 'me')).toEqual({
+         action: 'Review it',
+         context: 'review requested',
+      });
+   });
+
+   it('asked of someone else: theirs, so I just see who', () => {
+      const p = dp({
+         author: 'a',
+         status: 'needs_cr',
+         askedOf: ['bob', 'cy'],
+         askedAt: hoursAgo(1),
+      });
+      expect(rowNote(p, 'me')).toEqual({
+         action: null,
+         context: 'waiting on bob, cy · asked 1h ago',
+      });
+      expect(rowWord(p, 'me')).toEqual({ kind: 'wait', word: 'review requested' });
+      expect(reviewIsMine(p, 'me')).toBe(false);
+   });
+
+   it('the author waits on whoever they asked, then nudges past 4 hours', () => {
+      const asked = (h: number, who = ['bob']) =>
+         dp({ author: 'me', status: 'needs_cr', askedOf: who, askedAt: hoursAgo(h) });
+      expect(rowNote(asked(3), 'me')).toEqual({
+         action: null,
+         context: 'waiting on bob · asked 3h ago',
+      });
+      expect(rowWord(asked(3), 'me')).toEqual({ kind: 'wait', word: 'review requested' });
+      expect(rowNote(asked(5), 'me')).toEqual({ action: 'Nudge bob', context: 'asked bob 5h ago' });
+      expect(rowWord(asked(5), 'me')).toEqual({ kind: 'do', word: 'Nudge' });
+      expect(rowNote(asked(5, ['bob', 'cy']), 'me').action).toBe('Nudge reviewers');
+      expect(authorMove(asked(5))).toBe('Nudge bob');
+   });
+
+   it('a claim makes the review the claimer’s, not anyone else’s', () => {
+      const claimed = dp({ author: 'a', status: 'needs_cr', claimedBy: { login: 'cy', at: null } });
+      expect(reviewIsMine(claimed, 'cy')).toBe(true);
+      expect(reviewIsMine(claimed, 'me')).toBe(false);
+      // asked of me AND claimed by someone else: still asked of me
+      const both = dp({
+         author: 'a',
+         status: 'needs_cr',
+         askedOf: ['me'],
+         claimedBy: { login: 'cy', at: null },
+      });
+      expect(reviewIsMine(both, 'me')).toBe(true);
+      expect(rowNote(both, 'me').action).toBe('Review it');
+   });
+});
+
+describe('askForInputHint — worth asking for review?', () => {
+   const own = (o: Partial<Parameters<typeof dp>[0]> = {}) =>
+      dp({ author: 'me', status: 'needs_cr', ownReview: true, ...o });
+
+   it('names the areas in plain words', () => {
+      expect(askForInputHint(own({ inputHints: ['ci', 'migrations'] }))).toBe(
+         'touches CI and migrations · worth asking for review?'
+      );
+      expect(askForInputHint(own({ inputHints: ['agent-docs', 'deploy', 'dependencies'] }))).toBe(
+         'touches agent docs, deploy config and dependencies · worth asking for review?'
+      );
+   });
+
+   it('stays quiet without hints, once asked, once CR is in, or when the field is absent', () => {
+      expect(askForInputHint(own())).toBeNull();
+      expect(askForInputHint(own({ inputHints: [] }))).toBeNull();
+      expect(askForInputHint(own({ inputHints: ['ci'], ownReview: false }))).toBeNull();
+      expect(askForInputHint(own({ inputHints: ['ci'], crHave: 1 }))).toBeNull();
    });
 });
 
@@ -990,11 +1108,11 @@ describe('rowWord — the one-word section-header key', () => {
          ).toEqual({ kind: 'wait', word: 'claimed' });
       });
 
-      it('a stale claim does not read claimed — it falls back to the "Review it" do', () => {
-         const at = Date.now() / 1000 - 3 * 3600; // 3h ago, past STALE_CLAIM_SECS
+      it('a stale claim still reads claimed: the claimer took it on', () => {
+         const at = Date.now() / 1000 - 3 * 3600;
          expect(
             word({ author: 'auth', status: 'needs_cr' }, 'me', { claim: { login: 'bob', at } })
-         ).toEqual({ kind: 'do', word: 'Review' });
+         ).toEqual({ kind: 'wait', word: 'claimed' });
       });
 
       it('deploy_block reviewer → deploy hold', () => {
@@ -1031,7 +1149,8 @@ describe('DO_WORD / WAIT_WORD_RANK — drift guard', () => {
    // silently sort that group to the bottom instead of failing loudly. The
    // two vocabularies must carry exactly the same set of words.
    it('DO_WORD only ever produces words DO_WORD_RANK ranks', () => {
-      expect(new Set(Object.values(DO_WORD))).toEqual(new Set(DO_WORD_RANK));
+      // plus 'Nudge', which rowWord gives every "Nudge {name}" by its prefix
+      expect(new Set([...Object.values(DO_WORD), 'Nudge'])).toEqual(new Set(DO_WORD_RANK));
    });
 
    // waitWord computes its word from the pull's own facts rather than a
@@ -1063,6 +1182,8 @@ describe('DO_WORD / WAIT_WORD_RANK — drift guard', () => {
          [{ status: 'needs_recr' }], // waiting on re-CR
          [{ status: 'needs_cr', changesRequestedBy: ['other'] }], // with author
          [{ status: 'needs_cr' }], // waiting on CR
+         [{ status: 'needs_cr', askedOf: ['other'] }], // review requested
+         [{ status: 'needs_cr', ownReview: true }], // self-review
       ];
       const produced = cases.map(([o, extra]) => waitWord(dp(o), 'me', extra));
       expect(WAIT_WORD_RANK).toEqual(expect.arrayContaining(produced));
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index b99691c0..07d16331 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -1,5 +1,5 @@
 import { ago } from '../../../shared/format';
-import { requestedReviewers } from './reviewers';
+import { claimFor } from './reviewers';
 import { authorOwnsIt, feedbackAnswered, parked } from '../../../shared/model/stage';
 import { CR_INCOMPLETE, unique, type DerivedPull } from '../../../shared/model/status';
 import { isSuffixBot } from '../../../shared/model/visibility';
@@ -10,36 +10,95 @@ export { authorOwnsIt, feedbackAnswered, parked };
 
 /**
  * The verb column: what moves this pull, and whose move is it? Review's
- * "Yours to do" lane and My work's "Your move" both read from here so the
+ * "Waiting on you" lane and My work's "Your move" both read from here so the
  * two tabs can never disagree about what you owe.
+ *
+ * The self-review policy (shared/model/status.ts ownReview): a developer CRs
+ * and QAs their own pull unless they ask for a review, so an unrequested
+ * pull's stamps are its author's move and nobody else owes it anything. Only
+ * a pull that needs someone else (a review asked of people, one a reviewer
+ * took on, one from outside the dev team) is anyone else's review work.
+ */
+
+/** The author reviews it themselves. A bot is never a developer, whatever
+ * the roster says (with no roster derive counts everyone, bots included). */
+export const selfReviewed = (p: DerivedPull): boolean =>
+   !!p.ownReview && !isSuffixBot(p.data.user.login);
+
+/** who the author's side asked to review it (people and team members),
+ * read as [] off a pull derived before the policy existed */
+export const askedOf = (p: DerivedPull): string[] => p.askedOf ?? [];
+
+/** Requests are answered in hours: past this, the author's move is a nudge. */
+export const ASK_OVERDUE_HOURS = 4;
+
+/** Whole hours since the review request, or null when there's none or it
+ * can't be dated. */
+export function askedHours(p: DerivedPull, now = Date.now() / 1000): number | null {
+   return p.askedAt == null ? null : Math.max(0, Math.floor((now - p.askedAt) / 3600));
+}
+
+/** "asked 3h ago", "asked just now"; null when the request can't be dated */
+export function askedAgo(p: DerivedPull, now?: number): string | null {
+   const h = askedHours(p, now);
+   if (h == null) return null;
+   return h < 1 ? 'asked just now' : `asked ${h}h ago`;
+}
+
+/** A request nobody has answered past ASK_OVERDUE_HOURS. */
+export const askOverdue = (p: DerivedPull, now?: number): boolean =>
+   (askedHours(p, now) ?? 0) >= ASK_OVERDUE_HOURS;
+
+/**
+ * Whether this pull is `me`'s review work: asked of me (by name or through a
+ * team), or one I said I'd review; otherwise one that needs someone else and
+ * that nobody was asked for or took on (an author outside the dev team, or a
+ * team request naming nobody on the roster). Never my own, and never a
+ * developer's own unrequested pull: its review is its author's.
+ */
+export function reviewIsMine(p: DerivedPull, me: string): boolean {
+   if (p.data.user.login === me) return false;
+   const claim = claimFor(p.data);
+   if (claim?.login === me) return true;
+   const asked = askedOf(p);
+   if (asked.length) return asked.includes(me);
+   if (claim) return false;
+   return !selfReviewed(p);
+}
+
+const INPUT_HINT_WORDS: Record<string, string> = {
+   ci: 'CI',
+   migrations: 'migrations',
+   alerting: 'alerting',
+   'agent-docs': 'agent docs',
+   deploy: 'deploy config',
+   dependencies: 'dependencies',
+};
+
+/** "a", "a and b", "a, b and c" */
+const andList = (words: string[]) =>
+   words.length < 2 ? words.join('') : `${words.slice(0, -1).join(', ')} and ${words.at(-1)}`;
+
+/**
+ * The quiet hint on your own self-reviewed pull whose diff touches what
+ * usually deserves team input (input_hints, from the changed paths): "touches
+ * CI and migrations · worth asking for review?". Null once a review is
+ * asked for, once CR is in, or with nothing to say.
  */
+export function askForInputHint(p: DerivedPull): string | null {
+   if (!selfReviewed(p) || parked(p) || p.crHave >= p.data.status.cr_req) return null;
+   const areas = unique((p.data.input_hints ?? []).map(h => INPUT_HINT_WORDS[h] ?? h));
+   return areas.length ? `touches ${andList(areas)} · worth asking for review?` : null;
+}
+
+/** The author's move to chase a request gone past ASK_OVERDUE_HOURS. */
+const nudgeMove = (asked: string[]) => `Nudge ${asked.length === 1 ? asked[0] : 'reviewers'}`;
 
 /** Your move on a pull you authored; null = waiting on someone else. Only ever
- * called for the viewer's own pulls, so the author IS the viewer here. */
+ * called for the viewer's own pulls, so the author IS the viewer here. The
+ * same order authorNote weighs, without its context. */
 export function authorMove(p: DerivedPull): string | null {
-   if (parked(p)) return null;
-   if (p.status === 'ready') return 'Merge it';
-   // the ci FLAG, not just the ci_red status: a red build mid-review keeps
-   // its needs_cr status (reviewers may still take it), but fixing the build
-   // is the author's move either way
-   if (p.status === 'ci_red' || p.ci === 'failing') return 'Fix CI';
-   // a dev block is feedback waiting on YOU — v1 lore said "ask them to lift
-   // it", which misroutes the most common author action. But a block you put
-   // on your own PR (self-flagged "hold off") isn't feedback to answer — the
-   // move is lifting it, so mirror authorNote's self-only-blocker case rather
-   // than telling you to "Address feedback" from yourself.
-   if (p.status === 'dev_block') {
-      const others = p.devBlockedBy.filter(l => l !== p.data.user.login);
-      return others.length ? 'Address feedback' : 'Lift your block';
-   }
-   // conflict only, NOT status === 'unmergeable': that status also covers a
-   // clean stacked pull (dependent, signed off, waiting on its parent), where
-   // there is nothing to rebase and no move to nudge about
-   if (p.conflict) return 'Rebase';
-   if (p.status === 'needs_qa' && !p.qaingLogin && !p.reqaBy.length) return 'Find a QA-er';
-   // the exit verb, not "finish": the move is marking it ready for review
-   if (p.status === 'draft') return 'Undraft';
-   return null;
+   return parked(p) ? null : authorNote(p, p.data.user.login).action;
 }
 
 /** Your move on someone else's pull; null = not your job right now. The QA
@@ -61,22 +120,20 @@ export function reviewerMove(p: DerivedPull, me: string): string | null {
 
 /**
  * The subset of moves worth a desktop nudge: a real transition that just
- * landed on you — your PR is mergeable / broke CI / got feedback / needs a
- * rebase, or a re-CR/re-QA fell to you. Excludes self-initiated states
- * (claiming QA, still drafting) and "go find someone" states, which aren't
- * events so much as standing conditions. Returns the action label, or null.
+ * landed on you: your PR is mergeable / broke CI / got feedback / needs a
+ * rebase, a re-CR/re-QA fell to you, or someone asked you for a review.
+ * Excludes standing conditions on your own pull (your own stamp to give, a
+ * draft, a block you put on yourself, a request gone quiet): nothing landed
+ * on you there. Returns the action label, or null.
  */
 export function alertMove(p: DerivedPull, me: string): string | null {
    if (p.data.user.login === me) {
       const v = authorMove(p);
-      // 'Lift your block' is a block you put on yourself — a standing choice,
-      // not an event that landed on you, so it earns no desktop nudge (same as
-      // 'Find a QA-er' / 'Undraft')
-      const standing = v === 'Find a QA-er' || v === 'Undraft' || v === 'Lift your block';
-      return v && !standing ? v : null;
+      return v && ['Merge it', 'Fix CI', 'Address feedback', 'Rebase'].includes(v) ? v : null;
    }
    const v = reviewerMove(p, me);
-   return v === 'Re-stamp' || v === 'Re-QA' ? v : null;
+   if (v === 'Re-stamp' || v === 'Re-QA') return v;
+   return askedOf(p).includes(me) && rowNote(p, me).action === 'Review it' ? 'Review it' : null;
 }
 
 /**
@@ -152,21 +209,24 @@ function authorNote(p: DerivedPull, me: string): RowNote {
       return { action: 'Rebase', context: p.crHave < crReq ? 'CR still needed' : null };
    if (p.status === 'unmergeable' && p.dependent) return waitOnly('lands with its parent');
    if (p.status === 'ready') return doOnly('Merge it');
-   if (p.status === 'needs_qa') {
-      if (!p.qaingLogin && !p.reqaBy.length) return doOnly('Find a QA-er');
-      if (p.qaingLogin) return waitOnly(`${who([p.qaingLogin])} is testing it`);
-      if (p.reqaBy.length) return waitOnly(`new commits undid ${who(p.reqaBy)}'s QA`);
+   const reviewing = p.status === 'needs_cr' || p.status === 'needs_recr';
+   if (!reviewing && p.status !== 'needs_qa') {
+      if (p.status === 'ci_pending') return waitOnly('merge when it goes green');
+      if (p.status === 'deploy_block')
+         return waitOnly(`ask ${who(p.deployBlockedBy)} before deploy`);
+      return waitOnly(FALLBACK_STATUS_LABEL[p.status]);
    }
-   if (p.status === 'needs_recr')
-      return waitOnly(`waiting on ${who(p.recrBy)} to re-stamp${pushed}`);
+
+   // your own stamp went stale on a push: under self-review it's yours to
+   // give again, whoever else is asked
+   if ((reviewing && p.recrBy.includes(me)) || (!reviewing && p.reqaBy.includes(me)))
+      return { action: 'Re-stamp', context: 'new commits since your stamp' };
    if (p.status === 'needs_cr') {
       // any reviewer with an unstamped verdict (CHANGES_REQUESTED already
       // handled above) has left something the author owes an answer to.
       // DISMISSED is excluded — a dismissed review no longer stands, so it
       // owes no answer. Bots are excluded too: the wire's unstamped_reviewers
-      // carries every reviewer, and the CI review bot COMMENTs on most PRs —
-      // unfiltered, "Answer the review · from claude[bot]" was the note on a
-      // quarter of the live board, burying the real queue-position context.
+      // carries every reviewer, and the CI review bot COMMENTs on most PRs.
       const reviewerLogins = unique(
          (d.status.unstamped_reviewers ?? [])
             .filter(r => r.state !== 'DISMISSED' && !isSuffixBot(r.login))
@@ -174,104 +234,59 @@ function authorNote(p: DerivedPull, me: string): RowNote {
       );
       if (reviewerLogins.length)
          return { action: 'Answer the review', context: `from ${who(reviewerLogins)}` };
-      if (p.engagedNoStamp.length) return waitOnly(`in discussion with ${who(p.engagedNoStamp)}`);
-      if (p.starved) return { action: 'Nudge for a review', context: `unreviewed ${p.ageDays}d` };
+   }
+   if (p.status === 'needs_qa' && p.qaingLogin)
+      return waitOnly(`${who([p.qaingLogin])} is testing it`);
+   // you asked for a review: theirs to give, answered in hours
+   const asked = askedOf(p);
+   if (asked.length) {
+      const when = askedAgo(p);
+      if (askOverdue(p))
+         return { action: nudgeMove(asked), context: `asked ${who(asked)} ${askedHours(p)}h ago` };
+      return waitOnly(`waiting on ${who(asked)}${when ? ` · ${when}` : ''}`);
+   }
+   const claim = claimFor(d);
+   if (claim) return waitOnly(`${claim.login} is reviewing it`);
+   if (selfReviewed(p))
+      return reviewing
+         ? { action: 'Stamp CR', context: 'review it yourself, or request a review' }
+         : { action: 'Stamp QA', context: 'test it yourself, or request a review' };
+   // outside the dev team: someone else reviews it, nobody's been asked yet
+   if (p.status === 'needs_recr')
+      return waitOnly(`waiting on ${who(p.recrBy)} to re-stamp${pushed}`);
+   if (p.status === 'needs_qa')
       return waitOnly(
-         p.crHave > 0 ? `in the CR queue · ${p.crHave} of ${crReq}` : 'in the CR queue'
+         p.reqaBy.length ? `new commits undid ${who(p.reqaBy)}'s QA` : 'waiting on a tester'
       );
-   }
-   if (p.status === 'ci_pending') return waitOnly('merge when it goes green');
-   if (p.status === 'deploy_block') return waitOnly(`ask ${who(p.deployBlockedBy)} before deploy`);
-
-   return waitOnly(FALLBACK_STATUS_LABEL[p.status]);
+   if (p.engagedNoStamp.length) return waitOnly(`in discussion with ${who(p.engagedNoStamp)}`);
+   return waitOnly(
+      p.crHave > 0 ? `waiting on a review · ${p.crHave} of ${crReq}` : 'waiting on a review'
+   );
 }
 
 /** A reviewer's claim on a pull: who, and when (epoch seconds — see
  * types.ts's review_requests). `at` is null when the server can't say yet
- * (e.g. it restarted before the webhook backfilled the timestamp); a claim
- * with no `at` is treated as fresh everywhere below, since there's nothing to
- * measure staleness against. */
+ * (e.g. it restarted before the webhook backfilled the timestamp). */
 export interface Claim {
    login: string;
    at: number | null;
 }
 
-/** A claim older than this no longer absolves anyone else — the reader may
- * have wandered off, so the pull goes back on the market. */
+/** When an unfinished claim of yours starts reading as stale (the default for
+ * the claim-warn nag, and the "claimed it 3h ago" wording elsewhere). */
 export const STALE_CLAIM_SECS = 2 * 3600;
 
-/**
- * Layers claim/turn coordination onto a base needs_cr/needs_recr note — the
- * note an uninvolved reviewer would see (no stamp of their own, nothing
- * specifically owed by them). A claim always wins over a turn: someone
- * actively reading it is a stronger signal than the rotation's guess, and a
- * fresh claim by someone else absolves the viewer entirely (action null) —
- * but a claim past STALE_CLAIM_SECS stops absolving, since the reader may
- * have moved on, and the pull's "Review it" action comes back. A claim with
- * no timestamp can't be proven stale, so it stays fresh (never degrades to
- * "pick it up?").
- */
-function withCoordination(
-   base: RowNote,
-   me: string,
-   claim?: Claim | null,
-   turn?: string | null,
-   requestedFromMe?: boolean
-): RowNote {
-   if (claim) {
-      const claimAgo = claim.at != null ? `${ago(claim.at)} ago` : null;
-      if (claim.login === me)
-         return {
-            action: 'Finish your review',
-            context: claimAgo ? `you claimed it · ${claimAgo}` : 'you claimed it',
-         };
-      const staleSecs = claim.at != null ? Date.now() / 1000 - claim.at : 0;
-      if (staleSecs > STALE_CLAIM_SECS)
-         return {
-            action: 'Review it',
-            context: `${claim.login} claimed it ${claimAgo}, pick it up?`,
-         };
-      return { action: null, context: `${claim.login} is reading it` };
-   }
-   // An explicit GitHub review request beats the rotation guess: it's a direct
-   // ask, so it always earns the "Review it" pill (and turnFor already stays
-   // silent on requested pulls, so `turn` is null here anyway).
-   if (requestedFromMe)
-      return {
-         action: 'Review it',
-         context: base.context ? `review requested · ${base.context}` : 'review requested',
-      };
-   if (turn === me)
-      return {
-         action: 'Review it',
-         context: base.context ? `your turn · ${base.context}` : 'your turn',
-      };
-   if (turn)
-      return {
-         action: base.action,
-         context: base.context ? `${base.context} · ${turn}'s turn` : `${turn}'s turn`,
-      };
-   return base;
-}
-
 /** The viewer did not author this pull: what they owe, or why they're waiting. */
-function reviewerNote(
-   p: DerivedPull,
-   me: string,
-   extra?: { claim?: Claim | null; turn?: string | null }
-): RowNote {
+function reviewerNote(p: DerivedPull, me: string, extra?: { claim?: Claim | null }): RowNote {
    const d = p.data;
    const author = d.user.login;
    const who = (logins: string[]) => logins.map(l => (l === me ? 'you' : l)).join(', ');
    const pushed = p.headPushedAt ? ` · last commit ${ago(p.headPushedAt)} ago` : '';
    const crReq = d.status.cr_req;
    const qaReq = d.status.qa_req;
-   // GitHub review requests: an ask aimed at you drives the note (via
-   // withCoordination below); one aimed at someone else is still worth naming
-   // as context, so an uninvolved reader sees who owns it.
-   const requested = requestedReviewers(p);
-   const requestedFromMe = requested.includes(me);
-   const requestedOthers = requested.filter(l => l !== me);
+   const asked = askedOf(p);
+   const when = askedAgo(p);
+   const claim = extra?.claim !== undefined ? extra.claim : claimFor(d);
 
    // your personal obligations — but only once the pull is reviewable: while
    // the author owns it (draft / dev block / red CI, the statuses below that
@@ -305,48 +320,46 @@ function reviewerNote(
       }
       return waitOnly(`changes requested by ${who(p.changesRequestedBy)}`);
    }
-   // Adapted from the spec's literal order (see PR/report): an already-active
-   // CR stamp earns the reassuring "you've stamped" count instead of the
-   // generic "waiting on a re-stamp" line, so this check runs before the
-   // plain needs_recr branch below, not after it.
+   // an already-active CR stamp earns the reassuring "you've stamped" count
+   // instead of the generic wait, so this runs before the review branches
    if (CR_INCOMPLETE.includes(p.status) && p.crBy.includes(me))
       return waitOnly(`you've stamped · ${p.crHave} of ${crReq}`);
-   if (p.status === 'needs_recr')
-      return withCoordination(
-         waitOnly(`waiting on ${who(p.recrBy)}${pushed}`),
-         me,
-         extra?.claim,
-         extra?.turn,
-         requestedFromMe
-      );
-   if (p.status === 'needs_cr') {
-      const context = p.starved
-         ? `unreviewed ${p.ageDays}d`
-         : p.crHave > 0
-           ? `${p.crHave} of ${crReq} in`
-           : requestedOthers.length
-             ? `requested from ${who(requestedOthers)}`
-             : p.engagedNoStamp.length
-               ? `${who(p.engagedNoStamp)} looking`
-               : null;
-      return withCoordination(
-         { action: 'Review it', context },
-         me,
-         extra?.claim,
-         extra?.turn,
-         requestedFromMe
-      );
-   }
    if (p.status === 'needs_qa') {
       if (p.qaBy.includes(me)) return waitOnly(`you've QA'd · ${p.qaHave} of ${qaReq}`);
       if (p.qaingLogin) return waitOnly(`${who([p.qaingLogin])} is testing it`);
-      return { action: 'QA it', context: p.qaHave > 0 ? `${p.qaHave} of ${qaReq} in` : null };
+   }
+
+   const reviewing = p.status === 'needs_cr' || p.status === 'needs_recr';
+   if (reviewing || p.status === 'needs_qa') {
+      if (claim?.login === me) {
+         const since = claim.at != null ? ` · ${ago(claim.at)} ago` : '';
+         return { action: 'Finish your review', context: `you said you’d review it${since}` };
+      }
+      if (asked.includes(me))
+         return { action: reviewing ? 'Review it' : 'QA it', context: when ?? 'review requested' };
+      if (claim) return waitOnly(`${claim.login} is reviewing it`);
+      if (p.status === 'needs_recr') return waitOnly(`waiting on ${who(p.recrBy)}${pushed}`);
+      if (asked.length) return waitOnly(`waiting on ${who(asked)}${when ? ` · ${when}` : ''}`);
+      // the author reviews their own: nobody else owes it anything
+      if (selfReviewed(p)) return waitOnly('in self-review');
+      // needs someone else and nobody's on it: an author outside the dev
+      // team, or a request to a team nobody on the roster is in
+      if (p.status === 'needs_qa')
+         return { action: 'QA it', context: p.qaHave > 0 ? `${p.qaHave} of ${qaReq} in` : null };
+      const context = p.starved
+         ? `waiting ${p.ageDays}d`
+         : p.crHave > 0
+         ? `${p.crHave} of ${crReq} in`
+         : p.engagedNoStamp.length
+         ? `${who(p.engagedNoStamp)} looking`
+         : null;
+      return { action: 'Review it', context };
    }
    if (p.status === 'deploy_block') return waitOnly(`ask ${who(p.deployBlockedBy)} first`);
    if (p.status === 'unmergeable')
       return waitOnly(p.conflict ? 'conflicts · author rebases' : 'lands with its parent');
    if (p.status === 'ci_pending') return waitOnly('all stamps in, waiting on green');
-   if (p.status === 'ready') return waitOnly(`ready · nudge ${author} if it sits`);
+   if (p.status === 'ready') return waitOnly(`ready · ${author} merges it`);
 
    return waitOnly(FALLBACK_STATUS_LABEL[p.status]);
 }
@@ -391,23 +404,10 @@ export function actionState(p: DerivedPull, me: string): ActionStateKey {
  * whether it came from a `CR`/`dev_block` comment tag or a GitHub review, so
  * the wording never says "requested changes" or "approved".
  *
- * Deliberately independent of authorMove/reviewerMove: those two back
- * alertMove's narrow desktop-notification filter and must keep behaving
- * exactly as before, so this rewrite duplicates rather than reuses their
- * (much narrower) checks.
- *
- * `extra` is optional and reviewer-side only (see withCoordination): a claim
- * or a rotation turn on a needs_cr/needs_recr pull layers on top of the base
- * note for anyone not already specifically implicated (no stamp, nothing
- * owed). Existing two-arg callers (query.ts's `has:action`, the popover)
- * keep reading the base note, unaware of claims/turns — that's fine, they
- * don't need the coordination detail.
+ * `extra.claim` overrides the pull's own claim (claimFor) for the
+ * reviewer-side note; callers normally leave it out.
  */
-export function rowNote(
-   p: DerivedPull,
-   me: string,
-   extra?: { claim?: Claim | null; turn?: string | null }
-): RowNote {
+export function rowNote(p: DerivedPull, me: string, extra?: { claim?: Claim | null }): RowNote {
    // parked outranks everything, the author's own moves included: a shelved
    // pull is a wait for everyone until the label comes off
    if (parked(p)) return waitOnly('parked, kept open on purpose');
@@ -429,7 +429,8 @@ export type RowWord = { kind: 'do' | 'wait'; word: string };
 
 /** rowNote's action string → the one-word label its section header shows.
  * Falls back to the action string itself so a future action never renders
- * blank — but every string rowNote can produce today is listed here. */
+ * blank — but every string rowNote can produce today is listed here, the
+ * author's "Nudge {name}" by its prefix (see rowWord). */
 export const DO_WORD: Record<string, string> = {
    'Re-stamp': 'Re-stamp',
    'Re-QA': 'Re-QA',
@@ -443,34 +444,34 @@ export const DO_WORD: Record<string, string> = {
    'Lift your block': 'Unblock',
    Unblock: 'Unblock',
    Rebase: 'Rebase',
-   'Nudge for a review': 'Nudge CR',
-   'Find a QA-er': 'Find a QA-er',
+   'Stamp CR': 'Stamp CR',
+   'Stamp QA': 'Stamp QA',
    'Review it': 'Review',
    'QA it': 'QA',
    Undraft: 'Undraft',
 };
 
-/** Same freshness rule withCoordination uses for a claim by someone else — but
- * here it decides a single word (claimed vs. still-owed), not the fuller
- * action/context pair, so it's reimplemented rather than shared. A claim with
- * no timestamp can't be proven stale, so it reads as fresh. */
-function freshOtherClaim(me: string, claim?: Claim | null): boolean {
-   if (!claim || claim.login === me) return false;
-   if (claim.at == null) return true;
-   return Date.now() / 1000 - claim.at <= STALE_CLAIM_SECS;
-}
-
 /**
  * The wait-side word, computed straight from the pull's own facts rather than
  * parsed from rowNote's context — free text is for a human to read, not for a
- * grouping decision to key off. The branch order deliberately mirrors
- * reviewerNote/authorNote: changes-requested outranks your own stamp, and a
- * claim only absolves a viewer with no stake of their own in the pull.
+ * grouping decision to key off. The branch order mirrors reviewerNote/
+ * authorNote: changes-requested outranks your own stamp, and a claim only
+ * absolves a viewer with no stake of their own in the pull. Who was asked
+ * stays in the context ("waiting on bob · asked 3h ago"): one word per
+ * name would split a lane into a header per person.
  */
 export function waitWord(p: DerivedPull, me: string, extra?: { claim?: Claim | null }): string {
    if (parked(p)) return 'parked';
    if (p.externalBlock) return 'on hold';
    const isAuthor = p.data.user.login === me;
+   const claim = extra?.claim !== undefined ? extra.claim : claimFor(p.data);
+   // who it waits on, once nobody's specifically owed a stamp by you
+   const holder = () => {
+      if (claim && claim.login !== me) return 'claimed';
+      if (askedOf(p).length) return 'review requested';
+      if (selfReviewed(p)) return 'self-review';
+      return null;
+   };
    switch (p.status) {
       case 'draft':
          return 'draft';
@@ -489,18 +490,16 @@ export function waitWord(p: DerivedPull, me: string, extra?: { claim?: Claim | n
       case 'needs_qa':
          if (p.qaBy.includes(me)) return 'stamped';
          if (p.qaingLogin) return 'in QA';
-         if (isAuthor && p.reqaBy.length) return 'waiting on re-QA';
-         return 'waiting on QA';
+         if (isAuthor && p.reqaBy.length && !askedOf(p).length) return 'waiting on re-QA';
+         return holder() ?? 'waiting on QA';
       case 'needs_recr':
          if (p.crBy.includes(me)) return 'stamped';
-         if (freshOtherClaim(me, extra?.claim)) return 'claimed';
-         return 'waiting on re-CR';
+         return holder() ?? 'waiting on re-CR';
       case 'needs_cr':
          if (p.changesRequestedBy.length)
             return feedbackAnswered(p) ? 'waiting on re-CR' : 'with author';
          if (p.crBy.includes(me)) return 'stamped';
-         if (freshOtherClaim(me, extra?.claim)) return 'claimed';
-         return 'waiting on CR';
+         return holder() ?? 'waiting on CR';
       default:
          return 'waiting';
    }
@@ -516,18 +515,18 @@ export function waitWord(p: DerivedPull, me: string, extra?: { claim?: Claim | n
  * from parsing rowNote's context string, which is free text meant for a
  * human, not a stable key to group on.
  */
-export function rowWord(
-   p: DerivedPull,
-   me: string,
-   extra?: { claim?: Claim | null; turn?: string | null }
-): RowWord {
+export function rowWord(p: DerivedPull, me: string, extra?: { claim?: Claim | null }): RowWord {
    const note = rowNote(p, me, extra);
-   if (note.action != null) return { kind: 'do', word: DO_WORD[note.action] ?? note.action };
-   return { kind: 'wait', word: waitWord(p, me, extra) };
+   if (note.action == null) return { kind: 'wait', word: waitWord(p, me, extra) };
+   if (note.action.startsWith('Nudge ')) return { kind: 'do', word: 'Nudge' };
+   return { kind: 'do', word: DO_WORD[note.action] ?? note.action };
 }
 
-/** Most-urgent-first order for the 'do' word groups. */
+/** Most-urgent-first order for the 'do' word groups. A review someone asked
+ * of you leads: the policy measures answering one in hours. */
 export const DO_WORD_RANK: readonly string[] = [
+   'Review',
+   'QA',
    'Re-stamp',
    'Re-QA',
    'Finish QA',
@@ -536,17 +535,17 @@ export const DO_WORD_RANK: readonly string[] = [
    'Merge',
    'Fix CI',
    'Respond',
+   'Stamp CR',
+   'Stamp QA',
+   'Nudge',
    'Unblock',
    'Rebase',
-   'Nudge CR',
-   'Find a QA-er',
-   'Review',
-   'QA',
    'Undraft',
 ];
 
 /** Most-urgent-first order for the 'wait' word groups. */
 export const WAIT_WORD_RANK: readonly string[] = [
+   'review requested',
    'waiting on re-CR',
    'waiting on CR',
    'with author',
@@ -554,6 +553,7 @@ export const WAIT_WORD_RANK: readonly string[] = [
    'waiting on QA',
    'in QA',
    'claimed',
+   'self-review',
    'stamped',
    'CI running',
    'CI failing',
diff --git a/frontend-v2/src/model/cheers.test.ts b/frontend-v2/src/model/cheers.test.ts
index 8de6411e..5389f0d3 100644
--- a/frontend-v2/src/model/cheers.test.ts
+++ b/frontend-v2/src/model/cheers.test.ts
@@ -34,6 +34,8 @@ function pull(
       status?: DerivedPull['status'];
       conflict?: boolean;
       starved?: boolean;
+      askedOf?: string[];
+      askedAt?: number | null;
    } = {}
 ): DerivedPull {
    return {
@@ -53,6 +55,8 @@ function pull(
       status: o.status ?? 'needs_cr',
       conflict: o.conflict ?? false,
       starved: o.starved ?? false,
+      askedOf: o.askedOf ?? [],
+      askedAt: o.askedAt ?? null,
    } as unknown as DerivedPull;
 }
 
@@ -67,14 +71,12 @@ function sig(o: Partial<Signals> & { queue?: number; pulls?: DerivedPull[] } = {
       qa: o.qa ?? 0,
       boardReviewable: o.boardReviewable ?? o.review ?? queue,
       restampKeys: o.restampKeys ?? new Set(),
-      turns: o.turns ?? new Map(),
       byKey: o.byKey ?? byKey,
       quickWinCount: o.quickWinCount ?? 0,
       quickWinPull: o.quickWinPull ?? null,
       bestStart: o.bestStart ?? null,
       startReason: o.startReason ?? '',
       backlog: o.backlog ?? 0,
-      debtors: o.debtors ?? [],
       authorPrs: o.authorPrs ?? new Map(),
       myRank: o.myRank ?? 0,
       myCount: o.myCount ?? 0,
@@ -125,7 +127,7 @@ describe('diffCheers — priming', () => {
             queue: 5,
             review: 5,
             restampKeys: new Set([pullKey(owed.data)]),
-            turns: new Map([[pullKey(owed.data), owed]]),
+            requestedOfMe: new Map([[pullKey(owed.data), owed]]),
             quickWinCount: 4,
             bestStart: startPull,
             backlog: 1,
@@ -221,23 +223,6 @@ describe('diffCheers — rewards', () => {
    });
 });
 
-describe('diffCheers — your-turn', () => {
-   it('nags a turn once, then forgets it once it is no longer yours', () => {
-      const base = primed(sig());
-      const p = pull('org/a', 9, { ageDays: 4 });
-      const turns = new Map([[pullKey(p.data), p]]);
-      const first = diffCheers(sig({ turns }), 'me', base);
-      expect(first.toasts.some(t => t.icon === '⏳' && t.pull?.number === 9)).toBe(true);
-      // still yours next tick: no repeat
-      const second = diffCheers(sig({ turns }), 'me', first.next);
-      expect(second.toasts.some(t => t.icon === '⏳')).toBe(false);
-      // leaves, then comes back: nags again
-      const gone = diffCheers(sig(), 'me', second.next);
-      const back = diffCheers(sig({ turns }), 'me', gone.next);
-      expect(back.toasts.some(t => t.icon === '⏳')).toBe(true);
-   });
-});
-
 describe('diffCheers — start-here', () => {
    it('does not fire on a prime tick with no backlog', () => {
       const { toasts } = diffCheers(sig({ backlog: 0, bestStart: null }), 'me', EMPTY_BASELINE);
@@ -267,27 +252,37 @@ describe('diffCheers — start-here', () => {
 });
 
 describe('startHereReason — priority order', () => {
-   it('prioritizes reciprocity over everything else', () => {
-      const target = pull('org/a', 1, { author: 'alice', ageDays: 10, weight: 'XS' });
-      const mine = pull('org/a', 2, { author: 'me', crBy: ['alice'] });
-      expect(startHereReason(target, [target, mine], 'me')).toBe(
-         'alice reviewed yours, return the favor'
-      );
+   it('a review asked of you leads, with how long ago', () => {
+      const target = pull('org/a', 1, {
+         author: 'alice',
+         weight: 'XS',
+         askedOf: ['me'],
+         askedAt: Date.now() / 1000 - 3.2 * 3600,
+      });
+      expect(startHereReason(target, 'me')).toBe('alice asked you 3h ago');
+      const undated = pull('org/a', 2, { author: 'alice', askedOf: ['me'] });
+      expect(startHereReason(undated, 'me')).toBe('alice asked you');
    });
 
-   it('does not treat a shared repo as a reason — falls through it', () => {
-      // an M-weight pull in a repo the viewer has stamped before: no "you know
-      // this repo" reason, so with no reciprocity or quick win it hits urgency
+   it('a review asked of someone else is no reason for you', () => {
+      const target = pull('org/a', 1, {
+         author: 'alice',
+         weight: 'M',
+         ageDays: 3,
+         askedOf: ['bob'],
+      });
+      expect(startHereReason(target, 'me')).toBe('Waiting 3d without a full CR');
+   });
+
+   it('has no favor to return: a review you got isn’t one you owe', () => {
+      // alice stamped one of mine; under self-review that earns her nothing
       const target = pull('org/a', 1, { author: 'alice', weight: 'M', ageDays: 3 });
-      const sameRepoStamped = pull('org/a', 2, { crBy: ['me'] });
-      expect(startHereReason(target, [target, sameRepoStamped], 'me')).toBe(
-         'Waiting 3d without a full CR'
-      );
+      expect(startHereReason(target, 'me')).toBe('Waiting 3d without a full CR');
    });
 
-   it('falls back to a quick-win when there is no reciprocity', () => {
+   it('falls back to a quick-win', () => {
       const target = pull('org/b', 1, { author: 'alice', weight: 'XS', sizeKnown: true });
-      expect(startHereReason(target, [target], 'me')).toBe('Small one (XS), quick');
+      expect(startHereReason(target, 'me')).toBe('Small one (XS), quick');
    });
 
    it('falls back to urgency when nothing else applies', () => {
@@ -297,7 +292,7 @@ describe('startHereReason — priority order', () => {
          sizeKnown: true,
          ageDays: 7,
       });
-      expect(startHereReason(target, [target], 'me')).toBe('Waiting 7d without a full CR');
+      expect(startHereReason(target, 'me')).toBe('Waiting 7d without a full CR');
    });
 });
 
@@ -341,31 +336,6 @@ describe('diffCheers — quick-wins', () => {
    });
 });
 
-describe('diffCheers — return-the-favor', () => {
-   it('fires once per debtor, then stays silent for that debtor', () => {
-      const base = primed(sig());
-      const p = pull('org/a', 9, { author: 'alice' });
-      const debtors = [{ login: 'alice', pull: p, count: 2 }];
-      const first = diffCheers(sig({ debtors }), 'me', base);
-      expect(first.toasts.some(t => t.dedupeKey === 'favor:alice')).toBe(true);
-      expect(first.toasts.some(t => t.body?.includes('2 of your PRs'))).toBe(true);
-      const second = diffCheers(sig({ debtors }), 'me', first.next);
-      expect(second.toasts.some(t => t.dedupeKey === 'favor:alice')).toBe(false);
-   });
-
-   it('fires separately for a second debtor in the same tick', () => {
-      const base = primed(sig());
-      const pAlice = pull('org/a', 1, { author: 'alice' });
-      const pBob = pull('org/a', 2, { author: 'bob' });
-      const debtors = [
-         { login: 'alice', pull: pAlice, count: 1 },
-         { login: 'bob', pull: pBob, count: 1 },
-      ];
-      const { toasts } = diffCheers(sig({ debtors }), 'me', base);
-      expect(toasts.filter(t => t.icon === '🤝')).toHaveLength(2);
-   });
-});
-
 describe('diffCheers — leaderboard', () => {
    it('fires top-of-board when you take #1, then stays silent while you hold it', () => {
       const base = primed(sig({ myRank: 2, myCount: 3 }));
@@ -689,13 +659,13 @@ describe('diffCheers — MAX_PER_TICK', () => {
       const base = primed(sig({ review: 5, restampKeys: new Set(), quickWinCount: 0 }));
       const p1 = pull('org/a', 1);
       const p2 = pull('org/a', 2, { ageDays: 4 });
-      const turns = new Map([[pullKey(p2.data), p2]]);
+      const requestedOfMe = new Map([[pullKey(p2.data), p2]]);
       const { toasts } = diffCheers(
          sig({
             review: 0, // board-cleared: highest priority of the four
             restampKeys: new Set([pullKey(p1.data)]), // re-stamp-owed
             pulls: [p1, p2],
-            turns, // your-turn
+            requestedOfMe, // review-requested
             quickWinCount: 3, // quick-wins: lowest priority of the four
          }),
          'me',
@@ -703,7 +673,7 @@ describe('diffCheers — MAX_PER_TICK', () => {
       );
       expect(toasts).toHaveLength(3);
       expect(toasts.some(t => t.dedupeKey === 'board:clear')).toBe(true);
-      expect(toasts.some(t => t.icon === '⏳')).toBe(true);
+      expect(toasts.some(t => t.icon === '✦')).toBe(true);
       expect(toasts.some(t => t.icon === '🔁')).toBe(true);
       expect(toasts.some(t => t.icon === '⚡')).toBe(false);
    });
@@ -713,13 +683,13 @@ describe('diffCheers — MAX_PER_TICK', () => {
       const base = primed(sig({ review: 5, restampKeys: new Set(), quickWinCount: 0 }));
       const p1 = pull('org/a', 1);
       const p2 = pull('org/a', 2, { ageDays: 4 });
-      const turns = new Map([[pullKey(p2.data), p2]]);
+      const requestedOfMe = new Map([[pullKey(p2.data), p2]]);
       const overflow = () =>
          sig({
             review: 0,
             restampKeys: new Set([pullKey(p1.data)]),
             pulls: [p1, p2],
-            turns,
+            requestedOfMe,
             quickWinCount: 3,
          });
       const first = diffCheers(overflow(), 'me', base);
@@ -731,7 +701,7 @@ describe('diffCheers — MAX_PER_TICK', () => {
       expect(second.toasts.some(t => t.icon === '⚡')).toBe(true);
       // and the survivors from tick one stay quiet (their marks stood)
       expect(second.toasts.some(t => t.dedupeKey === 'board:clear')).toBe(false);
-      expect(second.toasts.some(t => t.icon === '⏳')).toBe(false);
+      expect(second.toasts.some(t => t.icon === '✦')).toBe(false);
       expect(second.toasts.some(t => t.icon === '🔁')).toBe(false);
    });
 });
@@ -791,19 +761,13 @@ describe('evaluateCheers — loading guard', () => {
 
    it('no-ops and carries the baseline while the board is still loading', () => {
       // the empty snapshot the store publishes before the first payload lands
-      const { toasts, next } = evaluateCheers(
-         { pulls: [], turns: new Map(), me: 'me', ready: false },
-         primedBase
-      );
+      const { toasts, next } = evaluateCheers({ pulls: [], me: 'me', ready: false }, primedBase);
       expect(toasts).toEqual([]);
       expect(next).toBe(primedBase);
    });
 
    it('WOULD fire phantom clears against that empty board once ready — the bug the guard prevents', () => {
-      const { toasts } = evaluateCheers(
-         { pulls: [], turns: new Map(), me: 'me', ready: true },
-         primedBase
-      );
+      const { toasts } = evaluateCheers({ pulls: [], me: 'me', ready: true }, primedBase);
       const keys = toasts.map(t => t.dedupeKey);
       expect(keys).toContain('inbox:zero');
       expect(keys).toContain('board:clear');
@@ -834,7 +798,7 @@ describe('evaluateCheers — start-here and parked projects', () => {
       const other = reviewable(pull('org/a', 2, { author: 'bob', ageDays: 2 }));
       const start = (parked?: ReadonlyMap<string, string>) =>
          evaluateCheers(
-            { pulls: [parkedOne, other], turns: new Map(), me: 'me', ready: true, parked },
+            { pulls: [parkedOne, other], me: 'me', ready: true, parked },
             EMPTY_BASELINE
          ).toasts.find(t => t.dedupeKey?.startsWith('start:'))?.dedupeKey;
       expect(start()).toBe(`start:${pullKey(parkedOne.data)}`);
@@ -844,6 +808,42 @@ describe('evaluateCheers — start-here and parked projects', () => {
    });
 });
 
+describe('evaluateCheers — self-review', () => {
+   const reviewable = (p: DerivedPull, o: Partial<DerivedPull> = {}) =>
+      ({
+         ...p,
+         dependent: false,
+         qaingLogin: null,
+         crHave: 0,
+         qaHave: 0,
+         changesRequestedBy: [],
+         engagedNoStamp: [],
+         ciFailing: [],
+         headPushedAt: null,
+         devBlockedBy: [],
+         deployBlockedBy: [],
+         externalBlock: false,
+         cryo: false,
+         ...o,
+      } as DerivedPull);
+
+   it('never points you at a developer’s own unrequested PR', () => {
+      const own = reviewable(pull('org/a', 1, { author: 'alice', ageDays: 30, weight: 'XS' }), {
+         ownReview: true,
+      });
+      const { toasts } = evaluateCheers({ pulls: [own], me: 'me', ready: true }, EMPTY_BASELINE);
+      expect(toasts).toEqual([]);
+   });
+
+   it('a review asked of you, through a team too, is a review request and the place to start', () => {
+      const asked = reviewable(pull('org/a', 1, { author: 'alice', askedOf: ['me', 'bob'] }));
+      const first = evaluateCheers({ pulls: [], me: 'me', ready: true }, EMPTY_BASELINE);
+      const { toasts } = evaluateCheers({ pulls: [asked], me: 'me', ready: true }, first.next);
+      expect(toasts.some(t => t.dedupeKey === `req:${pullKey(asked.data)}`)).toBe(true);
+      expect(toasts.find(t => t.dedupeKey?.startsWith('start:'))?.body).toBe('alice asked you');
+   });
+});
+
 describe('cheer catalog', () => {
    it('documents exactly every toast kind, once each', () => {
       const catalogKinds = CHEER_CATALOG.map(c => c.kind);
@@ -891,8 +891,7 @@ describe('diffCheers — muting', () => {
       const build = (muted?: ReadonlySet<ToastKind>) =>
          diffCheers(
             sig({
-               restampKeys: new Set([pullKey(p1.data)]), // re-stamp-owed
-               turns: new Map([[pullKey(p2.data), p2]]), // your-turn
+               restampKeys: new Set([pullKey(p1.data), pullKey(p2.data)]), // two re-stamp-owed
                requestedOfMe: new Map([[pullKey(p3.data), p3]]), // review-requested (top)
                quickWinCount: 4, // quick-wins (lowest)
                pulls: [p1, p2, p3],
@@ -930,16 +929,12 @@ describe('diffCheers / startHereReason — display names', () => {
          undefined,
          names
       );
-      expect(toasts.some(t => t.body === 'Alice A asked you to review this.')).toBe(true);
-      expect(toasts.some(t => t.body === 'bob asked you to review this.')).toBe(true);
-   });
-
-   it('resolves the debtor’s name in return-the-favor', () => {
-      const base = primed(sig());
-      const p = pull('org/a', 9, { author: 'alice' });
-      const debtors = [{ login: 'alice', pull: p, count: 1 }];
-      const { toasts } = diffCheers(sig({ debtors }), 'me', base, undefined, names);
-      expect(toasts.some(t => t.title === 'Return the favor to Alice A')).toBe(true);
+      expect(
+         toasts.some(t => t.body === 'Alice A asked you to review this. Answer within hours.')
+      ).toBe(true);
+      expect(
+         toasts.some(t => t.body === 'bob asked you to review this. Answer within hours.')
+      ).toBe(true);
    });
 
    it('resolves the overtaker’s name in overtaken, but keys the dedupeKey off the raw login', () => {
@@ -989,11 +984,8 @@ describe('diffCheers / startHereReason — display names', () => {
       ).toBe(true);
    });
 
-   it('resolves the reciprocity author’s name in startHereReason', () => {
-      const target = pull('org/a', 1, { author: 'alice', ageDays: 10, weight: 'XS' });
-      const mine = pull('org/a', 2, { author: 'me', crBy: ['alice'] });
-      expect(startHereReason(target, [target, mine], 'me', false, names)).toBe(
-         'Alice A reviewed yours, return the favor'
-      );
+   it('resolves the requester’s name in startHereReason', () => {
+      const target = pull('org/a', 1, { author: 'alice', askedOf: ['me'] });
+      expect(startHereReason(target, 'me', false, names)).toBe('Alice A asked you');
    });
 });
diff --git a/frontend-v2/src/model/cheers.ts b/frontend-v2/src/model/cheers.ts
index 391620dc..23b754bf 100644
--- a/frontend-v2/src/model/cheers.ts
+++ b/frontend-v2/src/model/cheers.ts
@@ -1,10 +1,10 @@
 import { pullKey } from '../../../shared/format';
 import type { PullData } from '../../../shared/types';
-import { actionState, STALE_CLAIM_SECS } from './actions';
+import { actionState, askedHours, askedOf, STALE_CLAIM_SECS } from './actions';
 import { dealFrom, dealRank } from './deal';
 import { reviewerRanks } from './leaderboard';
 import { displayName } from './names';
-import { claimFor, reviewRequestedFrom } from './reviewers';
+import { claimFor } from './reviewers';
 import { crSort } from './sort';
 import { CR_INCOMPLETE, type DerivedPull } from '../../../shared/model/status';
 import type { Toast } from './toast';
@@ -51,14 +51,10 @@ export interface CheerBaseline {
    sessionStamps: number;
    /** milestone counts already celebrated */
    firedMilestones: ReadonlySet<number>;
-   /** turn-rotation pulls already nagged, so "your turn" fires once per pull */
-   seenTurns: ReadonlySet<string>;
    /** pull keys where you currently owe a re-stamp (recrBy/reqaBy has you) */
    restampKeys: ReadonlySet<string>;
    /** you've already been told about the current batch of quick wins */
    quickWinsNagged: boolean;
-   /** debtor logins already nudged for reciprocity this session */
-   favorsSeen: ReadonlySet<string>;
    /** your leaderboard rank last tick (0 = unranked / no stamps in view) */
    myRank: number;
    /** your stamp count last tick — climbing requires it to have GROWN, so a
@@ -88,10 +84,8 @@ export const EMPTY_BASELINE: CheerBaseline = {
    queue: 0,
    sessionStamps: 0,
    firedMilestones: new Set(),
-   seenTurns: new Set(),
    restampKeys: new Set(),
    quickWinsNagged: false,
-   favorsSeen: new Set(),
    myRank: 0,
    myCount: 0,
    wasTop: false,
@@ -106,7 +100,7 @@ export const EMPTY_BASELINE: CheerBaseline = {
  * Flatten a baseline to a JSON-safe shape (Sets → arrays, the Map → entries)
  * so it can ride in sessionStorage. Persisting the baseline is what stops a
  * page reload from re-priming off EMPTY_BASELINE and replaying every load-time
- * greeting (start-here, return-the-favor, the shipped catch-up); a reload
+ * greeting (start-here, the shipped catch-up); a reload
  * instead resumes the diff, so only what genuinely changed while away speaks.
  */
 export function serializeBaseline(b: CheerBaseline): unknown {
@@ -117,10 +111,8 @@ export function serializeBaseline(b: CheerBaseline): unknown {
       queue: b.queue,
       sessionStamps: b.sessionStamps,
       firedMilestones: [...b.firedMilestones],
-      seenTurns: [...b.seenTurns],
       restampKeys: [...b.restampKeys],
       quickWinsNagged: b.quickWinsNagged,
-      favorsSeen: [...b.favorsSeen],
       myRank: b.myRank,
       myCount: b.myCount,
       wasTop: b.wasTop,
@@ -148,10 +140,8 @@ export function reviveBaseline(raw: unknown): CheerBaseline | null {
          queue: Number(o.queue) || 0,
          sessionStamps: Number(o.sessionStamps) || 0,
          firedMilestones: new Set(arr(o.firedMilestones) as number[]),
-         seenTurns: new Set(arr(o.seenTurns) as string[]),
          restampKeys: new Set(arr(o.restampKeys) as string[]),
          quickWinsNagged: !!o.quickWinsNagged,
-         favorsSeen: new Set(arr(o.favorsSeen) as string[]),
          myRank: Number(o.myRank) || 0,
          myCount: Number(o.myCount) || 0,
          wasTop: !!o.wasTop,
@@ -168,10 +158,6 @@ export function reviveBaseline(raw: unknown): CheerBaseline | null {
 
 interface CheerInput {
    pulls: DerivedPull[];
-   /** whose turn each starved, unclaimed pull is (pull key → login), computed
-    * once in app.tsx and shared by the rows, desktop notifications, and these
-    * cheers — three surfaces, one rotation read */
-   turns: ReadonlyMap<string, string>;
    /** closed pulls in the loaded window, for the leaderboard's tally — optional
     * so older callers still typecheck; an absent window just ranks off the
     * open board. */
@@ -188,7 +174,7 @@ interface CheerInput {
     * than firing then hiding it. */
    muted?: ReadonlySet<ToastKind>;
    /** pull keys the viewer snoozed ("not today") in the Review lens — excluded
-    * from the reviewable pool so start-here / quick-wins / your-turn cheers
+    * from the reviewable pool so start-here / quick-wins cheers
     * don't re-nudge a pull you just deferred. */
    snoozed?: ReadonlySet<string>;
    /** login → human display name (model/names.ts) — turns a GitHub login into
@@ -241,9 +227,7 @@ function pick(list: string[], seed: number): string {
    return list[((seed % list.length) + list.length) % list.length];
 }
 
-/** Has `login` landed an active CR or QA stamp on this pull? Mirrors
- * deal.ts's private helper — duplicated rather than imported so this stays a
- * small, self-contained pure check like the rest of model/. */
+/** Has `login` landed an active CR or QA stamp on this pull? */
 function hasStamp(p: DerivedPull, login: string): boolean {
    return p.crBy.includes(login) || p.qaBy.includes(login);
 }
@@ -252,10 +236,11 @@ function hasStamp(p: DerivedPull, login: string): boolean {
 const claimOf = (p: DerivedPull) => claimFor(p.data);
 
 /**
- * The one-line "why this pull" for start-here, in priority order: returning a
- * favor beats a quick win beats plain urgency. `pulls` is the whole board (not
- * just the queue) so reciprocity can look across every author the viewer has
- * reviewed, matching deal.ts's own scoring.
+ * The one-line "why this pull" for start-here, in priority order: a review
+ * asked of you beats a quick win beats plain waiting. Only pulls that are
+ * someone else's review work get here (asked of you, outside the dev team,
+ * bots), so there's no favor to return: under self-review nobody owes
+ * anyone a review for one they got.
  *
  * There's deliberately no "you know this repo" reason: in a monorepo everyone
  * has stamped something in it, so it's both always true and no motivation at
@@ -263,15 +248,16 @@ const claimOf = (p: DerivedPull) => claimFor(p.data);
  */
 export function startHereReason(
    p: DerivedPull,
-   pulls: DerivedPull[],
    me: string,
    superlative = false,
    names: Readonly<Record<string, string | null>> = {}
 ): string {
    const author = p.data.user.login;
-   const owedByAuthor = pulls.some(o => o.data.user.login === me && hasStamp(o, author));
-   if (owedByAuthor)
-      return `${displayName(names, author) ?? author} reviewed yours, return the favor`;
+   if (askedOf(p).includes(me)) {
+      const h = askedHours(p);
+      const when = h == null ? '' : h < 1 ? ' just now' : ` ${h}h ago`;
+      return `${displayName(names, author) ?? author} asked you${when}`;
+   }
    const quickWin = p.weight === 'XS' || p.weight === 'S';
    if (quickWin) return `Small one (${p.weight}), quick`;
    const days = Math.max(1, Math.round(p.ageDays));
@@ -321,8 +307,6 @@ export interface Signals {
    boardReviewable: number;
    /** pull keys where you currently owe a re-stamp */
    restampKeys: Set<string>;
-   /** pull keys the rotation currently names the viewer for, unclaimed */
-   turns: Map<string, DerivedPull>;
    /** the pull behind each key, for a toast's body/link */
    byKey: Map<string, DerivedPull>;
    /** unclaimed XS/S reviewable pulls on the board right now */
@@ -333,9 +317,6 @@ export interface Signals {
    startReason: string;
    /** unclaimed reviewable count (excludes claimed pulls, unlike `review`) */
    backlog: number;
-   /** authors who owe you a favor and have an open reviewable PR, in a
-    * deterministic order; one entry per debtor */
-   debtors: { login: string; pull: DerivedPull; count: number }[];
    authorPrs: Map<string, AuthorPrState>;
    myRank: number;
    myCount: number;
@@ -346,8 +327,9 @@ export interface Signals {
    staleClaims: Map<string, DerivedPull>;
    /** the claim-warn threshold as loose words ("an hour"), for the nudge copy */
    staleClaimAfter: string;
-   /** pulls GitHub has asked YOU to review (and you haven't yet), for the
-    * review-requested toast — the most direct "review this" the board carries */
+   /** pulls asked of YOU (by name or through a team) that you haven't
+    * stamped yet, for the review-requested toast: the most direct "review
+    * this" the board carries */
    requestedOfMe: Map<string, DerivedPull>;
    /** logins holding each rank right now, you excluded, keyed by rank number —
     * the leaderboard neighborhood the overtaken nudge reads to name whoever
@@ -361,7 +343,6 @@ function readSignals(input: CheerInput): Signals {
    const snoozed = input.snoozed ?? new Set<string>();
    const now = input.now ?? Date.now();
    const stamped = new Set<string>();
-   const turns = new Map<string, DerivedPull>();
    const byKey = new Map<string, DerivedPull>();
    const restampKeys = new Set<string>();
    let review = 0;
@@ -378,10 +359,6 @@ function readSignals(input: CheerInput): Signals {
       if (st === 'review') review++;
       else if (st === 'qa') qa++;
       else if (st === 'restamp') restampKeys.add(key);
-      // a starved BOT pull shouldn't tap you with "your turn — you're the best
-      // fit"; bots are handled on their own low-priority cadence, not the rotation
-      if (!mine && !isBot(p) && !claimOf(p) && !snoozed.has(key) && input.turns.get(key) === me)
-         turns.set(key, p);
    }
 
    const reviewableUnclaimed = pulls.filter(
@@ -406,32 +383,9 @@ function readSignals(input: CheerInput): Signals {
       }),
       { passed: new Set() }
    );
-   const startReason = bestStart
-      ? startHereReason(bestStart, pulls, me, true, input.names ?? {})
-      : '';
+   const startReason = bestStart ? startHereReason(bestStart, me, true, input.names ?? {}) : '';
 
-   // reciprocity: who has stamped one of your own pulls, and do they have an
-   // open reviewable pull of their own right now?
    const myPulls = pulls.filter(p => p.data.user.login === me);
-   const debtorPullKeys = new Map<string, Set<string>>();
-   for (const p of myPulls) {
-      const key = pullKey(p.data);
-      for (const login of new Set([...p.crBy, ...p.qaBy])) {
-         const keys = debtorPullKeys.get(login) ?? new Set<string>();
-         keys.add(key);
-         debtorPullKeys.set(login, keys);
-      }
-   }
-   const debtors: { login: string; pull: DerivedPull; count: number }[] = [];
-   const seenDebtor = new Set<string>();
-   for (const p of crSort(reviewableUnclaimed)) {
-      const author = p.data.user.login;
-      const count = debtorPullKeys.get(author)?.size ?? 0;
-      if (count > 0 && !seenDebtor.has(author)) {
-         seenDebtor.add(author);
-         debtors.push({ login: author, pull: p, count });
-      }
-   }
 
    const authorPrs = new Map<string, AuthorPrState>();
    // parked pulls sit out the edge system entirely: "ready to merge",
@@ -457,11 +411,11 @@ function readSignals(input: CheerInput): Signals {
    ).length;
 
    // claims of yours gone stale that you still haven't stamped — the nudge to
-   // either finish the review or release it back to the pool. The threshold is
+   // either finish the review or drop it. The threshold is
    // the viewer's claim-warn setting (30m–4h), so the copy has to say the real
    // number, not a hardcoded "a couple hours". A claim with no `at` (metadata
    // not yet backfilled after a server restart) can't be proven stale, so it
-   // never nags — same rule model/actions.ts's withCoordination applies.
+   // never nags.
    const warnMs = input.claimWarnMs ?? STALE_CLAIM_MS;
    const staleClaimAfter = durationPhrase(warnMs);
    const staleClaims = new Map<string, DerivedPull>();
@@ -480,18 +434,16 @@ function readSignals(input: CheerInput): Signals {
       }
    }
 
-   // GitHub asked you to review these and you haven't stamped them — a direct
-   // request, distinct from the rotation's guess (which stays silent on
-   // requested pulls). reviewRequestedFrom already excludes a self-claim (see
-   // model/reviewers.ts), so a pull you've claimed yourself never lands here.
-   // Drives the review-requested toast.
+   // the author asked you to review these (askedOf leaves out claims, so a
+   // pull you took on yourself never lands here) and you haven't stamped
+   // them. Drives the review-requested toast.
    const requestedOfMe = new Map<string, DerivedPull>();
    for (const p of pulls) {
       const key = pullKey(p.data);
       if (
          !p.cryo &&
          CR_INCOMPLETE.includes(p.status) &&
-         reviewRequestedFrom(p, me) &&
+         askedOf(p).includes(me) &&
          !p.crBy.includes(me)
       ) {
          requestedOfMe.set(key, p);
@@ -528,14 +480,12 @@ function readSignals(input: CheerInput): Signals {
       qa,
       boardReviewable,
       restampKeys,
-      turns,
       byKey,
       quickWinCount: quickWinCandidates.length,
       quickWinPull,
       bestStart,
       startReason,
       backlog: reviewableUnclaimed.length,
-      debtors,
       authorPrs,
       myRank,
       myCount,
@@ -576,10 +526,8 @@ export const PRIORITY_ORDER = [
    'stamp-landed',
    'pr-first-review',
    'review-requested',
-   'your-turn',
    're-stamp-owed',
    'claim-stale',
-   'return-the-favor',
    'start-here',
    'quick-wins',
    'pr-ci-red',
@@ -587,7 +535,7 @@ export const PRIORITY_ORDER = [
    'pr-conflicts',
    'pr-starving',
 ] as const;
-export type ToastKind = (typeof PRIORITY_ORDER)[number];
+export type ToastKind = typeof PRIORITY_ORDER[number];
 const PRIORITY: Record<ToastKind, number> = Object.fromEntries(
    PRIORITY_ORDER.map((kind, i) => [kind, PRIORITY_ORDER.length - i])
 ) as Record<ToastKind, number>;
@@ -611,7 +559,7 @@ export const CHEER_CATALOG: {
 }[] = [
    // Each label matches the toast's own headline so a toast you see maps to
    // an obvious switch — no guessing. Where the headline leads with a count or
-   // a name ("5 stamps in view", "Return the favor to alice"), the label is
+   // a name ("5 stamps in view", "alice took your #2 spot"), the label is
    // its stable phrase. stamp-landed is the one exception: its headline rotates
    // ("Nice one." / "Keep 'em coming." / "Clean."), so the label names the
    // event and the hint quotes the phrases.
@@ -656,14 +604,14 @@ export const CHEER_CATALOG: {
       kind: 'pr-green',
       group: 'reward',
       label: 'Green, ship it',
-      hint: 'A PR of yours clears CR and QA, ready to ship.',
+      hint: 'A PR of yours is signed off and green, ready to merge.',
    },
    // Nudges — what to review next
    {
       kind: 'start-here',
       group: 'nudge',
       label: 'Start here',
-      hint: 'The single best pull to pick up next.',
+      hint: 'The best review to pick up next: one asked of you first.',
    },
    {
       kind: 'quick-wins',
@@ -675,13 +623,7 @@ export const CHEER_CATALOG: {
       kind: 'review-requested',
       group: 'nudge',
       label: 'Review requested',
-      hint: 'Someone asked for your review on GitHub.',
-   },
-   {
-      kind: 'your-turn',
-      group: 'nudge',
-      label: 'Your turn to review',
-      hint: 'You’re the best-matched reviewer for a long-waiting, unclaimed PR.',
+      hint: 'Someone asked you, or a team you’re on, for a review on GitHub.',
    },
    {
       kind: 're-stamp-owed',
@@ -689,17 +631,11 @@ export const CHEER_CATALOG: {
       label: 'Changed since your ✓',
       hint: 'A PR you approved changed and wants another look.',
    },
-   {
-      kind: 'return-the-favor',
-      group: 'nudge',
-      label: 'Return the favor',
-      hint: 'Someone who reviewed your PRs has one open.',
-   },
    {
       kind: 'claim-stale',
       group: 'nudge',
-      label: 'Claimed but still unreviewed',
-      hint: 'A review you claimed has sat unreviewed too long.',
+      label: 'Said you’d review, still unreviewed',
+      hint: 'A review you said you’d do has sat too long.',
    },
    {
       kind: 'overtaken',
@@ -736,7 +672,7 @@ export const CHEER_CATALOG: {
       kind: 'pr-starving',
       group: 'author',
       label: 'Waiting for review',
-      hint: 'Your PR has gone a while with no review.',
+      hint: 'A PR you asked for review on has gone a while without one.',
    },
 ];
 
@@ -784,7 +720,7 @@ export function diffCheers(
    muted: ReadonlySet<ToastKind> = NO_MUTED,
    /** login → human display name, for the same login→name swap as
     * startHereReason's own `names` param — threaded here too since these
-    * builders (review-requested, return-the-favor, overtaken,
+    * builders (review-requested, overtaken,
     * pr-first-review) construct their text directly, not through
     * startHereReason. */
    names: Readonly<Record<string, string | null>> = {}
@@ -803,10 +739,8 @@ export function diffCheers(
             queue: sig.queue,
             sessionStamps: 0,
             firedMilestones: new Set(),
-            seenTurns: new Set(sig.turns.keys()),
             restampKeys: sig.restampKeys,
             quickWinsNagged: sig.quickWinCount >= QUICK_WIN_THRESHOLD,
-            favorsSeen: new Set(),
             myRank: sig.myRank,
             myCount: sig.myCount,
             wasTop: sig.myRank === 1,
@@ -908,31 +842,9 @@ export function diffCheers(
       );
    }
 
-   // the rotation newly named you on a starved pull. Next tick's seenTurns is
-   // just the current turn keys — a pull that stops being yours is forgotten,
-   // so if it later comes back around it can nag again.
-   const seenTurns = new Set(sig.turns.keys());
-   for (const [key, p] of sig.turns) {
-      if (base.seenTurns.has(key)) continue;
-      push(
-         'your-turn',
-         {
-            tone: 'nag',
-            icon: '⏳',
-            title: 'Your turn to review',
-            body: `Waiting ${Math.max(1, Math.round(p.ageDays))}d with nobody on it; you're the best fit. Claim it?`,
-            pull: pullRef(p),
-            actionLabel: 'Claim it',
-            dedupeKey: `turn:${key}`,
-         },
-         () => seenTurns.delete(key)
-      );
-   }
-
-   // review requested: GitHub asked you directly. Fires once per pull (rebuilt
-   // from the current tick, seenTurns-style, so a dropped-then-re-added request
-   // can nag again). Distinct from your-turn: this is an explicit ask, not the
-   // rotation's guess — which is why turnFor stays silent on requested pulls.
+   // review requested: the author asked you directly. Fires once per pull
+   // (rebuilt from the current tick, so a dropped-then-re-added request can
+   // nag again).
    const requestedSeen = new Set(sig.requestedOfMe.keys());
    for (const [key, p] of sig.requestedOfMe) {
       if (base.requestedSeen.has(key)) continue;
@@ -942,7 +854,9 @@ export function diffCheers(
             tone: 'info',
             icon: '✦',
             title: 'Review requested',
-            body: `${displayName(names, p.data.user.login) ?? p.data.user.login} asked you to review this.`,
+            body: `${
+               displayName(names, p.data.user.login) ?? p.data.user.login
+            } asked you to review this. Answer within hours.`,
             pull: pullRef(p),
             dedupeKey: `req:${key}`,
          },
@@ -988,8 +902,8 @@ export function diffCheers(
    for (const p of newRestamps.slice(MAX_PER_TICK)) restampKeys.delete(pullKey(p.data));
 
    // a claim of yours went stale (2h+) and you still haven't stamped it —
-   // nudge once per pull to finish it or hand it back. seenTurns-style rebuild
-   // from the current tick, so releasing then re-claiming can nag again.
+   // nudge once per pull to finish it or drop it. Rebuilt from the current
+   // tick, so dropping then re-claiming can nag again.
    const staleClaimsSeen = new Set(sig.staleClaims.keys());
    for (const [key, p] of sig.staleClaims) {
       if (base.staleClaimsSeen.has(key)) continue;
@@ -998,8 +912,8 @@ export function diffCheers(
          {
             tone: 'nag',
             icon: '✋',
-            title: 'You claimed this, still unreviewed',
-            body: `It's been ${sig.staleClaimAfter}. Review it, or release it for someone else.`,
+            title: 'You said you’d review this',
+            body: `It's been ${sig.staleClaimAfter}. Review it, or drop it so the author knows.`,
             pull: pullRef(p),
             dedupeKey: `claimstale:${key}`,
          },
@@ -1029,28 +943,6 @@ export function diffCheers(
       quickWinsNagged = false;
    }
 
-   // return the favor: a debtor's open reviewable pull, nudged once per debtor
-   const favorsSeen = new Set(base.favorsSeen);
-   for (const { login, pull: p, count } of sig.debtors) {
-      if (favorsSeen.has(login)) continue;
-      favorsSeen.add(login);
-      push(
-         'return-the-favor',
-         {
-            tone: 'info',
-            icon: '🤝',
-            title: `Return the favor to ${displayName(names, login) ?? login}`,
-            body:
-               count === 1
-                  ? 'They reviewed one of your PRs.'
-                  : `They've reviewed ${count} of your PRs.`,
-            pull: pullRef(p),
-            dedupeKey: `favor:${login}`,
-         },
-         () => favorsSeen.delete(login)
-      );
-   }
-
    // leaderboard: top and climbing. Evicted edges hold last tick's rank/top
    // state in the baseline so they re-fire while the standing persists.
    let nextWasTop = sig.myRank === 1;
@@ -1123,7 +1015,9 @@ export function diffCheers(
             {
                tone: 'nag',
                icon: '📉',
-               title: `${displayName(names, overtaker) ?? overtaker} took your #${base.myRank} spot`,
+               title: `${displayName(names, overtaker) ?? overtaker} took your #${
+                  base.myRank
+               } spot`,
                body: `You're #${sig.myRank} on the board now.`,
                dedupeKey: `overtaken:${base.myRank}:${overtaker}`,
             },
@@ -1156,7 +1050,7 @@ export function diffCheers(
                tone: 'reward',
                icon: '🚀',
                title: 'Green, ship it',
-               body: 'CR + QA both cleared.',
+               body: 'Signed off and green.',
                pull: pullRef(p),
                celebrate: true,
                shimmer: true,
@@ -1176,7 +1070,9 @@ export function diffCheers(
                tone: 'info',
                icon: '👀',
                title: 'Someone picked up your PR',
-               body: `${firstReviewer ? (displayName(names, firstReviewer) ?? firstReviewer) : 'A reviewer'} is on it.`,
+               body: `${
+                  firstReviewer ? displayName(names, firstReviewer) ?? firstReviewer : 'A reviewer'
+               } is on it.`,
                pull: pullRef(p),
                dedupeKey: `firstrev:${key}`,
             },
@@ -1232,7 +1128,9 @@ export function diffCheers(
                tone: 'nag',
                icon: '🕰️',
                title: `Waiting ${p.ageDays}d for review`,
-               body: 'Your PR, worth a nudge?',
+               body: askedOf(p).length
+                  ? `Asked of ${askedOf(p).join(', ')}, worth a nudge?`
+                  : 'Your PR, worth a nudge?',
                pull: pullRef(p),
                dedupeKey: `starve:${key}`,
             },
@@ -1277,10 +1175,8 @@ export function diffCheers(
          queue: nextQueue,
          sessionStamps,
          firedMilestones,
-         seenTurns,
          restampKeys,
          quickWinsNagged,
-         favorsSeen,
          myRank: nextMyRank,
          myCount: nextMyCount,
          wasTop: nextWasTop,
diff --git a/frontend-v2/src/model/deal.test.ts b/frontend-v2/src/model/deal.test.ts
index 4358d9b5..931902f1 100644
--- a/frontend-v2/src/model/deal.test.ts
+++ b/frontend-v2/src/model/deal.test.ts
@@ -21,6 +21,7 @@ function dp(o: {
    deletions?: number;
    headPushedAt?: number | null;
    reviewRequests?: { login: string; at: number | null; self: boolean }[];
+   ownReview?: boolean;
 }): DerivedPull {
    return {
       data: {
@@ -42,6 +43,7 @@ function dp(o: {
       weight: o.weight ?? 'M',
       sizeKnown: o.sizeKnown ?? true,
       headPushedAt: o.headPushedAt ?? null,
+      ownReview: o.ownReview ?? false,
    } as unknown as DerivedPull;
 }
 
@@ -103,13 +105,20 @@ describe('deal rank+from — scoring bumps', () => {
       expect(deal([familiarRepoPull, unfamiliarRepoPull], opts)).toBe(familiarRepoPull);
    });
 
-   it("reciprocity: an author who has stamped one of my pulls outranks one who hasn't", () => {
-      const reciprocalAuthorPull = dp({ author: 'alice', number: 1 });
-      const strangerPull = dp({ author: 'bob', number: 2 });
-      // alice stamped one of my own authored pulls elsewhere on the board
+   it('no reciprocity: a review you got earns its author nothing under self-review', () => {
+      const aliceNewer = dp({ author: 'alice', number: 1, ageDays: 1 });
+      const bobOlder = dp({ author: 'bob', number: 2, ageDays: 2 });
+      // alice stamped one of my own pulls; the older one still deals first
       const myPullAliceStamped = dp({ author: 'me', number: 99, crBy: ['alice'] });
-      const opts = baseOpts({ pulls: [reciprocalAuthorPull, strangerPull, myPullAliceStamped] });
-      expect(deal([reciprocalAuthorPull, strangerPull], opts)).toBe(reciprocalAuthorPull);
+      const opts = baseOpts({ pulls: [aliceNewer, bobOlder, myPullAliceStamped] });
+      expect(deal([aliceNewer, bobOlder], opts)).toBe(bobOlder);
+   });
+
+   it('never deals a developer’s own unrequested pull: its review is its author’s', () => {
+      const own = dp({ author: 'alice', number: 1, ageDays: 30, ownReview: true });
+      const outside = dp({ author: 'bob', number: 2 });
+      expect(deal([own, outside], baseOpts())).toBe(outside);
+      expect(deal([own], baseOpts())).toBeNull();
    });
 
    it('quick win: a known XS pull outranks an otherwise-identical unknown-size pull', () => {
diff --git a/frontend-v2/src/model/deal.ts b/frontend-v2/src/model/deal.ts
index eccc9bed..7089bf61 100644
--- a/frontend-v2/src/model/deal.ts
+++ b/frontend-v2/src/model/deal.ts
@@ -1,4 +1,5 @@
 import { pullKey } from '../../../shared/format';
+import { selfReviewed } from './actions';
 import { claimFor } from './reviewers';
 import { crSort } from './sort';
 import { STARVE_DAYS, type DerivedPull } from '../../../shared/model/status';
@@ -6,8 +7,8 @@ import { STARVE_DAYS, type DerivedPull } from '../../../shared/model/status';
 /**
  * The review queue's one ranking. dealRank orders a pool by the same score
  * "Deal me one" uses — crSort's deterministic base re-ranked by urgency plus
- * two social signals crSort doesn't know about (have I reviewed this repo
- * before; does this author owe me one) — and dealFrom hands out the first
+ * one signal crSort doesn't know about (have I reviewed this repo before) —
+ * and dealFrom hands out the first
  * still-available entry of that order. The lane renders dealRank's output
  * verbatim, so the button always deals the top visible card that's still up
  * for grabs: the list and the button can't disagree.
@@ -15,9 +16,9 @@ import { STARVE_DAYS, type DerivedPull } from '../../../shared/model/status';
 
 export interface DealRankOptions {
    me: string;
-   /** the whole board's derived pulls (not just the queue) — familiarity and
-    * reciprocity look across every repo/author the viewer touches, not only
-    * the pulls up for grabs right now. */
+   /** the whole board's derived pulls (not just the queue) — familiarity
+    * looks across every repo the viewer touches, not only the pulls up for
+    * grabs right now. */
    pulls: DerivedPull[];
    /** pulls to hand out only once everything else is gone (bot PRs): they still
     * need a reviewer, but shouldn't jump ahead of human work however old they
@@ -45,23 +46,21 @@ function isClaimed(p: DerivedPull): boolean {
  *    for a fresh one, ageDays normalized against the starvation threshold —
  *    so a two-day-old pull still edges out a same-day one without needing to
  *    hit the starvation cliff first.
- *  - +2 familiarity: the viewer has stamped this repo before — less context
- *    to load before reviewing.
- *  - +2 reciprocity: this pull's author has stamped one of the viewer's own
- *    pulls — a nudge toward returning the favor.
+ *  - +2 familiarity: the viewer has stamped someone else's pull in this repo
+ *    before — less context to load before reviewing.
  *  - +1 quick win: a known XS/S pull, a small bias toward clearing easy ones.
- * In units of the urgency ramp: one is warnDays of waiting.
+ * In units of the urgency ramp: one is warnDays of waiting. There's no
+ * reciprocity term: under self-review a review you got isn't one you owe.
  */
 export function dealScore(p: DerivedPull, opts: DealRankOptions): number {
    const urgency = p.starved ? p.starveScore : p.ageDays / (opts.warnDays ?? STARVE_DAYS);
    const repo = p.data.repo;
-   const author = p.data.user.login;
-   const familiar = opts.pulls.some(other => other.data.repo === repo && hasStamp(other, opts.me));
-   const owedByAuthor = opts.pulls.some(
-      other => other.data.user.login === opts.me && hasStamp(other, author)
+   const familiar = opts.pulls.some(
+      other =>
+         other.data.repo === repo && other.data.user.login !== opts.me && hasStamp(other, opts.me)
    );
    const quickWin = p.weight === 'XS' || p.weight === 'S';
-   return urgency + (familiar ? 2 : 0) + (owedByAuthor ? 2 : 0) + (quickWin ? 1 : 0);
+   return urgency + (familiar ? 2 : 0) + (quickWin ? 1 : 0);
 }
 
 /**
@@ -87,7 +86,9 @@ export function dealRank(pool: DerivedPull[], opts: DealRankOptions): DerivedPul
 
 /**
  * Deal the first still-available entry of an already-ranked list — skipping
- * anything claimed or already passed this sitting. Takes the *rendered* queue
+ * anything claimed or already passed this sitting, and a developer's own
+ * unrequested pull, whose review is its author's (the lanes never rank one;
+ * this keeps the deal honest whatever list it's handed). Takes the *rendered* queue
  * (dealRank order, team-pinning and all) rather than re-ranking, so the card
  * dealt is by construction the top visible one still up for grabs.
  */
@@ -100,7 +101,7 @@ export function dealFrom(
 ): DerivedPull | null {
    for (const p of ranked) {
       const key = pullKey(p.data);
-      if (opts.passed.has(key) || isClaimed(p)) continue;
+      if (opts.passed.has(key) || isClaimed(p) || selfReviewed(p)) continue;
       return p;
    }
    return null;
diff --git a/frontend-v2/src/model/notificationRelevance.ts b/frontend-v2/src/model/notificationRelevance.ts
index 40a9cf8e..dd497a05 100644
--- a/frontend-v2/src/model/notificationRelevance.ts
+++ b/frontend-v2/src/model/notificationRelevance.ts
@@ -17,12 +17,12 @@ function toastPullKeys(toast: Toast): string[] {
 /**
  * Whether a fired notification has gone stale: the PR it points you at has left
  * the open board (merged or closed), so whatever it asked you to do can't be
- * done anymore. The notification panel drops these, so a nudge like "return the
- * favor on fixbot#3116" removes itself the moment #3116 merges instead of
+ * done anymore. The notification panel drops these, so a nudge like "review
+ * requested on fixbot#3116" removes itself the moment #3116 merges instead of
  * lingering as a dead link (prod report, Kyle 2026-07-27).
  *
- * Deliberately general -- every PR-linked kind, not just return-the-favor -- so
- * one rule governs the whole panel. Two shapes are never stale: a toast with no
+ * Deliberately general -- every PR-linked kind -- so one rule governs the
+ * whole panel. Two shapes are never stale: a toast with no
  * PR (inbox-zero, board-cleared, a milestone count), since there's nothing to
  * resolve, and a retrospective recap (shipped), which lists merged PRs on
  * purpose. A toast pointing at several pulls is stale only once every one of
diff --git a/frontend-v2/src/model/portfolio.ts b/frontend-v2/src/model/portfolio.ts
index 3ca6c34b..84698feb 100644
--- a/frontend-v2/src/model/portfolio.ts
+++ b/frontend-v2/src/model/portfolio.ts
@@ -874,7 +874,7 @@ export function portfolioCsv(items: readonly PortfolioItem[]): string {
       'Days since last activity',
       'Worked on it, last 14 days',
       'Open PRs',
-      'Waiting on review',
+      'In review',
       'Merged, last 14 days',
       'Plan',
       'Issues open',
diff --git a/frontend-v2/src/model/query.test.ts b/frontend-v2/src/model/query.test.ts
index 021f5bac..28892dc0 100644
--- a/frontend-v2/src/model/query.test.ts
+++ b/frontend-v2/src/model/query.test.ts
@@ -15,6 +15,7 @@ function fake(
       weight: Weight;
       recrBy: string[];
       reqaBy: string[];
+      askedOf: string[];
    }>
 ): DerivedPull {
    return {
@@ -44,6 +45,7 @@ function fake(
       cryo: false,
       changesRequestedBy: [],
       engagedNoStamp: [],
+      askedOf: over.askedOf ?? [],
       data: {
          title: over.title ?? 'Fix the store dropdown',
          repo: over.repo ?? 'acme/widgets',
@@ -131,6 +133,13 @@ describe('matchesQuery', () => {
       ).toBe(false);
    });
 
+   it('is:asked matches a review asked of the viewer, by name or through a team', () => {
+      const p = fake({ askedOf: ['bob', 'carol'] });
+      expect(matchesQuery(p, 'is:asked', 'bob')).toBe(true);
+      expect(matchesQuery(p, 'is:asked', 'dave')).toBe(false);
+      expect(matchesQuery(fake({}), 'is:asked', 'bob')).toBe(false);
+   });
+
    it('is:blocked matches dev_block and deploy_block statuses only', () => {
       expect(matchesQuery(fake({ status: 'dev_block' }), 'is:blocked', 'viewer')).toBe(true);
       expect(matchesQuery(fake({ status: 'deploy_block' }), 'is:blocked', 'viewer')).toBe(true);
diff --git a/frontend-v2/src/model/query.ts b/frontend-v2/src/model/query.ts
index 1284eff9..96801694 100644
--- a/frontend-v2/src/model/query.ts
+++ b/frontend-v2/src/model/query.ts
@@ -1,4 +1,4 @@
-import { authorOwnsIt, parked, rowNote } from './actions';
+import { askedOf, authorOwnsIt, parked, rowNote } from './actions';
 import type { DerivedPull } from '../../../shared/model/status';
 import type { PullData } from '../../../shared/types';
 import { isBotLogin } from '../../../shared/model/visibility';
@@ -16,6 +16,7 @@ import { isBotLogin } from '../../../shared/model/visibility';
  *   weight:xs,s   review-effort class, comma list ORs (weight:xs,s = XS or S)
  *   has:action    the viewer (`me`) has an imperative move on this card
  *   is:restamp    `me` owes a re-CR or re-QA on a reviewable pull
+ *   is:asked      a review was asked of `me` (by name or through a team)
  *   is:blocked    status is dev_block or deploy_block
  *   is:bot        the author is a bot: the `[bot]` suffix OR a login named in
  *                 config.json's `bots` list (the caller's `extraBots` set) —
@@ -74,6 +75,7 @@ function matchTerm(
                return (
                   !parked(p) && !authorOwnsIt(p) && (p.recrBy.includes(me) || p.reqaBy.includes(me))
                );
+            if (val === 'asked') return askedOf(p).includes(me);
             if (val === 'blocked') return p.status === 'dev_block' || p.status === 'deploy_block';
             if (val === 'draft') return p.status === 'draft';
             if (val === 'mine') return d.user.login.toLowerCase() === me.toLowerCase();
@@ -100,7 +102,7 @@ function matchTerm(
  * search lens runs this so a merged or closed PR is findable by the identity
  * terms people actually search on: bare text, #number, repo:, author:, label:,
  * is:bot, is:mine. Tokens that describe a live board state (status:, weight:,
- * older:, has:action, is:restamp/blocked/draft) can't hold on something already
+ * older:, has:action, is:restamp/asked/blocked/draft) can't hold on something already
  * closed, so a query using one deliberately excludes closed results rather than
  * matching them by accident. Bare terms and identity tokens match exactly as
  * matchTerm does for open pulls, so "offer" finds the same fields either side of
@@ -141,7 +143,7 @@ function matchClosedTerm(
          if (key === 'is') {
             if (val === 'bot') return isBotLogin(pd.user.login, extraBots);
             if (val === 'mine') return pd.user.login.toLowerCase() === me.toLowerCase();
-            // is:restamp/blocked/draft describe an open pull's state
+            // is:restamp/asked/blocked/draft describe an open pull's state
             return false;
          }
          if (OPEN_ONLY_KEYS.has(key)) return false;
diff --git a/frontend-v2/src/model/reviewLanes.test.ts b/frontend-v2/src/model/reviewLanes.test.ts
index f57d785d..c1635fc3 100644
--- a/frontend-v2/src/model/reviewLanes.test.ts
+++ b/frontend-v2/src/model/reviewLanes.test.ts
@@ -7,8 +7,14 @@ import { buildReviewLanes, type ReviewLanesInput } from './reviewLanes';
  * repoBlocks, claimFor) reads. Defaults describe a plain, fully-open
  * needs_cr pull from someone else, freshly pushed (old enough that
  * isIterating never demotes it by accident) and untouched by the viewer, so
- * a test only needs to override what it's actually exercising. */
+ * a test only needs to override what it's actually exercising. That someone
+ * is outside the dev team (ownReview false), so their review is anyone's;
+ * `ownReview: true` is a developer's own unrequested pull. askedOf follows
+ * requestedReviewers minus claims, as derive() builds it. */
 function dp(o: {
+   ownReview?: boolean;
+   askedOf?: string[];
+   askedAt?: number | null;
    repo?: string;
    number?: number;
    author?: string;
@@ -97,6 +103,13 @@ function dp(o: {
       cryo: o.cryo ?? false,
       changesRequestedBy: o.changesRequestedBy ?? [],
       engagedNoStamp: o.engagedNoStamp ?? [],
+      ownReview: o.ownReview ?? false,
+      askedOf:
+         o.askedOf ??
+         (o.requestedReviewers ?? []).filter(
+            l => !(o.reviewRequests ?? []).some(r => r.self && r.login === l)
+         ),
+      askedAt: o.askedAt ?? null,
    } as unknown as DerivedPull;
 }
 
@@ -110,7 +123,6 @@ function input(o: Partial<ReviewLanesInput> & { pulls?: DerivedPull[] }): Review
       napping: [],
       changed: [],
       me: 'me',
-      selfReview: true,
       teams: [],
       codeRegions: [],
       repoPriority: [],
@@ -131,11 +143,11 @@ describe('buildReviewLanes — review queue', () => {
       expect(lanes.queue).toEqual([p]);
    });
 
-   it('excludes a pull you already hold a live CR stamp on (it waits on the other reviewer instead)', () => {
+   it('excludes a pull you already hold a live CR stamp on (the rest is its author’s)', () => {
       const p = dp({ author: 'alice', status: 'needs_cr', crBy: ['me'], crReq: 2 });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
       expect(lanes.queue).not.toContain(p);
-      expect(lanes.yoursWaiting).toContain(p);
+      expect(lanes.yoursWaiting).not.toContain(p);
    });
 
    it('excludes your own pull from the queue', () => {
@@ -187,11 +199,11 @@ describe('buildReviewLanes — needs QA', () => {
       expect(lanes.needsQa).not.toContain(p);
    });
 
-   it('excludes a pull you already QA-stamped (it lands in yoursWaiting instead)', () => {
+   it('excludes a pull you already QA-stamped', () => {
       const p = dp({ author: 'alice', status: 'needs_qa', qaBy: ['me'], qaReq: 2 });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
       expect(lanes.needsQa).not.toContain(p);
-      expect(lanes.yoursWaiting).toContain(p);
+      expect(lanes.yoursWaiting).not.toContain(p);
    });
 
    it('sinks a QA-incomplete pull outside your primary repos to needsQaOther', () => {
@@ -232,17 +244,17 @@ describe('buildReviewLanes — waiting on you vs waiting on others', () => {
       expect(lanes.yourMove).toContain(p);
    });
 
-   it('puts your own pull still waiting on review in yoursWaiting, not yourMove', () => {
-      const mine = dp({ author: 'me', status: 'needs_cr' });
+   it('puts your own pull waiting on the people you asked in yoursWaiting, not yourMove', () => {
+      const mine = dp({ author: 'me', status: 'needs_cr', askedOf: ['bob'] });
       const lanes = buildReviewLanes(input({ pulls: [mine] }));
       expect(lanes.yourMove).not.toContain(mine);
       expect(lanes.yoursWaiting).toEqual([mine]);
    });
 
-   it('puts a pull you have CR-stamped, not yet fully signed off, in yoursWaiting', () => {
+   it('keeps a stamp you gave on someone else’s PR out of yoursWaiting: only your PRs wait there', () => {
       const p = dp({ author: 'alice', status: 'needs_cr', crBy: ['me'], crReq: 2 });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
-      expect(lanes.yoursWaiting).toEqual([p]);
+      expect(lanes.yoursWaiting).toEqual([]);
    });
 
    it('dedupes a pull that qualifies for yourMove through two routes at once', () => {
@@ -259,63 +271,124 @@ describe('buildReviewLanes — waiting on you vs waiting on others', () => {
    });
 });
 
-describe('buildReviewLanes — region matches', () => {
-   it('surfaces a pull matching a configured code region as a highlight, without removing it from the queue', () => {
-      const p = dp({ author: 'alice', status: 'needs_cr', title: 'Rework the Shopify sync' });
-      const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: ['Shopify'] }));
-      expect(lanes.regionMatches).toEqual([p]);
-      expect(lanes.queue).toContain(p);
+describe('buildReviewLanes — self-review: nobody else is assigned a developer’s own PR', () => {
+   it('keeps a developer’s unrequested PR out of everyone else’s queue, QA, and Waiting on you', () => {
+      const own = dp({
+         author: 'alice',
+         status: 'needs_cr',
+         ownReview: true,
+         starved: true,
+         ageDays: 30,
+      });
+      const ownQa = dp({ number: 2, author: 'alice', status: 'needs_qa', ownReview: true });
+      const lanes = buildReviewLanes(input({ pulls: [own, ownQa] }));
+      expect(lanes.queue).toEqual([]);
+      expect(lanes.queueStarved).toEqual([]);
+      expect(lanes.queueOther).toEqual([]);
+      expect(lanes.needsQa).toEqual([]);
+      expect(lanes.needsQaOther).toEqual([]);
+      expect(lanes.yourMove).toEqual([]);
    });
 
-   it('leaves regionMatches empty when no regions are configured', () => {
-      const p = dp({ author: 'alice', status: 'needs_cr', title: 'Rework the Shopify sync' });
-      const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: [] }));
-      expect(lanes.regionMatches).toEqual([]);
-      expect(lanes.queue).toEqual([p]);
+   it('puts the author’s own stamps in their Waiting on you', () => {
+      const cr = dp({ author: 'me', status: 'needs_cr', ownReview: true });
+      const restamp = dp({
+         number: 2,
+         author: 'me',
+         status: 'needs_recr',
+         recrBy: ['me'],
+         ownReview: true,
+      });
+      const lanes = buildReviewLanes(input({ pulls: [cr, restamp] }));
+      expect(lanes.yourMove).toEqual([restamp, cr]);
+      expect(lanes.yoursWaiting).toEqual([]);
    });
 
-   it('surfaces a QA-pool match in regionMatches too, without removing it from needsQa', () => {
-      const p = dp({
-         author: 'alice',
-         status: 'needs_qa',
-         title: 'Rework the Shopify sync',
-      });
-      const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: ['Shopify'] }));
-      expect(lanes.regionMatches).toEqual([p]);
-      expect(lanes.needsQa).toContain(p);
+   it('a review asked of someone else is theirs, not in my queue', () => {
+      const p = dp({ author: 'alice', status: 'needs_cr', askedOf: ['bob'] });
+      const lanes = buildReviewLanes(input({ pulls: [p] }));
+      expect(lanes.queue).toEqual([]);
+      expect(lanes.yourMove).toEqual([]);
    });
 
-   it('excludes a pull you already CR-stamped from regionMatches, even via the QA pool', () => {
-      // qaPool itself doesn't care about crBy — a needs_qa pull with a live
-      // stamp from you would otherwise sail through the QA-pool leg and land
-      // in "your code regions" as if it were news to you. It still belongs
-      // in needsQa (that lane's own filters don't look at crBy at all).
+   it('a review someone said they’d do is theirs, not in my queue', () => {
       const p = dp({
          author: 'alice',
-         status: 'needs_qa',
-         crBy: ['me'],
-         title: 'Rework the Shopify sync',
+         status: 'needs_cr',
+         requestedReviewers: ['bob'],
+         reviewRequests: [{ login: 'bob', at: null, self: true }],
       });
+      expect(buildReviewLanes(input({ pulls: [p] })).queue).toEqual([]);
+   });
+
+   it('requested-of-you leads Waiting on you, oldest request first', () => {
+      const now = Date.now() / 1000;
+      const restamp = dp({ number: 1, author: 'alice', status: 'needs_recr', recrBy: ['me'] });
+      const newer = dp({ number: 2, author: 'bob', askedOf: ['me'], askedAt: now - 3600 });
+      const older = dp({ number: 3, author: 'cy', askedOf: ['me'], askedAt: now - 5 * 3600 });
+      const lanes = buildReviewLanes(input({ pulls: [restamp, newer, older] }));
+      expect(lanes.yourMove).toEqual([older, newer, restamp]);
+   });
+});
+
+describe('buildReviewLanes — could use your input', () => {
+   it('offers someone’s self-review in your code region, without queueing it', () => {
+      const p = dp({ author: 'alice', ownReview: true, title: 'Rework the Shopify sync' });
       const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: ['Shopify'] }));
-      expect(lanes.regionMatches).not.toContain(p);
-      expect(lanes.needsQa).toContain(p);
+      expect(lanes.couldUseInput).toEqual([p]);
+      expect(lanes.queue).toEqual([]);
+      expect(lanes.yourMove).toEqual([]);
+      // an offer, not work: the board still reads as quiet
+      expect(lanes.boardIsQuiet).toBe(true);
    });
 
-   it('keeps a needs_recr pull in regionMatches when only your own stamp went stale', () => {
-      // recrBy including you means YOUR re-stamp is owed (a "Re-stamp" verb
-      // in Waiting on you) and crBy no longer includes you, since a stale
-      // stamp drops out of the active crBy set. The new qaPool exclusion
-      // only checks crBy (a currently-live stamp), so this pull still
-      // matches through the QA-pool leg.
-      const p = dp({
+   it('offers a self-review in a repo you’ve reviewed someone else’s PR in, regions first', () => {
+      const reviewed = dp({
+         repo: 'org/web',
+         number: 1,
+         author: 'bob',
+         status: 'ready',
+         crBy: ['me'],
+      });
+      const inRepo = dp({
+         repo: 'org/web',
+         number: 2,
          author: 'alice',
-         status: 'needs_recr',
-         recrBy: ['me'],
-         crBy: [],
-         title: 'Rework the Shopify sync',
+         ownReview: true,
+         ageDays: 9,
       });
-      const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: ['Shopify'] }));
-      expect(lanes.regionMatches).toContain(p);
+      const inRegion = dp({
+         repo: 'org/other',
+         number: 3,
+         author: 'cy',
+         ownReview: true,
+         title: 'Shopify webhooks',
+      });
+      const elsewhere = dp({ repo: 'org/other', number: 4, author: 'dee', ownReview: true });
+      const lanes = buildReviewLanes(
+         input({ pulls: [reviewed, inRepo, inRegion, elsewhere], codeRegions: ['Shopify'] })
+      );
+      expect(lanes.couldUseInput).toEqual([inRegion, inRepo]);
+   });
+
+   it('leaves out your own, ones you stamped, requested or outside ones, and drafts', () => {
+      const pulls = [
+         dp({ number: 1, author: 'me', ownReview: true, title: 'Shopify' }),
+         dp({
+            number: 2,
+            author: 'alice',
+            ownReview: true,
+            crBy: ['me'],
+            crReq: 2,
+            title: 'Shopify',
+         }),
+         dp({ number: 3, author: 'alice', askedOf: ['bob'], title: 'Shopify' }),
+         dp({ number: 4, author: 'alice', title: 'Shopify' }),
+         dp({ number: 5, author: 'alice', ownReview: true, status: 'draft', title: 'Shopify' }),
+      ];
+      expect(buildReviewLanes(input({ pulls, codeRegions: ['Shopify'] })).couldUseInput).toEqual(
+         []
+      );
    });
 });
 
@@ -348,11 +421,10 @@ describe('buildReviewLanes — stamped and ready lanes', () => {
       expect(lanes.ready).toEqual([bot]);
    });
 
-   it('keeps a stamped (CR-incomplete, your stamp live) pull out of the queue and in yoursWaiting', () => {
+   it('keeps a stamped (CR-incomplete, your stamp live) pull out of the queue', () => {
       const p = dp({ author: 'alice', status: 'needs_cr', crBy: ['me'], crReq: 2 });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
       expect(lanes.queue).toEqual([]);
-      expect(lanes.yoursWaiting).toEqual([p]);
    });
 });
 
@@ -433,11 +505,14 @@ describe('buildReviewLanes — why-line display names', () => {
    });
 
    it('whyUpNext threads names into startHereReason for a non-teammate', () => {
-      // reciprocity reason: alice reviewed one of "me"'s pulls
-      const target = dp({ author: 'alice', status: 'needs_cr' });
-      const mine = dp({ repo: 'org/repo', number: 99, author: 'me', crBy: ['alice'] });
-      const lanes = buildReviewLanes(input({ pulls: [target, mine], names: { alice: 'Alice A' } }));
-      expect(lanes.whyUpNext(target)).toBe('Alice A reviewed yours, return the favor');
+      const target = dp({
+         author: 'alice',
+         status: 'needs_cr',
+         askedOf: ['me'],
+         askedAt: Date.now() / 1000 - 2.5 * 3600,
+      });
+      const lanes = buildReviewLanes(input({ pulls: [target], names: { alice: 'Alice A' } }));
+      expect(lanes.whyUpNext(target)).toBe('Alice A asked you 2h ago');
    });
 
    it("whyQaNext resolves the tester's display name", () => {
@@ -516,8 +591,8 @@ describe('buildReviewLanes — projects', () => {
             standing: standing({ 'org/repo#1': 'picker' }),
          })
       );
-      // both re-stamps still come before the review request
-      expect(lanes.yourMove).toEqual([restamp, restampParked, requested]);
+      // the review request leads; the parked re-stamp sinks below the other
+      expect(lanes.yourMove).toEqual([requested, restamp, restampParked]);
    });
 
    it('puts the PR that helps finish a plan first on a tie, and says so', () => {
diff --git a/frontend-v2/src/model/reviewLanes.ts b/frontend-v2/src/model/reviewLanes.ts
index ca80a60c..cd3ca411 100644
--- a/frontend-v2/src/model/reviewLanes.ts
+++ b/frontend-v2/src/model/reviewLanes.ts
@@ -1,4 +1,5 @@
 import {
+   CR_INCOMPLETE,
    isIterating,
    qaDone,
    STARVE_DAYS,
@@ -9,19 +10,23 @@ import {
 import type { PullData } from '../../../shared/types';
 import { pullKey } from '../../../shared/format';
 import {
+   askedOf,
    authorMove,
+   authorOwnsIt,
    DO_WORD_RANK,
    reviewerMove,
+   reviewIsMine,
    rowNote,
    rowWord,
+   selfReviewed,
    WAIT_WORD_RANK,
 } from './actions';
 import { startHereReason } from './cheers';
 import { dealRank, dealScore } from './deal';
 import { displayName } from './names';
-import { matchesRegion } from './regions';
+import { matchesRegion, regionFirst } from './regions';
 import { repoBlocks, type RepoBlock } from './repoBlocks';
-import { claimFor, reviewRequestedFrom } from './reviewers';
+import { claimFor } from './reviewers';
 import { myPeople, type PersonalTeam } from '../settings';
 import { crScore, crSort, finishersFirst, sinkBy, teamFirst } from './sort';
 import type { PullStanding } from './standing';
@@ -65,14 +70,11 @@ export interface ReviewLanesInput {
     * way every other model file stays independent of the store singleton. */
    changed: DerivedPull[];
    me: string;
-   /** settings.selfReview: promotes "Find a QA-er" into the home to-do lane —
-    * lining up QA is the daily stall on a team that doesn't gate on CR */
-   selfReview: boolean;
    /** settings.teams: your personal rosters, unioned into the "teammates lead
     * the queue" set */
    teams: PersonalTeam[];
-   /** settings.codeRegions: free-text areas that pull a PR into "In your code
-    * regions" ahead of the plain queue/QA lanes */
+   /** settings.codeRegions: free-text areas that put someone's self-reviewed
+    * PR into "Could use your input" */
    codeRegions: string[];
    /** settings.repoPriority: non-empty switches the review queue from one
     * ranked list to contiguous per-repo blocks */
@@ -96,8 +98,8 @@ export interface ReviewLanes {
     * rowWord's do-word (Re-stamp, Merge it, Review it, ...) — the kinds of
     * action that unblock other people first, then oldest within a word */
    yourMove: DerivedPull[];
-   /** your own PRs and the stamps you've already given, still sitting with
-    * someone else, folded flat and re-bucketed by rowWord's wait-word */
+   /** your own PRs waiting on someone else (people you asked, CI, a block),
+    * folded flat and re-bucketed by rowWord's wait-word */
    yoursWaiting: DerivedPull[];
    /** new or updated since lastSeen, newest first — a pass-through of the
     * input so every lane the render reads comes off one object */
@@ -114,10 +116,10 @@ export interface ReviewLanes {
    /** the review queue's contiguous per-repo blocks (only meaningful with
     * repoPriority set) */
    queueBlocks: RepoBlock[];
-   /** CR- or QA-pool pulls matching a configured code region, deduped — a
-    * highlight copy, not an extraction: matches also stay in the queue/QA
-    * lanes below */
-   regionMatches: DerivedPull[];
+   /** other people's self-reviewed PRs in your code regions or in repos
+    * you've reviewed in, regions first: a chance to help, never a debt, so
+    * nothing counts it and nothing deals from it */
+   couldUseInput: DerivedPull[];
    needsQa: DerivedPull[];
    needsQaOther: DerivedPull[];
    /** fully signed off and green, bot PRs included — one merge press from done */
@@ -152,16 +154,24 @@ export interface ReviewLanes {
 
 const NO_STANDING: PullStanding = { parked: new Map(), finishing: new Map() };
 
-/** Your own pulls contribute only their do-it-now verbs to the home lane.
- * "Undraft" always stays in My work (planning, not minutes). Getting QA is
- * different: when the team self-reviews, CR isn't the gate and lining up QA
- * is the daily stall, so "Find a QA-er" graduates to a home to-do. */
-function ownVerb(p: DerivedPull, selfReview: boolean): string | null {
+/** Your own pulls contribute only their do-it-now verbs to the home lane:
+ * under self-review your own stamps and a request gone quiet are daily work.
+ * "Undraft" always stays in My work (planning, not minutes). */
+const OWN_DO_NOW = [
+   'Re-stamp',
+   'Merge it',
+   'Fix CI',
+   'Address feedback',
+   'Stamp CR',
+   'Stamp QA',
+   'Lift your block',
+   'Rebase',
+];
+function ownVerb(p: DerivedPull): string | null {
    const verb = authorMove(p);
    if (!verb) return null;
-   const doNow = ['Merge it', 'Fix CI', 'Address feedback', 'Lift your block', 'Rebase'];
-   if (selfReview) doNow.push('Find a QA-er');
-   return doNow.includes(verb) ? verb : null;
+   if (verb.startsWith('Nudge ')) return 'Nudge';
+   return OWN_DO_NOW.includes(verb) ? verb : null;
 }
 
 export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
@@ -173,7 +183,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       napping,
       changed,
       me,
-      selfReview,
       teams,
       codeRegions,
       repoPriority,
@@ -213,31 +222,15 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // 1. Waiting on you: strictly your verbs. The earlier "Act now" lesson still
    //    binds — padding this with other people's jobs made it noise — but
    //    your own merge button is your job, whichever tab you're on.
-   const MOVE_RANK = [
-      'Re-stamp',
-      'Re-QA',
-      'Finish QA',
-      'Merge it',
-      'Fix CI',
-      'Address feedback',
-      'Lift your block',
-      'Rebase',
-      'Find a QA-er',
-   ];
-   const todo = pulls
-      .map(p => ({
-         p,
-         verb: p.data.user.login === me ? ownVerb(p, selfReview) : reviewerMove(p, me),
-      }))
-      .filter((x): x is { p: DerivedPull; verb: string } => x.verb !== null)
-      .sort(
-         (a, b) =>
-            MOVE_RANK.indexOf(a.verb) - MOVE_RANK.indexOf(b.verb) || b.p.ageDays - a.p.ageDays
-      );
+   //    The list is re-ranked by do-word below, so no order here.
+   const todo = pulls.filter(
+      p => (p.data.user.login === me ? ownVerb(p) : reviewerMove(p, me)) !== null
+   );
 
-   // 2. Review queue: best next review first (leverage + age + weight).
-   //    Includes pulls waiting on someone else's re-stamp — a fresh CR from
-   //    you counts there too (the stale pip marks them).
+   // 2. Review queue: best next review first (leverage + age + weight), and
+   //    only review that's yours under self-review (reviewIsMine): asked of
+   //    you, taken on by you, or needing someone else with nobody on it. A
+   //    developer's own unrequested PR is never in anyone else's queue.
    // exclude PRs you already hold a live CR stamp on — including a needs_recr
    // whose re-stamp is owed by someone else, not you. You reviewed this head;
    // being asked to review it again because a different reviewer's stamp went
@@ -246,6 +239,7 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       p =>
          !p.cryo &&
          !p.crBy.includes(me) &&
+         reviewIsMine(p, me) &&
          (p.status === 'needs_cr' || (p.status === 'needs_recr' && !p.recrBy.includes(me)))
    );
    const nonStarved = crPool.filter(p => !p.starved);
@@ -278,8 +272,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    //    claim state, lighter tests first, then oldest. Split by your primary
    //    repos, same as the review queue — QA is the bottleneck on a
    //    self-review team, so it deserves the same relevance cut.
-   // (computed above the queue/needsQa construction so regionMatches below
-   // can read both pools before either lane's pool is filtered)
    const qaPool = others.filter(
       p =>
          !p.cryo &&
@@ -293,7 +285,9 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
          // on a needs_recr pull is still yours to do, not a generic lane slot
          p.qaingLogin !== me &&
          !p.qaBy.includes(me) &&
-         !p.reqaBy.includes(me)
+         !p.reqaBy.includes(me) &&
+         // a self-reviewed PR's QA is its author's
+         reviewIsMine(p, me)
    );
    const qaSort = (list: DerivedPull[]) =>
       [...list].sort(
@@ -314,23 +308,28 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       );
    };
 
-   // In your code regions: reviewable pulls (CR or QA pool) matching a region
-   // you set in Settings, deduped across the two pools, surfaced as a
-   // highlight above the queue/QA lanes below — a copy of a slice, not an
-   // extraction (the same non-exclusive relationship "Recently updated" and
-   // a claimed PR already have with their lanes): a region match still shows
-   // up in its normal queue/QA spot too. The QA-pool leg excludes a pull you
-   // already hold a live CR stamp on — you've already reviewed it, so it
-   // isn't region news to you, even though qaPool itself doesn't otherwise
-   // care about CR state.
-   const regionSeen = new Set<string>();
-   const regionMatches = crRank(
-      [...crPool, ...qaPool.filter(p => !p.crBy.includes(me))].filter(p => {
-         const k = pullKey(p.data);
-         if (regionSeen.has(k) || !matchesRegion(p, codeRegions)) return false;
-         regionSeen.add(k);
-         return true;
-      })
+   // Could use your input: other people's self-reviewed PRs, still owed a
+   // stamp, in your code regions or in repos you've reviewed someone else's
+   // PR in. Nobody asked you, so it's an offer, never a debt: the lane rests
+   // folded and nothing counts it, deals from it, or lets it starve (crSort's
+   // age credit is off for a self-reviewed PR). Region matches first.
+   const reviewedIn = new Set(
+      others.filter(p => p.crBy.includes(me) || p.qaBy.includes(me)).map(p => p.data.repo)
+   );
+   const couldUseInput = regionFirst(
+      crSort(
+         others.filter(
+            p =>
+               selfReviewed(p) &&
+               !p.cryo &&
+               !authorOwnsIt(p) &&
+               (CR_INCOMPLETE.includes(p.status) || p.status === 'needs_qa') &&
+               !p.crBy.includes(me) &&
+               (matchesRegion(p, codeRegions) || reviewedIn.has(p.data.repo))
+         ),
+         sunk
+      ),
+      codeRegions
    );
 
    // ONE review queue: your primary repos' reviewables, every starved pull
@@ -341,11 +340,8 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // next pickup; the retired "Deal me one" button dealt this exact order,
    // which is why the button became redundant and was removed. Non-starved
    // work outside your primary repos still folds into "other repos" below,
-   // reachable but not in the way. Region matches stay in this queue too:
-   // "In your code regions" above is a highlight, a copy of a slice, not an
-   // extraction — the same non-exclusive relationship "Recently updated" and
-   // a claimed PR already have with their lanes. A parked project's PRs sink
-   // below every other person's, teammates' included, and above the bots.
+   // reachable but not in the way. A parked project's PRs sink below every
+   // other person's, teammates' included, and above the bots.
    const dealOpts = { me, pulls, deprioritize: isDemoted, warnDays: ageWarnDays };
    const classOf = (p: DerivedPull) => (isDemoted(p) ? 2 : sunk(p) ? 1 : 0);
    const queue = finishersFirst(
@@ -397,15 +393,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       false
    );
 
-   // your live CR stamp is in, the PR just isn't fully signed off yet (another
-   // reviewer owes a stamp, or a re-CR). Covers needs_recr too, so a PR you
-   // reviewed doesn't vanish once someone else's stamp goes stale.
-   const stamped = others.filter(
-      p => (p.status === 'needs_cr' || p.status === 'needs_recr') && p.crBy.includes(me)
-   );
-   // QA's symmetric case: you gave a QA stamp but qa_req wants more. Without
-   // this the PR sits in "Needs QA" as if you never touched it.
-   const qaStamped = others.filter(p => !qaDone(p) && p.qaBy.includes(me));
    const byStatus = (s: Status) => others.filter(p => p.status === s);
    const devBlocked = byStatus('dev_block');
    const deployHeld = byStatus('deploy_block');
@@ -414,16 +401,12 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    const ciRed = byStatus('ci_red');
    const drafts = byStatus('draft');
 
-   // GitHub asked you directly — the most concrete "review this" on the board,
-   // so it leads. Only while it's still your move (unstamped, review-stage).
-   const requestedOfYou = crSort(
-      others.filter(
-         p =>
-            (p.status === 'needs_cr' || p.status === 'needs_recr') &&
-            reviewRequestedFrom(p, me) &&
-            !p.crBy.includes(me)
-      )
-   );
+   // the author asked you (by name or through a team): the most concrete
+   // "review this" on the board, so it leads, while it's still your move
+   const requestedOfYou = others.filter(p => {
+      const action = rowNote(p, me).action;
+      return askedOf(p).includes(me) && (action === 'Review it' || action === 'QA it');
+   });
 
    // PRs you've claimed — the coordination lane so a claim isn't just a hand
    // icon buried in a lower lane; it's your commitment, surfaced up top.
@@ -439,7 +422,7 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // of by where they came from).
    const yourMoveKeys = new Set<string>();
    const yourMove: DerivedPull[] = [];
-   for (const p of [...todo.map(({ p }) => p), ...requestedOfYou, ...claimed, ...reReview]) {
+   for (const p of [...todo, ...requestedOfYou, ...claimed, ...reReview]) {
       const k = pullKey(p.data);
       if (yourMoveKeys.has(k)) continue;
       yourMoveKeys.add(k);
@@ -450,10 +433,16 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       const idx = DO_WORD_RANK.indexOf(word);
       return idx === -1 ? Number.POSITIVE_INFINITY : idx;
    };
-   // a parked project's sink within their word's group, never out of it
+   // the oldest request first (they're answered in hours); a parked
+   // project's sink within their word's group, never out of it
+   const askedAtOf = (p: DerivedPull) =>
+      askedOf(p).includes(me) ? p.askedAt ?? Number.POSITIVE_INFINITY : Number.POSITIVE_INFINITY;
    yourMove.sort(
       (a, b) =>
-         doRankOf(a) - doRankOf(b) || Number(sunk(a)) - Number(sunk(b)) || b.ageDays - a.ageDays
+         doRankOf(a) - doRankOf(b) ||
+         askedAtOf(a) - askedAtOf(b) ||
+         Number(sunk(a)) - Number(sunk(b)) ||
+         b.ageDays - a.ageDays
    );
    const yourMoveRanked = finishersFirst(
       yourMove,
@@ -461,22 +450,12 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       finishes
    );
 
-   // "Waiting on others": your PRs and stamps sitting with someone else right now —
-   // your own PRs waiting on a review/QA, plus a stamp you've already given
-   // that isn't fully signed off yet (stamped/qaStamped, formerly their own
-   // rest-group folds — redundant once this lane exists).
-   const yoursWaitingKeys = new Set<string>();
-   const yoursWaiting: DerivedPull[] = [];
-   for (const p of [
-      ...pulls.filter(p => p.data.user.login === me && rowWord(p, me).kind === 'wait'),
-      ...stamped,
-      ...qaStamped,
-   ]) {
-      const k = pullKey(p.data);
-      if (yoursWaitingKeys.has(k)) continue;
-      yoursWaitingKeys.add(k);
-      yoursWaiting.push(p);
-   }
+   // "Waiting on others": your own PRs sitting with someone else right now:
+   // people you asked, CI, a block. A stamp you gave on someone else's PR
+   // isn't here: under self-review the rest of that PR is its author's.
+   const yoursWaiting = pulls.filter(
+      p => p.data.user.login === me && rowWord(p, me).kind === 'wait'
+   );
    const waitRankOf = (p: DerivedPull) => {
       const word = rowWord(p, me, { claim: claimFor(p.data) }).word;
       const idx = WAIT_WORD_RANK.indexOf(word);
@@ -505,8 +484,10 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // so every surface explains a pick in the same words
    const whyUpNext = (p: DerivedPull) => {
       const base = team.has(p.data.user.login)
-         ? `From ${displayName(names, p.data.user.login) ?? p.data.user.login}, on your team: teammates’ PRs lead your queue`
-         : startHereReason(p, pulls, me, false, names);
+         ? `From ${
+              displayName(names, p.data.user.login) ?? p.data.user.login
+           }, on your team: teammates’ PRs lead your queue`
+         : startHereReason(p, me, false, names);
       return whyProject(p, base) ?? base;
    };
    // the queue's repo blocks (priority order, starved pierced out front) —
@@ -520,12 +501,16 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // ranking this lane doesn't use.
    const whyQaNext = (p: DerivedPull) => {
       const base = team.has(p.data.user.login)
-         ? `From ${displayName(names, p.data.user.login) ?? p.data.user.login}, on your team: teammates’ PRs lead this lane`
+         ? `From ${
+              displayName(names, p.data.user.login) ?? p.data.user.login
+           }, on your team: teammates’ PRs lead this lane`
          : p.qaingLogin
-           ? `${displayName(names, p.qaingLogin) ?? p.qaingLogin} is already testing it; it sinks below unclaimed QA`
-           : p.weight === 'XS' || p.weight === 'S'
-             ? `Nobody's testing it yet, a light one (${p.weight})`
-             : `Nobody's testing it yet, waiting ${Math.max(1, Math.round(p.ageDays))}d`;
+         ? `${
+              displayName(names, p.qaingLogin) ?? p.qaingLogin
+           } is already testing it; it sinks below unclaimed QA`
+         : p.weight === 'XS' || p.weight === 'S'
+         ? `Nobody's testing it yet, a light one (${p.weight})`
+         : `Nobody's testing it yet, waiting ${Math.max(1, Math.round(p.ageDays))}d`;
       return whyProject(p, base) ?? base;
    };
 
@@ -539,8 +524,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
 
    // the rest group itself earns a title only when it has something inside —
    // an empty "rest of the board" with 11 closed folds under it is still noise.
-   // stamped/qaStamped moved into "Waiting on others" above, so they no longer
-   // count here.
    const restTotal =
       queueOther.length +
       needsQaOther.length +
@@ -568,7 +551,7 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       queueOther,
       queueStarved,
       queueBlocks,
-      regionMatches,
+      couldUseInput,
       needsQa,
       needsQaOther,
       ready,
diff --git a/frontend-v2/src/model/reviewers.test.ts b/frontend-v2/src/model/reviewers.test.ts
deleted file mode 100644
index a04d11b2..00000000
--- a/frontend-v2/src/model/reviewers.test.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { hasReviewRequest, requestedReviewers, reviewRequestedFrom } from './reviewers';
-import type { DerivedPull } from '../../../shared/model/status';
-
-function pull(author: string, requested: string[] | undefined): DerivedPull {
-   return {
-      data: { repo: 'org/a', number: 1, user: { login: author }, requested_reviewers: requested },
-   } as unknown as DerivedPull;
-}
-
-describe('requestedReviewers', () => {
-   it('returns the requested logins, dropping the author', () => {
-      expect(requestedReviewers(pull('alice', ['bob', 'alice', 'carol']))).toEqual([
-         'bob',
-         'carol',
-      ]);
-   });
-
-   it('is empty when the field is absent (older servers)', () => {
-      expect(requestedReviewers(pull('alice', undefined))).toEqual([]);
-      expect(hasReviewRequest(pull('alice', undefined))).toBe(false);
-   });
-});
-
-describe('reviewRequestedFrom', () => {
-   it('is true only when the viewer is in the request list', () => {
-      expect(reviewRequestedFrom(pull('alice', ['bob']), 'bob')).toBe(true);
-      expect(reviewRequestedFrom(pull('alice', ['bob']), 'carol')).toBe(false);
-   });
-
-   it('never treats the author as requested from themselves', () => {
-      expect(reviewRequestedFrom(pull('alice', ['alice']), 'alice')).toBe(false);
-   });
-});
diff --git a/frontend-v2/src/model/reviewers.ts b/frontend-v2/src/model/reviewers.ts
index e0d64b12..dce706e6 100644
--- a/frontend-v2/src/model/reviewers.ts
+++ b/frontend-v2/src/model/reviewers.ts
@@ -1,23 +1,13 @@
 import type { PullData } from '../../../shared/types';
-import type { DerivedPull } from '../../../shared/model/status';
 
 /**
- * GitHub review requests. A `requested_reviewers` entry is GitHub's explicit,
- * authoritative "please review this" — a stronger signal than our own turn
- * rotation (model/rotation.ts), which is only a deterministic guess for
- * starved pulls with nobody assigned. So an explicit request supersedes the
- * rotation: turnFor stays silent whenever a pull carries one, and the note /
- * row highlight speak for the request instead.
+ * Claims. A reviewer who picks up a review says "I'll review" on the board,
+ * which adds them as a GitHub reviewer on the PR, so a claim IS a review
+ * request the reviewer made on themselves (review_requests marks it
+ * self === true). Who the author's side asked is derive()'s askedOf
+ * (shared/model/status.ts), which leaves claims out.
  *
- * A claim (claimFor below) is ALSO a requested_reviewers entry now — the
- * server adds the claimant as a GitHub reviewer — so requestedReviewers/
- * reviewRequestedFrom read the `review_requests` metadata to tell the two
- * apart: an entry with self === true is you (or whoever) asking to review it
- * yourself, not GitHub asking on the author's behalf, so it's excluded from
- * "review this" here. hasReviewRequest stays broader on purpose (see below).
- *
- * Kept viewer-agnostic and side-effect-free like the rest of model/. The
- * "is it mine to review" question is answered at call sites that know `me`.
+ * Kept viewer-agnostic and side-effect-free like the rest of model/.
  */
 
 /** Whoever's claimed to review this pull right now, or null. GitHub is the
@@ -32,35 +22,3 @@ export function claimFor(pull: PullData): { login: string; at: number | null } |
    const entry = (pull.review_requests ?? []).find(r => r.self && r.login !== pull.user.login);
    return entry ? { login: entry.login, at: entry.at } : null;
 }
-
-/** logins GitHub has an open review request from, minus the author (GitHub
- * never requests a review from the PR's own author, but guard anyway). Counts
- * self-requested (claimed) logins too — this is the raw wire list. */
-function allRequestedReviewers(p: DerivedPull): string[] {
-   return (p.data.requested_reviewers ?? []).filter(login => login !== p.data.user.login);
-}
-
-/** logins GitHub has an open review request from on the AUTHOR's behalf — a
- * real "please review this", excluding anyone whose request is a claim
- * (review_requests metadata marks it self === true). Metadata is best-effort:
- * absent (older server) or no matching entry means "can't prove it was a
- * claim", so the login still counts here. */
-export function requestedReviewers(p: DerivedPull): string[] {
-   const selfLogins = new Set((p.data.review_requests ?? []).filter(r => r.self).map(r => r.login));
-   return allRequestedReviewers(p).filter(login => !selfLogins.has(login));
-}
-
-/** GitHub (the author's side) has explicitly asked `me` to review this pull —
- * false when the only request for `me` is their own claim. */
-export function reviewRequestedFrom(p: DerivedPull, me: string): boolean {
-   return requestedReviewers(p).includes(me);
-}
-
-/** The pull carries any open GitHub review request at all, claims included —
- * the signal turnFor checks to know it should defer rather than rotate. A
- * claimed pull already has someone on it, same as an author-requested one, so
- * this deliberately does NOT exclude self-requests the way requestedReviewers
- * does. */
-export function hasReviewRequest(p: DerivedPull): boolean {
-   return allRequestedReviewers(p).length > 0;
-}
diff --git a/frontend-v2/src/model/rotation.test.ts b/frontend-v2/src/model/rotation.test.ts
deleted file mode 100644
index 2d5a0bfd..00000000
--- a/frontend-v2/src/model/rotation.test.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { DerivedPull, Status } from '../../../shared/model/status';
-import { buildReviewerPools, turnFor } from './rotation';
-
-/** A DerivedPull with only the fields buildReviewerPools/turnFor read. */
-function dp(o: {
-   repo?: string;
-   number?: number;
-   author?: string;
-   status?: Status;
-   starved?: boolean;
-   crBy?: string[];
-   qaBy?: string[];
-   crLogins?: string[];
-}): DerivedPull {
-   return {
-      data: {
-         repo: o.repo ?? 'org/repo',
-         number: o.number ?? 1,
-         user: { login: o.author ?? 'author' },
-         status: {
-            allCR: (o.crLogins ?? []).map(login => ({ data: { user: { login } } })),
-         },
-      },
-      status: o.status ?? 'needs_cr',
-      starved: o.starved ?? true,
-      crBy: o.crBy ?? [],
-      qaBy: o.qaBy ?? [],
-   } as unknown as DerivedPull;
-}
-
-describe('buildReviewerPools', () => {
-   it('unions active and stale CR signers per repo', () => {
-      const pulls = [
-         dp({ repo: 'org/a', crLogins: ['alice', 'bob'] }),
-         dp({ repo: 'org/a', number: 2, crLogins: ['bob', 'carol'] }),
-         dp({ repo: 'org/b', crLogins: ['dave'] }),
-      ];
-      const pools = buildReviewerPools(pulls);
-      expect(pools.get('org/a')).toEqual(['alice', 'bob', 'carol']);
-      expect(pools.get('org/b')).toEqual(['dave']);
-   });
-
-   it('excludes bot logins', () => {
-      const pulls = [dp({ crLogins: ['alice', 'dependabot[bot]'] })];
-      expect(buildReviewerPools(pulls).get('org/repo')).toEqual(['alice']);
-   });
-
-   it('returns an empty map for no pulls', () => {
-      expect(buildReviewerPools([]).size).toBe(0);
-   });
-});
-
-describe('turnFor', () => {
-   const pools = buildReviewerPools([
-      dp({ repo: 'org/repo', crLogins: ['alice', 'bob', 'carol'] }),
-   ]);
-
-   it('is null when the pull is not starved', () => {
-      expect(turnFor(dp({ starved: false }), pools, [])).toBeNull();
-   });
-
-   it('is null outside needs_cr/needs_recr', () => {
-      expect(turnFor(dp({ status: 'ready' }), pools, [])).toBeNull();
-      expect(turnFor(dp({ status: 'dev_block' }), pools, [])).toBeNull();
-   });
-
-   it('is null when the repo has no pool', () => {
-      expect(turnFor(dp({ repo: 'org/unknown' }), pools, [])).toBeNull();
-   });
-
-   it('is null when every pool member is the author or already stamped', () => {
-      const p = dp({ author: 'alice', crBy: ['bob', 'carol'] });
-      expect(turnFor(p, pools, [])).toBeNull();
-   });
-
-   it('picks the same name on every call — deterministic', () => {
-      const p = dp({ number: 42 });
-      const first = turnFor(p, pools, []);
-      expect(first).not.toBeNull();
-      for (let i = 0; i < 5; i++) expect(turnFor(p, pools, [])).toBe(first);
-   });
-
-   it('picks a candidate from the eligible pool, excluding the author and existing CR', () => {
-      const p = dp({ author: 'bob', crBy: ['carol'] });
-      expect(turnFor(p, pools, [])).toBe('alice');
-   });
-
-   it('different pull numbers can land on different names', () => {
-      const picks = new Set<string | null>();
-      // no reciprocity signal (empty board) → falls through to the hash spread
-      for (let n = 0; n < 30; n++) picks.add(turnFor(dp({ number: n }), pools, []));
-      // over 30 distinct keys hashed into a 3-person pool, expect more than
-      // one name to come up — a constant pick would mean the hash isn't
-      // actually varying with the pull identity
-      expect(picks.size).toBeGreaterThan(1);
-   });
-
-   it('prefers a candidate the author has reviewed before (reciprocity)', () => {
-      // pull authored by dave; dave has CR'd one of carol's PRs elsewhere, so
-      // carol is owed a look back and leads the pool regardless of the hash
-      const target = dp({ number: 7, author: 'dave' });
-      const board = [target, dp({ author: 'carol', number: 99, crBy: ['dave'] })];
-      expect(turnFor(target, pools, board)).toBe('carol');
-   });
-
-   it('counts a QA stamp as reciprocity too', () => {
-      const target = dp({ number: 8, author: 'dave' });
-      const board = [target, dp({ author: 'bob', number: 98, qaBy: ['dave'] })];
-      expect(turnFor(target, pools, board)).toBe('bob');
-   });
-});
diff --git a/frontend-v2/src/model/rotation.ts b/frontend-v2/src/model/rotation.ts
deleted file mode 100644
index 94927186..00000000
--- a/frontend-v2/src/model/rotation.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import { hasReviewRequest } from './reviewers';
-import { CR_INCOMPLETE, type DerivedPull } from '../../../shared/model/status';
-import { isSuffixBot } from '../../../shared/model/visibility';
-
-/**
- * Turn rotation: a starved, CR-incomplete pull with no claim still needs
- * someone to pick it up. Rather than a server-assigned queue, every client
- * computes the same "whose turn" answer independently, so there's no round
- * trip and nothing to keep in sync.
- *
- * Who gets named is the best-fit reviewer, not just a hash: the pick leans on
- * the same reciprocity signal deal.ts ranks pulls by — someone the pull's
- * author has reviewed before is owed a look back, so they lead. (Repo
- * familiarity can't separate candidates here: the pool IS everyone who CR's
- * this repo, so they're all familiar.) When nobody's specifically owed, or
- * several are, a deterministic djb2 hash of the pull's key spreads the pick
- * across pulls so it isn't always the same name.
- */
-
-/** djb2: a tiny, deterministic string hash — good enough for picking an
- * index into a small pool, not for anything security-sensitive. */
-function djb2(s: string): number {
-   let h = 5381;
-   for (let i = 0; i < s.length; i++) h = (h * 33) ^ s.charCodeAt(i);
-   return h >>> 0;
-}
-
-/**
- * Per repo, the sorted unique logins holding ANY CR signature — active or
- * stale — on any pull of that repo. Stale counts because a re-review is
- * still a review: someone who has CR'd this repo before is fair game for the
- * rotation even if their stamp on this particular pull went stale. Bots
- * excluded (isSuffixBot is enough here, same as model/status.ts's
- * engagedNoStamp — this module has no reason to depend on the org's
- * configured `bots` list).
- */
-export function buildReviewerPools(pulls: DerivedPull[]): Map<string, string[]> {
-   const byRepo = new Map<string, Set<string>>();
-   for (const p of pulls) {
-      const set = byRepo.get(p.data.repo) ?? new Set<string>();
-      for (const sig of p.data.status.allCR) {
-         const login = sig.data.user.login;
-         if (!isSuffixBot(login)) set.add(login);
-      }
-      byRepo.set(p.data.repo, set);
-   }
-   const pools = new Map<string, string[]>();
-   for (const [repo, set] of byRepo) pools.set(repo, [...set].sort());
-   return pools;
-}
-
-const TURN_STATUSES = CR_INCOMPLETE;
-
-/**
- * Whose turn it is on this pull, or null when there's no rotation to name:
- * not starved, not CR-incomplete, or an empty pool once the author and anyone
- * already carrying an active CR stamp are excluded. Deterministic — the same
- * board picks the same login on every client, with no state to agree on.
- *
- * `pulls` is the whole board, read for the reciprocity signal (who the author
- * has reviewed before). A claim on the pull supersedes this at the CALLER's
- * level (Row, rowNote's withCoordination, notifications) — turnFor itself
- * knows nothing about claims.
- */
-export function turnFor(
-   p: DerivedPull,
-   pools: ReadonlyMap<string, string[]>,
-   pulls: readonly DerivedPull[]
-): string | null {
-   // a parked (Cryogenic Storage) pull asks nothing of anyone, so it never
-   // enters the rotation, starved or not
-   if (p.cryo || !p.starved || !TURN_STATUSES.includes(p.status)) return null;
-   // An explicit GitHub review request answers "whose turn" authoritatively —
-   // don't also rotate a name onto the pull, or the board would tell someone
-   // it's their turn on a PR GitHub already routed to a specific reviewer.
-   if (hasReviewRequest(p)) return null;
-   const pool = pools.get(p.data.repo);
-   if (!pool || !pool.length) return null;
-   const author = p.data.user.login;
-   const candidates = pool.filter(login => login !== author && !p.crBy.includes(login));
-   if (!candidates.length) return null;
-
-   // Reciprocity: tag every candidate the author has already reviewed (an
-   // active CR or QA stamp on a PR that candidate authored). One board pass,
-   // not one per candidate. Those are owed a look back, so they form the
-   // preferred tier; if none qualify, everyone's fair game.
-   const candSet = new Set(candidates);
-   const owed = new Set<string>();
-   for (const o of pulls) {
-      const a = o.data.user.login;
-      if (candSet.has(a) && (o.crBy.includes(author) || o.qaBy.includes(author))) owed.add(a);
-   }
-   const tier = candidates.filter(c => owed.has(c));
-   const pick = tier.length ? tier : candidates;
-
-   // deterministic spread across pulls so equally-good candidates share the load
-   const idx = djb2(`${p.data.repo}#${p.data.number}`) % pick.length;
-   return pick[idx];
-}
diff --git a/frontend-v2/src/model/sort.test.ts b/frontend-v2/src/model/sort.test.ts
index a551eec8..16a6cbe0 100644
--- a/frontend-v2/src/model/sort.test.ts
+++ b/frontend-v2/src/model/sort.test.ts
@@ -4,7 +4,10 @@ import { crScore, crSort, finishersFirst, sinkBy, teamFirst } from './sort';
 
 function fake(over: {
    ageDays?: number;
+   /** active CR stamps, by reviewers other than the author unless crBy says */
    crHave?: number;
+   crBy?: string[];
+   ownReview?: boolean;
    crReq?: number;
    additions?: number | null;
    weight?: DerivedPull['weight'];
@@ -14,6 +17,8 @@ function fake(over: {
    return {
       ageDays: over.ageDays ?? 0,
       crHave: over.crHave ?? 0,
+      crBy: over.crBy ?? Array.from({ length: over.crHave ?? 0 }, (_, i) => `reviewer${i}`),
+      ownReview: over.ownReview ?? false,
       weight: over.weight ?? 'S',
       sizeKnown: over.sizeKnown ?? true,
       data: {
@@ -22,6 +27,7 @@ function fake(over: {
          // ancient updated_at so nothing counts as iterating
          updated_at: new Date(0).toISOString(),
          status: { cr_req: over.crReq ?? 1, commit_statuses: [] },
+         user: { login: 'author' },
       },
    } as unknown as DerivedPull;
 }
@@ -33,6 +39,18 @@ describe('crScore / crSort', () => {
       expect(crScore(oneFromDone)).toBeLessThan(crScore(untouched));
    });
 
+   it('the author’s own stamp is not a review in: no one-from-done jump', () => {
+      const selfStamped = fake({ crHave: 1, crBy: ['author'], crReq: 2 });
+      const untouched = fake({ crHave: 0, crReq: 2 });
+      expect(crScore(selfStamped)).toBe(crScore(untouched));
+   });
+
+   it('a self-reviewed pull earns no age credit: nobody else keeps it waiting', () => {
+      const oldOwn = fake({ weight: 'M', ageDays: 10, ownReview: true });
+      const freshM = fake({ weight: 'M', ageDays: 0 });
+      expect(crScore(oldOwn)).toBe(crScore(freshM));
+   });
+
    it('age earns rank: an old M beats a fresh M and can beat a fresh S', () => {
       const oldM = fake({ weight: 'M', ageDays: 10 });
       const freshM = fake({ weight: 'M', ageDays: 0 });
diff --git a/frontend-v2/src/model/sort.ts b/frontend-v2/src/model/sort.ts
index 89e12024..b4a9ac71 100644
--- a/frontend-v2/src/model/sort.ts
+++ b/frontend-v2/src/model/sort.ts
@@ -1,4 +1,10 @@
-import { STARVE_DAYS, isIterating, weightRank, type DerivedPull } from '../../../shared/model/status';
+import {
+   STARVE_DAYS,
+   isIterating,
+   weightRank,
+   type DerivedPull,
+} from '../../../shared/model/status';
+import { selfReviewed } from './actions';
 
 /**
  * The review-queue score, lower first. Weight is the base (lightest first —
@@ -6,10 +12,11 @@ import { STARVE_DAYS, isIterating, weightRank, type DerivedPull } from '../../..
  * lacked:
  *
  * - leverage: a pull one stamp from done jumps ~1.5 weight classes. Your
- *   stamp there finishes CR instead of starting it.
+ *   stamp there finishes CR instead of starting it. The author's own stamp
+ *   doesn't count toward it: it's not someone else's review in.
  * - age: up to two weight classes of credit as a pull approaches two weeks,
  *   so an old M outranks a fresh S instead of waiting for the starvation
- *   cliff.
+ *   cliff. None for a self-reviewed pull: nobody else is keeping it waiting.
  *
  * Unknown size ranks as M-ish, not XS: missing data must not promote a pull
  * to the top of everyone's queue.
@@ -17,8 +24,9 @@ import { STARVE_DAYS, isIterating, weightRank, type DerivedPull } from '../../..
 export function crScore(p: DerivedPull): number {
    const weight = weightRank(p.weight);
    const req = p.data.status.cr_req;
-   const oneFromDone = p.crHave > 0 && req - p.crHave === 1;
-   const ageCredit = Math.min(p.ageDays / STARVE_DAYS, 2);
+   const have = p.crBy.filter(l => l !== p.data.user.login).length;
+   const oneFromDone = have > 0 && req - have === 1;
+   const ageCredit = selfReviewed(p) ? 0 : Math.min(p.ageDays / STARVE_DAYS, 2);
    return weight - (oneFromDone ? 1.5 : 0) - ageCredit;
 }
 
diff --git a/frontend-v2/src/model/stage.test.ts b/frontend-v2/src/model/stage.test.ts
index 122010a9..556e1b04 100644
--- a/frontend-v2/src/model/stage.test.ts
+++ b/frontend-v2/src/model/stage.test.ts
@@ -33,6 +33,10 @@ function dp(
       recrBy: string[];
       /** someone took it to review, at this epoch second */
       claim: { login: string; at: number | null };
+      /** the author reviews it themselves (DerivedPull.ownReview) */
+      ownReview: boolean;
+      askedOf: string[];
+      askedAt: number | null;
    }> = {}
 ): DerivedPull {
    const asked = o.changesRequestedAt != null;
@@ -64,6 +68,9 @@ function dp(
       recrBy: o.recrBy ?? [],
       reqaBy: [],
       engagedNoStamp: [],
+      ownReview: o.ownReview ?? false,
+      askedOf: o.askedOf ?? [],
+      askedAt: o.askedAt ?? null,
    } as unknown as DerivedPull;
 }
 
@@ -151,22 +158,29 @@ describe('holderWords', () => {
       expect(holderWords(dp(1, 'ready', { author: 'mlahargou' }))).toBe(
          'mlahargou is working on it'
       );
-      const turns = new Map([['iFixit/ifixit#2', 'erin']]);
-      expect(holderWords(dp(2, 'needs_cr'), { turns })).toBe('erin’s turn to review');
-      expect(holderWords(dp(3, 'needs_cr'), { turns })).toBe('needs a reviewer');
+      const now = Date.now() / 1000;
+      // asked of people: who, and how long ago
+      expect(
+         holderWords(dp(2, 'needs_cr', { askedOf: ['erin', 'kate'], askedAt: now - 2.5 * 3600 }))
+      ).toBe('waiting on erin, kate, asked 2h ago');
+      // nobody asked: the author reviews their own
+      expect(holderWords(dp(2, 'needs_cr', { ownReview: true }))).toBe('dana is reviewing it');
+      expect(holderWords(dp(2, 'needs_qa', { ownReview: true }))).toBe('dana is reviewing it');
+      // from outside the dev team, nobody on it yet
+      expect(holderWords(dp(3, 'needs_cr'))).toBe('needs a reviewer');
       expect(holderWords(dp(3, 'needs_qa'))).toBe('needs a tester');
       // someone commented with no stamp: a sentence, like its siblings
       const engaged = (logins: string[]) =>
          ({ ...dp(4, 'needs_cr'), engagedNoStamp: logins } as DerivedPull);
       expect(holderWords(engaged(['mlahargou']))).toBe('mlahargou is looking at it');
       expect(holderWords(engaged(['ardelato', 'kate']))).toBe('ardelato, kate are looking at it');
-      // a named person holds it before anyone's turn does
-      expect(holderWords(dp(3, 'needs_qa', { qaingLogin: 'k0rvus' }), { turns })).toBe(
+      // someone testing it, or owing a re-stamp, holds it before the author's own review
+      expect(holderWords(dp(3, 'needs_qa', { qaingLogin: 'k0rvus', ownReview: true }))).toBe(
          'k0rvus is testing it'
       );
-      expect(holderWords(dp(2, 'needs_recr', { recrBy: ['djmetzle', 'caphene'] }), { turns })).toBe(
-         'waiting on djmetzle, caphene to look again'
-      );
+      expect(
+         holderWords(dp(2, 'needs_recr', { recrBy: ['djmetzle', 'caphene'], ownReview: true }))
+      ).toBe('waiting on djmetzle, caphene to look again');
       expect(holderWords(dp(4, 'deploy_block', { deployBlockedBy: ['sctice'] }))).toBe(
          'deploy hold by sctice'
       );
@@ -181,10 +195,9 @@ describe('holderWords', () => {
 
    it('names who took a PR to review, as its row does', () => {
       const now = Date.now() / 1000;
-      const turns = new Map([['iFixit/ifixit#2', 'erin']]);
-      expect(
-         holderWords(dp(2, 'needs_cr', { claim: { login: 'bob', at: now - 60 } }), { turns })
-      ).toBe('bob is reading it');
+      expect(holderWords(dp(2, 'needs_cr', { claim: { login: 'bob', at: now - 60 } }))).toBe(
+         'bob is reading it'
+      );
       expect(holderWords(dp(2, 'needs_cr', { claim: { login: 'bob', at: now - 3 * 3600 } }))).toBe(
          'bob claimed it 3h ago'
       );
@@ -196,14 +209,16 @@ describe('holderWords', () => {
    });
 
    it('starts a line with a capital, but never changes a login', () => {
-      const turns = new Map([['iFixit/ifixit#2', 'andyg0808']]);
       expect(holderWords(dp(1, 'draft', { author: 'mlahargou' }), { line: true })).toBe(
          'mlahargou is working on it'
       );
       expect(holderWords(dp(3, 'needs_cr'), { line: true })).toBe('Needs a reviewer');
-      expect(holderWords(dp(2, 'needs_cr'), { turns, line: true })).toBe(
-         'andyg0808’s turn to review'
+      expect(holderWords(dp(2, 'needs_cr', { askedOf: ['andyg0808'] }), { line: true })).toBe(
+         'Waiting on andyg0808'
       );
+      expect(
+         holderWords(dp(2, 'needs_cr', { author: 'andyg0808', ownReview: true }), { line: true })
+      ).toBe('andyg0808 is reviewing it');
       expect(holderWords(dp(3, 'needs_qa', { qaingLogin: 'jrodger312' }), { line: true })).toBe(
          'jrodger312 is testing it'
       );
@@ -215,11 +230,12 @@ describe('holderWords', () => {
       expect(holderWords(dp(1, 'draft', { ageDays: 38 }), onRow)).toBe('');
       expect(holderWords(dp(1, 'needs_cr', { externalBlock: true }), onRow)).toBe('');
       // who it waits on, and what holds it, the row doesn't say
-      const turns = new Map([['iFixit/ifixit#2', 'erin']]);
-      expect(holderWords(dp(2, 'needs_cr', { ageDays: 38 }), { ...onRow, turns })).toBe(
-         'erin’s turn to review'
+      expect(holderWords(dp(2, 'needs_cr', { ageDays: 38, askedOf: ['erin'] }), onRow)).toBe(
+         'waiting on erin'
       );
       expect(holderWords(dp(5, 'ready', { cryo: true }), onRow)).toBe('paused');
+      // the author's own review: the face already says whose
+      expect(holderWords(dp(2, 'needs_cr', { ownReview: true }), onRow)).toBe('in self-review');
    });
 });
 
diff --git a/frontend-v2/src/model/stage.ts b/frontend-v2/src/model/stage.ts
index 69584ccb..4911bf39 100644
--- a/frontend-v2/src/model/stage.ts
+++ b/frontend-v2/src/model/stage.ts
@@ -1,4 +1,4 @@
-import { ago, n, pullKey } from '../../../shared/format';
+import { ago, n } from '../../../shared/format';
 import type { ClosedIssue } from '../../../shared/model/decide';
 import { dayStart } from '../../../shared/model/projects';
 import { issuePace, paceFinish, type RoadmapItem } from '../../../shared/model/roadmap';
@@ -14,17 +14,17 @@ import {
    type ProjectWork,
 } from '../../../shared/model/work';
 import type { PullData } from '../../../shared/types';
-import { parked, STALE_CLAIM_SECS } from './actions';
+import { askedAgo, askedOf, parked, selfReviewed, STALE_CLAIM_SECS } from './actions';
 import { dayOf } from './days';
-import { claimFor, requestedReviewers } from './reviewers';
+import { claimFor } from './reviewers';
 import { days } from './words';
 
 export { prStage, type PrStage };
 
 /**
  * Where work stands, in a product manager's words rather than the board's
- * CR and QA ones. An open PR is ready to merge, on hold, waiting on review,
- * or in development. An open issue is as far along as its least finished
+ * CR and QA ones. An open PR is ready to merge, on hold, in review (the
+ * author's own, or someone's they asked), or in development. An open issue is as far along as its least finished
  * open PR; with none open, either its PRs merged and the issue is still
  * open, or no PR does it yet. Closing an issue is a person's call, so a
  * closed one is done or dropped whatever its PRs say.
@@ -35,7 +35,9 @@ export type IssueStage = PrStage | 'merged' | 'none' | 'done' | 'dropped';
 export const STAGE_WORDS: Record<IssueStage, string> = {
    ready: 'Ready to merge',
    hold: 'On hold',
-   review: 'Waiting on review',
+   // not "waiting on review": under self-review most PRs in review are
+   // their author's own to stamp, waiting on nobody
+   review: 'In review',
    // not "being worked on": the tab says that of a project whose PRs moved
    // lately (words.ts BEING_WORKED_ON), which a PR waiting on review is too
    work: 'In development',
@@ -90,8 +92,8 @@ export function issueStanding(
 
 /**
  * Who holds an open PR right now, in a few words: its author while it's
- * in development or ready to merge, whose turn it is to review, or what
- * holds it. Says how long it's been open once that's past `ageWarnDays`,
+ * in development or ready to merge, or reviewing it themselves; who it waits
+ * on for review; or what holds it. Says how long it's been open once that's past `ageWarnDays`,
  * the board's own age warning. With `line`, the words start a line: they
  * take a capital, unless they start with a login, which is never changed.
  * With `onRow`, the words sit under the PR's own row, so they leave out
@@ -102,7 +104,6 @@ export function issueStanding(
 export function holderWords(
    p: DerivedPull,
    opts: {
-      turns?: ReadonlyMap<string, string>;
       ageWarnDays?: number;
       line?: boolean;
       onRow?: boolean;
@@ -122,7 +123,7 @@ export function holderWords(
                : 'deploy hold'
          );
    } else if (stage === 'review') {
-      who = reviewWaits(p, opts.turns?.get(pullKey(p.data)) ?? null, own);
+      who = reviewWaits(p, own, !!opts.onRow);
    } else {
       who = opts.onRow ? '' : `${p.data.user.login} is working on it`;
    }
@@ -133,13 +134,13 @@ export function holderWords(
 }
 
 /**
- * Who a PR waiting on review waits on, in the order the board's own notes
- * weigh it (actions.ts reviewerNote): someone testing it now, the people
- * asked to look again, the ones a review was asked of, someone looking,
- * whose turn it is; only then nobody yet. `own` marks the board's words,
- * as against a login.
+ * Who a PR in review waits on, in the order the board's own notes weigh it
+ * (actions.ts reviewerNote): someone testing it now, the people asked to
+ * look again, the ones a review was asked of, someone looking, the author
+ * reviewing their own; only then nobody yet. `own` marks the board's words,
+ * as against a login; `onRow` leaves out the author, whose face the row shows.
  */
-function reviewWaits(p: DerivedPull, turn: string | null, own: (words: string) => string): string {
+function reviewWaits(p: DerivedPull, own: (words: string) => string, onRow: boolean): string {
    const list = (logins: string[]) => logins.join(', ');
    if (p.status === 'needs_qa') {
       if (p.qaingLogin) return `${p.qaingLogin} is testing it`;
@@ -163,14 +164,18 @@ function reviewWaits(p: DerivedPull, turn: string | null, own: (words: string) =
             : `${claim.login} is reading it`;
       }
    }
-   const asked = requestedReviewers(p);
-   if (asked.length) return own(`waiting on ${list(asked)}`);
+   const asked = askedOf(p);
+   if (asked.length) {
+      const when = askedAgo(p);
+      return own(`waiting on ${list(asked)}${when ? `, ${when}` : ''}`);
+   }
    if (p.engagedNoStamp.length) {
       return `${list(p.engagedNoStamp)} ${
          p.engagedNoStamp.length === 1 ? 'is' : 'are'
       } looking at it`;
    }
-   if (turn) return `${turn}’s turn to review`;
+   if (selfReviewed(p))
+      return onRow ? own('in self-review') : `${p.data.user.login} is reviewing it`;
    return own(p.status === 'needs_qa' ? 'needs a tester' : 'needs a reviewer');
 }
 
diff --git a/frontend-v2/src/model/team.test.ts b/frontend-v2/src/model/team.test.ts
index 25d5c7b3..1b11289e 100644
--- a/frontend-v2/src/model/team.test.ts
+++ b/frontend-v2/src/model/team.test.ts
@@ -12,6 +12,8 @@ function dp(o: {
    weight?: Weight;
    sizeKnown?: boolean;
    crHave?: number;
+   ownReview?: boolean;
+   askedOf?: string[];
 }): DerivedPull {
    return {
       data: {
@@ -28,6 +30,8 @@ function dp(o: {
       weight: o.weight ?? 'M',
       sizeKnown: o.sizeKnown ?? true,
       crHave: o.crHave ?? 0,
+      ownReview: o.ownReview ?? false,
+      askedOf: o.askedOf ?? [],
    } as unknown as DerivedPull;
 }
 
@@ -72,6 +76,15 @@ describe('teamBuckets — what a team-authored pull sorts into', () => {
       expect(stamped).toEqual([p]);
    });
 
+   it('leaves a teammate’s own unrequested pull in rest: its review is theirs', () => {
+      const own = dp({ author: 'alice', status: 'needs_cr', ownReview: true });
+      const asked = dp({ author: 'alice', status: 'needs_cr', askedOf: ['me'] });
+      const askedOfBob = dp({ author: 'alice', status: 'needs_cr', askedOf: ['bob'] });
+      const { reviewable, rest } = teamBuckets([own, asked, askedOfBob], ['alice'], 'me');
+      expect(reviewable).toEqual([asked]);
+      expect(rest).toEqual([own, askedOfBob]);
+   });
+
    it('lands non-CR statuses in rest', () => {
       const p = dp({ author: 'alice', status: 'ready' });
       const { reviewable, stamped, rest } = teamBuckets([p], ['alice'], 'me');
diff --git a/frontend-v2/src/model/team.ts b/frontend-v2/src/model/team.ts
index 02f4da5e..8a5c435b 100644
--- a/frontend-v2/src/model/team.ts
+++ b/frontend-v2/src/model/team.ts
@@ -1,4 +1,5 @@
 import { CR_INCOMPLETE, STATUS_ORDER, type DerivedPull } from '../../../shared/model/status';
+import { reviewIsMine } from './actions';
 import { crSort } from './sort';
 
 export interface TeamBuckets {
@@ -12,16 +13,17 @@ export interface TeamBuckets {
  * unit-testable without mounting React. Mirrors People.tsx's per-person split
  * (reviewable / mine / rest) generalized to a set of members.
  *
+ * `reviewable` is only review that's yours under self-review (actions.ts
+ * reviewIsMine: asked of you, one you said you'd do, or from outside the dev
+ * team with nobody on it); a teammate's own unrequested PR is theirs to
+ * review, so it sits in `rest` with the rest of what they're working on.
+ *
  * The stamp split is by *live* vs *stale*: only a currently-active CR stamp of
  * yours (`crBy`) is genuinely "stamped, in flight, waiting on another
  * reviewer." A needs_recr pull naming you in `recrBy` means your earlier stamp
- * went stale — the PR is back to 0-of-1 and still needs a CR, reviewable by
- * you (a re-stamp) or by anyone else — so it belongs in `reviewable`, not
- * `stamped`. (The row's own note still reads "your move: Re-stamp"; the lane
- * just must not claim it's waiting on someone else.) You can't review your own
- * PR, so your pulls stay out of `reviewable`/`stamped` — but they still land in
- * `rest`, so adding yourself to your team surfaces your work instead of
- * dropping it (the same way People.tsx handles viewing your own page).
+ * went stale, so it belongs in `reviewable`, not `stamped`. Your own pulls
+ * stay out of `reviewable`/`stamped` — but they still land in `rest`, so
+ * adding yourself to your team surfaces your work instead of dropping it.
  */
 export function teamBuckets(
    pulls: DerivedPull[],
@@ -32,7 +34,7 @@ export function teamBuckets(
    // include your own pulls in the pool; you just can't *review* them, so they
    // fall through to `rest` below instead of vanishing when you add yourself
    const theirs = pulls.filter(p => memberSet.has(p.data.user.login));
-   const reviewableByMe = (p: DerivedPull) => p.data.user.login !== me;
+   const reviewableByMe = (p: DerivedPull) => me != null && reviewIsMine(p, me);
 
    const reviewable = crSort(
       theirs.filter(
diff --git a/frontend-v2/src/model/toast.ts b/frontend-v2/src/model/toast.ts
index 0a0d9b40..916155cc 100644
--- a/frontend-v2/src/model/toast.ts
+++ b/frontend-v2/src/model/toast.ts
@@ -48,12 +48,6 @@ export interface Toast {
    ttlMs?: number;
    /** custom click action; when set, it replaces the default scroll-to-pull */
    onAct?: () => void;
-   /** an explicit action button in the card (e.g. "Claim it" on a your-turn
-    * nudge). The label is declarative; the caller attaches onAction, since it's
-    * impure. Distinct from onAct (the whole-card click), so the card can still
-    * reveal the pull while the button does something committal. */
-   actionLabel?: string;
-   onAction?: () => void;
    /** run once when the toast leaves for any reason (dismiss/timeout/evicted) */
    onGone?: () => void;
 }
diff --git a/frontend-v2/src/model/updateDraft.test.ts b/frontend-v2/src/model/updateDraft.test.ts
index 2b9f3f36..a25b1666 100644
--- a/frontend-v2/src/model/updateDraft.test.ts
+++ b/frontend-v2/src/model/updateDraft.test.ts
@@ -29,7 +29,7 @@ describe('draftUpdate', () => {
          health: 'on_track',
          body:
             '2 PRs merged in the last 14 days, and 8 are open: 1 ready to merge, ' +
-            '4 waiting on review and 3 in development. At this pace its 4 open issues are ' +
+            '4 in review and 3 in development. At this pace its 4 open issues are ' +
             `done around ${dayWords('2026-10-28')}, by its ${dayWords('2026-11-01')} end.`,
       });
    });
@@ -51,7 +51,7 @@ describe('draftUpdate', () => {
          health: 'at_risk',
          body:
             'No PRs merged in the last 14 days, and 8 are open: 1 ready to merge, ' +
-            '4 waiting on review and 3 in development. No PR activity for 25 days.',
+            '4 in review and 3 in development. No PR activity for 25 days.',
       });
       // Sep 7 for 2 weeks ended Sep 20
       expect(draftUpdate(plan({}, 2), NOW)).toMatchObject({
diff --git a/frontend-v2/src/notifications.ts b/frontend-v2/src/notifications.ts
index 82980d66..bd021f10 100644
--- a/frontend-v2/src/notifications.ts
+++ b/frontend-v2/src/notifications.ts
@@ -1,16 +1,9 @@
 import { useEffect, useRef } from 'react';
 import { githubUrl, pullKey, shortRepo } from '../../shared/format';
 import { alertMove } from './model/actions';
-import { claimFor } from './model/reviewers';
 import type { DerivedPull } from '../../shared/model/status';
-import { isSuffixBot } from '../../shared/model/visibility';
 import { getSettings } from './settings';
 
-/** A pull key → this sentinel action means "the rotation just named you" —
- * distinct from alertMove's real verbs so fire() can give it its own title
- * (repo/number baked in, since "your turn" alone says nothing about which PR). */
-const TURN_ACTION = '__your-turn__';
-
 export const notificationsSupported = typeof window !== 'undefined' && 'Notification' in window;
 
 export function notifyPermission(): NotificationPermission {
@@ -83,15 +76,12 @@ const TITLE: Record<string, string> = {
    Rebase: 'Needs a rebase',
    'Re-stamp': 'Re-stamp owed',
    'Re-QA': 'Re-QA owed',
+   'Review it': 'Review requested',
 };
 
 function fire(p: DerivedPull, action: string) {
    try {
-      const title =
-         action === TURN_ACTION
-            ? `Your turn: review ${shortRepo(p.data.repo)}#${p.data.number}`
-            : (TITLE[action] ?? action);
-      const notification = new Notification(title, {
+      const notification = new Notification(TITLE[action] ?? action, {
          body: `${p.data.title} · ${shortRepo(p.data.repo)} #${p.data.number}`,
          // one live notification per PR: a newer state replaces the old one
          tag: pullKey(p.data),
@@ -126,22 +116,11 @@ export function testNotification() {
 /** At most this many individual alerts per update; a rare bigger burst collapses. */
 const MAX_PER_TICK = 5;
 
-/** Whether anyone has claimed this pull (model/reviewers' one claim predicate). */
-function isClaimed(p: DerivedPull): boolean {
-   return claimFor(p.data) != null;
-}
-
-/** Bot-authored pulls never earn a "your turn" nudge -- mirrors cheers.ts's
- * own isBot guard on the same turns input, so a starved Dependabot PR can't
- * page a human. */
-function isBot(p: DerivedPull): boolean {
-   return isSuffixBot(p.data.user.login);
-}
-
 /**
  * Desktop notifications for every real transition that lands on you — your PR
  * going mergeable, breaking CI, getting feedback or needing a rebase, and
- * re-CRs / re-QAs falling to you (model/actions alertMove). Watches the whole
+ * re-CRs / re-QAs and review requests falling to you (model/actions
+ * alertMove). Watches the whole
  * board, not the current filter.
  *
  * Only fires while the window is unfocused: when you're looking, the board
@@ -149,19 +128,10 @@ function isBot(p: DerivedPull): boolean {
  * baseline is recorded on every update regardless, so returning to the tab and
  * leaving again never replays what already happened, and the first payload
  * after load only primes the baseline instead of alerting for the backlog.
- *
- * Also covers the turn rotation (model/rotation.ts): a starved, unclaimed
- * pull whose rotation names YOU gets the same one-shot treatment as a real
- * alertMove transition. A claim by someone else must never notify — it's
- * their move now, not an event that landed on you.
  */
 export function useNotifications(
    pulls: DerivedPull[],
    me: string,
-   /** whose turn each starved, unclaimed pull is (pull key → login) — computed
-    * once in app.tsx and shared with the rows and the cheers evaluator, so the
-    * three surfaces can never disagree about whose turn it is */
-   turns: ReadonlyMap<string, string>,
    /** the board's first payload has arrived. While false the board is still
     * loading (an empty snapshot); recording that as the baseline would make
     * every real pull look "new" and fire a backlog of alerts once data lands. */
@@ -205,12 +175,7 @@ export function useNotifications(
       const current = new Map<string, string>();
       for (const p of pulls) {
          const action = alertMove(p, me);
-         if (action) {
-            current.set(pullKey(p.data), action);
-            continue;
-         }
-         const key = pullKey(p.data);
-         if (turns.get(key) === me && !isClaimed(p) && !isBot(p)) current.set(key, TURN_ACTION);
+         if (action) current.set(pullKey(p.data), action);
       }
 
       // record the baseline but stay silent while unprimed or focused
@@ -232,5 +197,5 @@ export function useNotifications(
       }
       if (fired > 0 && s.notifySound) chime();
       seen.current = current;
-   }, [ready, pulls, me, turns]);
+   }, [ready, pulls, me]);
 }
diff --git a/frontend-v2/src/settings.ts b/frontend-v2/src/settings.ts
index b8686fbe..0c6feae6 100644
--- a/frontend-v2/src/settings.ts
+++ b/frontend-v2/src/settings.ts
@@ -74,10 +74,6 @@ export interface Settings {
     * global laneCap" — old saved settings simply lack this field, so they
     * fall back to the object default below. */
    laneCapByLens: Record<string, number>;
-   /** teams that self-review (iFixit) don't gate on CR, so lining up QA is the
-    * real stall: surface "Find a QA-er" on your own PR as a home to-do, not a
-    * My-work afterthought. Off leaves getting QA in My work only. */
-   selfReview: boolean;
    /** your named rosters — REVIEW CIRCLES, yours to define, not the org
     * chart (an official team and a cross-team pairing partner can be two
     * separate rosters). Every roster's members get the same two effects:
@@ -90,9 +86,9 @@ export interface Settings {
     * to — hidden is the whole state. */
    hiddenPeople: string[];
    /** free-text areas you own or care about (e.g. "Growthbook", "Shopify").
-    * A PR whose title, body, labels, branch, or repo partial-matches any of
-    * these floats to the top of the review queue. Arbitrary strings, not a
-    * known set — unlike repos/logins. */
+    * Someone's self-reviewed PR whose title, body, labels, branch, or repo
+    * partial-matches any of these lands in Review's "Could use your input".
+    * Arbitrary strings, not a known set — unlike repos/logins. */
    codeRegions: string[];
    /** when an unfinished claim of yours starts nagging you to finish or
     * release it. Claims themselves don't expire on a timer — they clear when
@@ -168,7 +164,6 @@ export const DEFAULT_SETTINGS: Settings = {
    mutedCheers: [],
    laneCap: 10,
    laneCapByLens: {},
-   selfReview: true,
    teams: [],
    hiddenPeople: [],
    codeRegions: [],
diff --git a/frontend-v2/src/toasts.tsx b/frontend-v2/src/toasts.tsx
index 28e4b982..c3bf058d 100644
--- a/frontend-v2/src/toasts.tsx
+++ b/frontend-v2/src/toasts.tsx
@@ -82,16 +82,9 @@ const SAMPLE_CHEERS: CheerToast[] = [
       tone: 'info',
       icon: '🎯',
       title: 'Start here',
-      body: 'alice reviewed yours, return the favor',
+      body: 'alice asked you 2 hours ago',
       pull: { repo: 'org/repo', number: 88, title: 'Cache device images at the edge' },
    },
-   {
-      tone: 'info',
-      icon: '🤝',
-      title: 'Return the favor to alice',
-      body: "They've reviewed 3 of your PRs.",
-      pull: { repo: 'org/repo', number: 90, title: 'Add a retry to the webhook sender' },
-   },
    {
       tone: 'info',
       icon: '⚡',
@@ -161,15 +154,6 @@ const SAMPLE_CHEERS: CheerToast[] = [
       celebrate: true,
       shimmer: true,
    },
-   {
-      tone: 'nag',
-      icon: '⏳',
-      title: 'Your turn to review',
-      body: "Waiting 6d with nobody on it; you're the best fit. Claim it?",
-      pull: { repo: 'org/repo', number: 5, title: 'Discourage new files in Exec/ dir' },
-      actionLabel: 'Claim it',
-      onAction: () => undefined,
-   },
 ];
 
 interface LiveToast extends Toast {
@@ -192,17 +176,11 @@ const NO_PARKED: ReadonlyMap<string, string> = new Map();
 export function useToasts(
    pulls: DerivedPull[],
    me: string,
-   /** whose turn each starved, unclaimed pull is (pull key → login) — app.tsx
-    * computes it once for the rows, desktop notifications, and these cheers */
-   turns: ReadonlyMap<string, string>,
    extras: Toast[] = [],
    closed: PullData[] = [],
    /** clicking the quick-wins toast filters the board to the small ones rather
     * than scrolling to a single pull — a batch nudge wants a batch view */
    onQuickWins?: () => void,
-   /** the your-turn toast's "Claim it" button claims that review (which also
-    * adds you as a GitHub reviewer) — bound here since claiming is impure */
-   onClaimTurn?: (repo: string, number: number) => void,
    /** the board's first data has arrived. While false the board is still
     * loading (an empty snapshot), and diffing that against a primed baseline
     * would fire phantom "Board's clear" / "Inbox zero" and count every stamp
@@ -213,7 +191,7 @@ export function useToasts(
     * dependency-injection pattern as `closed`/`extras` above. */
    names: Readonly<Record<string, string | null>> = {},
    /** pull keys the viewer snoozed in Review — passed to evaluateCheers so a
-    * snoozed pull stops firing start-here / your-turn cheers. */
+    * snoozed pull stops firing start-here / quick-wins cheers. */
    snoozed: ReadonlySet<string> = new Set(),
    /** open PRs whose project is parked: start-here puts them last */
    parked: ReadonlyMap<string, string> = NO_PARKED
@@ -344,7 +322,6 @@ export function useToasts(
       const { toasts: fresh, next } = evaluateCheers(
          {
             pulls,
-            turns,
             closed,
             me,
             now: Date.now(),
@@ -361,20 +338,15 @@ export function useToasts(
       // only persist once loaded, so a load-time tick can't overwrite the saved
       // session with a not-yet-hydrated baseline
       if (ready) saveCheerSession(me, next, firedKeys.current);
-      // bind the impure actions the pure evaluator can't: quick-wins filters
-      // the board to the small ones (a batch nudge wants a batch view), and the
-      // your-turn nudge's "Claim it" button claims that review in place.
-      const bound = fresh.map(t => {
-         if (t.dedupeKey?.startsWith('quick:') && onQuickWins)
-            return { ...t, pull: undefined, onAct: onQuickWins };
-         if (t.dedupeKey?.startsWith('turn:') && onClaimTurn && t.pull) {
-            const { repo, number } = t.pull;
-            return { ...t, onAction: () => onClaimTurn(repo, number) };
-         }
-         return t;
-      });
+      // bind the impure action the pure evaluator can't: quick-wins filters
+      // the board to the small ones (a batch nudge wants a batch view)
+      const bound = fresh.map(t =>
+         t.dedupeKey?.startsWith('quick:') && onQuickWins
+            ? { ...t, pull: undefined, onAct: onQuickWins }
+            : t
+      );
       if (on) push(bound);
-   }, [ready, pulls, turns, closed, me, push, onQuickWins, onClaimTurn, names, snoozed, parked]);
+   }, [ready, pulls, closed, me, push, onQuickWins, names, snoozed, parked]);
 
    // pre-built one-shot toasts from the caller (e.g. the shipped catch-up),
    // deduped by dedupeKey so the same logical toast never re-fires on a later
@@ -443,7 +415,9 @@ function SparkleBurst() {
             <span
                // biome-ignore lint/suspicious/noArrayIndexKey: fixed-length decorative burst
                key={i}
-               className={`sparkle absolute block rounded-full ${s.tint} ${s.big ? 'h-1.5 w-1.5' : 'h-1 w-1'}`}
+               className={`sparkle absolute block rounded-full ${s.tint} ${
+                  s.big ? 'h-1.5 w-1.5' : 'h-1 w-1'
+               }`}
                style={
                   {
                      '--dx': `${s.dx}px`,
@@ -515,19 +489,21 @@ function ToastCard({ toast, onDismiss }: { toast: LiveToast; onDismiss: (id: num
    const tone = reward
       ? 'border-brand-100 bg-surface ring-1 ring-brand/15'
       : info
-        ? 'border-brand-100 bg-surface'
-        : 'border-line bg-muted';
+      ? 'border-brand-100 bg-surface'
+      : 'border-line bg-muted';
    const medallion = reward
       ? 'bg-brand-50 text-brand medallion-pop'
       : info
-        ? 'bg-brand-50 text-brand'
-        : 'bg-secondary text-ink-2 medallion-slump';
+      ? 'bg-brand-50 text-brand'
+      : 'bg-secondary text-ink-2 medallion-slump';
 
    return (
       <div
          className={`group pointer-events-auto relative flex items-start gap-3 rounded-xl border px-3.5 py-3 shadow-lg ${tone} ${
             toast.leaving ? 'toast-leave' : 'toast-enter'
-         } ${clickable ? 'cursor-pointer transition-[background-color] hover:brightness-[0.98]' : ''}`}
+         } ${
+            clickable ? 'cursor-pointer transition-[background-color] hover:brightness-[0.98]' : ''
+         }`}
          // a clickable card is a button to the keyboard/screen reader; the
          // polite live region still announces either way
          role={clickable ? 'button' : 'status'}
@@ -596,19 +572,6 @@ function ToastCard({ toast, onDismiss }: { toast: LiveToast; onDismiss: (id: num
                )
             )}
             {toast.body && <span className="mt-0.5 block text-xs text-ink-2">{toast.body}</span>}
-            {toast.actionLabel && toast.onAction && (
-               <button
-                  type="button"
-                  onClick={e => {
-                     e.stopPropagation();
-                     toast.onAction?.();
-                     onDismiss(toast.id);
-                  }}
-                  className="pressable mt-2 inline-flex items-center rounded-md bg-brand px-2.5 py-1 text-[11px] font-semibold text-surface hover:bg-brand-700"
-               >
-                  {toast.actionLabel}
-               </button>
-            )}
          </span>
          <button
             type="button"
diff --git a/frontend-v2/src/views/Ci.tsx b/frontend-v2/src/views/Ci.tsx
index 1e4853bd..5bf7156c 100644
--- a/frontend-v2/src/views/Ci.tsx
+++ b/frontend-v2/src/views/Ci.tsx
@@ -38,8 +38,8 @@ function LedgerGlance({ ledger }: { ledger: CheckLedger }) {
    const word = failing.length
       ? `${failing.length} of ${total} runs failing`
       : running
-        ? `${running} of ${total} still running`
-        : `all ${total} green`;
+      ? `${running} of ${total} still running`
+      : `all ${total} green`;
    return (
       <>
          <span
@@ -134,8 +134,8 @@ export function Ci({ pulls, opts }: { pulls: DerivedPull[]; opts: RowOptions })
            slowestFailing != null ? ` · slowest ~${ciSecsWord(slowestFailing)}` : ''
         }`
       : running.length
-        ? `no checks failing · ${running.length} PR${running.length === 1 ? '' : 's'} still running`
-        : 'every check passing';
+      ? `no checks failing · ${running.length} PR${running.length === 1 ? '' : 's'} still running`
+      : 'every check passing';
 
    return (
       <>
@@ -144,7 +144,7 @@ export function Ci({ pulls, opts }: { pulls: DerivedPull[]; opts: RowOptions })
          {mineBroken.length > 0 && (
             <Lane
                title="Your broken builds"
-               sub="nobody can review these until the build is green"
+               sub="fix these before you stamp or merge"
                pulls={mineBroken}
                cap={8}
                opts={opts}
@@ -217,12 +217,7 @@ export function Ci({ pulls, opts }: { pulls: DerivedPull[]; opts: RowOptions })
             cap={8}
             opts={opts}
          />
-         {allGreen && (
-            <EmptyState
-               title="All green"
-               sub="Every check on the board passed. Go review something."
-            />
-         )}
+         {allGreen && <EmptyState title="All green" sub="Every check on the board passed." />}
          {(green.length > 0 || noChecks.length > 0) && (
             <RestGroup title="The rest of the board">
                {green.length > 0 && (
diff --git a/frontend-v2/src/views/MyWork.tsx b/frontend-v2/src/views/MyWork.tsx
index c93488ee..e34da65d 100644
--- a/frontend-v2/src/views/MyWork.tsx
+++ b/frontend-v2/src/views/MyWork.tsx
@@ -38,7 +38,10 @@ import { ClosedRow } from '../components/ClosedRow';
  * word-group sub-headers render — lane and header can't disagree (splitting
  * on authorMove once put a brand "Chase CR" header inside "Waiting on
  * others", because the two models diverge on edge cases like external
- * blocks). Under them, your projects, in the Projects tab's own words.
+ * blocks). Under self-review your own CR and QA stamps are Your move too,
+ * unless you asked someone: then the PR waits on them, and a request nobody
+ * answers in 4 hours comes back as a nudge. Under them, your projects, in
+ * the Projects tab's own words.
  */
 
 export function MyWork({
@@ -60,6 +63,8 @@ export function MyWork({
    allClosed: PullData[];
 }) {
    const me = opts.me;
+   // your self-reviewed rows say when the diff is worth asking someone about
+   const rowOpts = { ...opts, askHint: true };
    const mine = pulls.filter(p => p.data.user.login === me);
    const byUrgency = (a: DerivedPull, b: DerivedPull) => b.ageDays - a.ageDays;
    const kindOf = (p: DerivedPull) => rowWord(p, me, { claim: claimFor(p.data) }).kind;
@@ -93,7 +98,7 @@ export function MyWork({
    return (
       <>
          <Lane title="Your move" pulls={[]} count={move.length} opts={opts}>
-            <WordGroupRows pulls={move} opts={opts} id="mine:move" cap={laneShown(12, opts)} />
+            <WordGroupRows pulls={move} opts={rowOpts} id="mine:move" cap={laneShown(12, opts)} />
             {!move.length && (
                <div className="px-3.5 py-3 text-[13px] text-ink-3">
                   Nothing needs you right now.
@@ -103,7 +108,7 @@ export function MyWork({
          <Lane title="Waiting on others" pulls={[]} count={waiting.length} opts={opts}>
             <WordGroupRows
                pulls={waiting}
-               opts={opts}
+               opts={rowOpts}
                id="mine:waiting"
                cap={laneShown(12, opts)}
             />
diff --git a/frontend-v2/src/views/Review.tsx b/frontend-v2/src/views/Review.tsx
index 03079469..6d59e53e 100644
--- a/frontend-v2/src/views/Review.tsx
+++ b/frontend-v2/src/views/Review.tsx
@@ -1,5 +1,6 @@
 import type { DerivedPull } from '../../../shared/model/status';
 import { pullKey, shortRepo } from '../../../shared/format';
+import { reviewIsMine } from '../model/actions';
 import { useNames } from '../model/names';
 import { matchedRegions } from '../model/regions';
 import { buildReviewLanes } from '../model/reviewLanes';
@@ -47,7 +48,7 @@ export function Review({
    standing?: PullStanding;
 }) {
    const me = opts.me;
-   const { selfReview, teams, codeRegions, repoPriority, repoQueueCap } = useSettings();
+   const { teams, codeRegions, repoPriority, repoQueueCap } = useSettings();
    // login -> human display name (app.tsx prefetches the board), for the
    // rank-reason popover's why-lines (model/reviewLanes.ts's whyUpNext/whyQaNext)
    const names = useNames();
@@ -72,14 +73,15 @@ export function Review({
    const bots = allBots.filter(p => !isSnoozed(p.data, snoozed));
    const botsForReady = allBotsForReady.filter(p => !isSnoozed(p.data, snoozed));
 
-   // Recently updated: your review work that moved recently, newest first.
-   // Bounded two ways so a quiet board stops resurfacing stale bumps — since
-   // you last hit Clear (isFresh) AND within the last RECENT_MAX_AGE_DAYS.
-   // Already-done and non-reviewable pulls drop out: a PR you hold a live CR
-   // stamp on is finished for you, and others' drafts or dev-blocked PRs
-   // aren't yours to act on. Your own PRs always stay; activity on them is
-   // worth seeing. A pull can still live in a lane below; this is a highlight,
-   // not an exclusive bucket, and only Clear empties it.
+   // Recently updated: your PRs and your review work that moved recently,
+   // newest first. Bounded two ways so a quiet board stops resurfacing stale
+   // bumps — since you last hit Clear (isFresh) AND within the last
+   // RECENT_MAX_AGE_DAYS. Someone else's PR is here only while its review is
+   // yours (reviewIsMine: asked of you, taken on, or nobody's on it), so
+   // other people's self-reviews don't stream past; one you hold a live CR
+   // stamp on is finished for you, and drafts or dev-blocked PRs aren't
+   // yours to act on. A pull can still live in a lane below; this is a
+   // highlight, not an exclusive bucket, and only Clear empties it.
    const RECENT_MAX_AGE_DAYS = 3;
    const recentCutoff = Date.now() - RECENT_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
    const changed = pulls
@@ -88,7 +90,10 @@ export function Review({
       .filter(
          p =>
             p.data.user.login === me ||
-            (!p.data.draft && p.status !== 'dev_block' && !p.crBy.includes(me))
+            (reviewIsMine(p, me) &&
+               !p.data.draft &&
+               p.status !== 'dev_block' &&
+               !p.crBy.includes(me))
       )
       .sort((a, b) => Date.parse(b.data.updated_at) - Date.parse(a.data.updated_at));
 
@@ -100,7 +105,6 @@ export function Review({
       napping,
       changed,
       me,
-      selfReview,
       teams,
       codeRegions,
       repoPriority,
@@ -136,22 +140,20 @@ export function Review({
       <>
          {codeRegions.length === 0 && <RegionHint />}
          {/* Leads the whole lens (owner call): fully finished work — signed
-             off, green, one press from shipped — is the fastest, highest-
-             leverage thing on the board, so clearing it comes before even your
-             own owed work below. Your OWN ready PR still also appears in
-             "Waiting on you" as a Merge-it; this lane is everyone else's done
-             work, landable by anyone. */}
+             off, green, one press from shipped. Your OWN ready PR appears in
+             "Waiting on you" as a Merge-it; this lane is everyone else's,
+             which their authors merge. */}
          <Lane
             title="Ready to merge"
             sub={
                <SubDoor
                   label="Why Ready to merge leads"
-                  text="signed off and green, someone just has to press merge"
+                  text="signed off and green, each author merges their own"
                >
                   <p>
                      Everything is done on these: code review and QA are in, CI is green, and they
-                     merge cleanly. The author usually lands their own PR, but anyone can. Merge it,
-                     or nudge the author if it’s been sitting.
+                     merge cleanly. Their authors merge them; it’s here so you can see what’s about
+                     to ship.
                   </p>
                   <p>
                      Bot PRs land here too once they’re fully green: they only ship when a human
@@ -179,15 +181,14 @@ export function Review({
                         If it’s in this lane, nothing happens until you act:
                      </p>
                      <p>
-                        PRs you approved that changed after your approval (they need a fresh
-                        re-stamp from you), feedback that needs your reply, your own PRs ready to
-                        merge, fix, or rebase, PRs someone asked you to review, and reviews you
-                        claimed.
+                        PRs someone asked you to review, first: answer those within hours. Then
+                        stamps of yours that a push undid, reviews you said you’d do, feedback that
+                        needs your reply, and your own PRs to stamp, merge, fix, or rebase.
                      </p>
                      <p>
-                        Each group is named for the action you’d take (Re-stamp, Respond, Merge…).
-                        The kinds of action that unblock other people come first; inside a group,
-                        the PR that has been open the longest comes first.
+                        Each group is named for the action you’d take (Review, Re-stamp, Merge…).
+                        Review requests run oldest request first; inside every other group, the PR
+                        that has been open the longest comes first.
                      </p>
                      {projectRule(
                         'A parked project’s PRs sink to the bottom of their group',
@@ -213,16 +214,16 @@ export function Review({
                sub={
                   <SubDoor
                      label="What lands in Waiting on others"
-                     text="your PRs and stamps, in someone else's hands"
+                     text="your PRs, in someone else's hands"
                   >
                      <p className="font-medium text-ink">Nothing here needs you right now:</p>
                      <p>
-                        your own PRs waiting on a review, QA, or CI, plus PRs you’ve already stamped
-                        that are still waiting on another reviewer.
+                        your own PRs waiting on people you asked for a review, on CI, or on a hold.
+                        A request nobody answers in 4 hours moves up to Waiting on you as a nudge.
                      </p>
                      <p>
-                        Each group is named for what the PR is waiting on (a review, a tester, CI, a
-                        re-stamp), so you can see where everything of yours is stuck.
+                        Each group is named for what the PR is waiting on, so you can see where
+                        everything of yours is stuck.
                      </p>
                   </SubDoor>
                }
@@ -243,19 +244,20 @@ export function Review({
             sub={
                <SubDoor
                   label="What lands in Recently updated"
-                  text={`PRs you can still act on that changed in the last ${RECENT_MAX_AGE_DAYS} days`}
+                  text={`your PRs and reviews that changed in the last ${RECENT_MAX_AGE_DAYS} days`}
                >
                   <p>
                      A PR shows up here when it changed since you last hit Clear, and that change
                      was in the last {RECENT_MAX_AGE_DAYS} days. Newest first.
                   </p>
                   <p>
-                     PRs you’ve already code reviewed drop out, along with other people’s drafts and
-                     dev-blocked PRs. Your own PRs always stay.
+                     Your own PRs always stay. Someone else’s shows up only while its review is
+                     yours: asked of you, one you said you’d review, or one from outside the dev
+                     team. It drops out once you’ve code reviewed it.
                   </p>
                   <p>
-                     The review queue below is a different list: it ranks other people’s PRs that
-                     need a review, whether or not anything changed.
+                     The review queue below is a different list: it ranks the reviews that are
+                     yours, whether or not anything changed.
                   </p>
                </SubDoor>
             }
@@ -273,39 +275,9 @@ export function Review({
          {/* below here is offered work, not owed work — the board's suggestion
              for what to pick up next, as distinct from "Waiting on you" above. The
              label only earns its place when something is actually on offer. */}
-         {(lanes.queue.length > 0 ||
-            lanes.needsQa.length > 0 ||
-            lanes.regionMatches.length > 0) && (
+         {(lanes.queue.length > 0 || lanes.needsQa.length > 0) && (
             <div className={`mb-2 text-ink-3 ${eyebrowText}`}>Pick up next</div>
          )}
-         {codeRegions.length > 0 && lanes.regionMatches.length > 0 && (
-            <Lane
-               title="In your code regions"
-               sub={
-                  <SubDoor label="How code regions match" text="areas you flagged in Settings">
-                     <p>
-                        A PR lands here when its title, description, labels, branch, or repo
-                        contains one of your regions. Plain text, case-insensitive, no regex.
-                     </p>
-                  </SubDoor>
-               }
-               pulls={lanes.regionMatches}
-               cap={8}
-               opts={{
-                  ...opts,
-                  // the lane heading already says "this is your region," so
-                  // the row-level region mark would just repeat it
-                  hideRegionMark: true,
-                  rankReason: p => {
-                     const r = matchedRegions(p, codeRegions);
-                     return lanes.whyProject(
-                        p,
-                        r.length ? `It touches ${r.join(', ')}, a code region you flagged` : null
-                     );
-                  },
-               }}
-            />
-         )}
          {repoPriority.length > 0 ? (
             // the owner's priority-and-cap model: contiguous per-repo blocks in
             // the Settings repo order, each block score-ranked inside and
@@ -318,8 +290,13 @@ export function Review({
                sub={
                   <SubDoor
                      label="How the queue is ranked"
-                     text="your repos in your order, best first"
+                     text="reviews that are yours, your repos in your order"
                   >
+                     <p>
+                        Developers review their own PRs unless they ask, so this holds only reviews
+                        that are yours: asked of you, ones you said you’d do, and PRs from outside
+                        the dev team that nobody’s on yet.
+                     </p>
                      <p className="font-medium text-ink">
                         Repos appear as blocks in your repo order (Settings), each showing its best
                         few:
@@ -329,19 +306,19 @@ export function Review({
                         blocks entirely; they lead the lane whatever repo they’re from.
                      </p>
                      <p>
-                        Inside a block: your team’s PRs first, then repos you’ve reviewed before,
-                        people who review your work, and small quick wins, lightest first. Bot PRs
-                        sink to each block’s bottom. The per-repo cap folds the rest behind “+N
-                        more” so one busy repo can’t take the whole screen.
+                        Inside a block: your team’s PRs first, then repos you’ve reviewed before and
+                        small quick wins, lightest first. Bot PRs sink to each block’s bottom. The
+                        per-repo cap folds the rest behind “+N more” so one busy repo can’t take the
+                        whole screen.
                      </p>
                      {projectRule(
                         'A parked project’s PRs sink below everyone else’s, above the bot PRs',
                         'When two PRs rank the same with age in whole days'
                      )}
-                     <p>PRs you claim stay in the queue and also appear in Waiting on you.</p>
                      <p>
-                        Starving PRs and PRs in your code regions still show up in their repo block
-                        below; the call-outs above are copies, not removals.
+                        PRs you said you’d review stay in the queue and also appear in Waiting on
+                        you. Starving PRs still show up in their repo block below; the call-out
+                        above is a copy, not a removal.
                      </p>
                   </SubDoor>
                }
@@ -353,7 +330,9 @@ export function Review({
                   count={lanes.queueStarved.length}
                   label="Starving"
                   tone="do"
-                  gloss={`Waited ${opts.ageWarnDays ?? 4}+ days for review; these outrank your repo order.`}
+                  gloss={`Waited ${
+                     opts.ageWarnDays ?? 4
+                  }+ days for review; these outrank your repo order.`}
                   id="review:queue:starving"
                   defaultOpen
                >
@@ -364,7 +343,9 @@ export function Review({
                      key={b.repo}
                      count={b.pulls.length}
                      label={shortRepo(b.repo)}
-                     gloss={`${shortRepo(b.repo)}’s reviewable PRs, best first; your repo order (Settings) decides where the block sits.`}
+                     gloss={`${shortRepo(
+                        b.repo
+                     )}’s reviewable PRs, best first; your repo order (Settings) decides where the block sits.`}
                      id={`review:queue:${b.repo}`}
                      defaultOpen
                   >
@@ -382,7 +363,15 @@ export function Review({
             <Lane
                title="Review queue"
                sub={
-                  <SubDoor label="How the queue is ranked" text="one queue, best next review first">
+                  <SubDoor
+                     label="How the queue is ranked"
+                     text="reviews that are yours, best first"
+                  >
+                     <p>
+                        Developers review their own PRs unless they ask, so this holds only reviews
+                        that are yours: asked of you, ones you said you’d do, and PRs from outside
+                        the dev team that nobody’s on yet.
+                     </p>
                      <p className="font-medium text-ink">One score ranks every card:</p>
                      <p>
                         PRs that have waited {opts.ageWarnDays ?? 4}+ days for review jump to the
@@ -394,18 +383,16 @@ export function Review({
                         is no extra ranking between teammates.
                      </p>
                      <p>
-                        After those: PRs in repos you’ve reviewed before, PRs from people who review
-                        your work, and small quick wins, lightest first. Bot PRs (dependency bumps)
-                        sink to the bottom.
+                        After those: PRs in repos you’ve reviewed before and small quick wins,
+                        lightest first. Bot PRs (dependency bumps) sink to the bottom.
                      </p>
                      {projectRule(
                         'A parked project’s PRs sink below everyone else’s, above the bot PRs',
                         'When two PRs rank the same with age in whole days'
                      )}
-                     <p>PRs you claim stay in the queue and also appear in Waiting on you.</p>
                      <p>
-                        PRs in your code regions still show up in the queue below; the call-out
-                        above is a copy, not a removal.
+                        PRs you said you’d review stay in the queue and also appear in Waiting on
+                        you.
                      </p>
                   </SubDoor>
                }
@@ -423,7 +410,8 @@ export function Review({
                >
                   <p>
                      QA runs in parallel with CR, so a pull can sit here and in the review queue at
-                     once.
+                     once. Like the queue, it holds only QA that’s yours: a self-reviewed PR’s
+                     author tests it.
                   </p>
                   <p>
                      Anything QA-incomplete with green CI lands here, unless it’s a draft, blocked,
@@ -440,12 +428,44 @@ export function Review({
             cap={6}
             opts={{ ...opts, rankReason: lanes.whyQaNext }}
          />
+         {/* an offer, not a debt: folded, uncounted, and outside the deal */}
+         {lanes.couldUseInput.length > 0 && (
+            <RestGroup
+               title="Could use your input"
+               sub="Nobody asked, but these touch your areas. Add yourself as a reviewer if you jump in."
+            >
+               <Fold
+                  count={lanes.couldUseInput.length}
+                  showCount={false}
+                  label="Self-reviews in your areas"
+                  gloss="Their authors review these themselves. Your code regions first, then repos you’ve reviewed in."
+                  id="review:could-use-input"
+               >
+                  <FoldRows
+                     list={lanes.couldUseInput}
+                     opts={{
+                        ...opts,
+                        rankReason: p => {
+                           const r = matchedRegions(p, codeRegions);
+                           return lanes.whyProject(
+                              p,
+                              r.length
+                                 ? `It touches ${r.join(', ')}, a code region you flagged`
+                                 : `In ${shortRepo(p.data.repo)}, where you’ve reviewed before`
+                           );
+                        },
+                     }}
+                     id="review:could-use-input"
+                  />
+               </Fold>
+            </RestGroup>
+         )}
          {(lanes.restTotal > 0 || lanes.napping.length > 0) && (
             <RestGroup title="The rest of the board">
                <Fold
                   count={lanes.queueOther.length}
                   label="Review, other repos"
-                  gloss="Reviewable, just outside your primary repos. The queue above sticks to the repos you actually review."
+                  gloss="Reviews that are yours, just outside your primary repos. The queue above sticks to the repos you actually review."
                   id="review:other-repos"
                   defaultOpen={lanes.boardIsQuiet}
                >
@@ -454,7 +474,7 @@ export function Review({
                <Fold
                   count={lanes.needsQaOther.length}
                   label="QA, other repos"
-                  gloss="Needs a tester, just outside your primary repos."
+                  gloss="QA that’s yours, just outside your primary repos."
                   id="review:qa-other-repos"
                   defaultOpen={lanes.boardIsQuiet}
                >
@@ -495,7 +515,7 @@ export function Review({
                <Fold
                   count={lanes.ciRed.length}
                   label="CI failing"
-                  gloss="Fully signed off, but a required CI check is failing; the author fixes the build, then it's ready. (A red build still awaiting review stays in the queue; reviewing it is your call.)"
+                  gloss="Fully signed off, but a required CI check is failing; the author fixes the build, then it's ready."
                   id="review:ci-red"
                   defaultOpen={lanes.boardIsQuiet}
                >
diff --git a/frontend-v2/src/views/Team.tsx b/frontend-v2/src/views/Team.tsx
index 8bb21f00..312a2e6d 100644
--- a/frontend-v2/src/views/Team.tsx
+++ b/frontend-v2/src/views/Team.tsx
@@ -1,10 +1,8 @@
 import { useMemo, useState, type MouseEvent } from 'react';
 import { ChevronRight, Plus } from 'lucide-react';
-import { authorOwnsIt, parked } from '../model/actions';
+import { askedOf, authorOwnsIt, parked } from '../model/actions';
 import { displayName, useNames } from '../model/names';
-import type { DerivedPull } from '../../../shared/model/status';
-import { matchesRegion } from '../model/regions';
-import { crSort } from '../model/sort';
+import { CR_INCOMPLETE, type DerivedPull } from '../../../shared/model/status';
 import { teamBuckets } from '../model/team';
 import { addTeam, DEFAULT_TEAM_NAME, myPeople, useSettings } from '../settings';
 import { createPersistentStore } from '../storage';
@@ -111,7 +109,7 @@ export function Team({
    const isOpen = (key: string) => openMap[key] ?? false;
    const toggleOpen = (key: string) =>
       teamOpenStore.set({ ...teamOpenStore.get(), [key]: !isOpen(key) });
-   const { teams: personalTeams, codeRegions, hiddenPeople } = useSettings();
+   const { teams: personalTeams, hiddenPeople } = useSettings();
    const yourPeople = myPeople(personalTeams);
    const yourSet = new Set(yourPeople);
    // login -> human name for the roster rows (app.tsx prefetches the board)
@@ -126,11 +124,14 @@ export function Team({
       for (const p of allPulls) m.set(p.data.user.login, (m.get(p.data.user.login) ?? 0) + 1);
       return m;
    }, [allPulls]);
+   // reviews asked of each person that they haven't stamped yet: the one
+   // review debt under self-review, answered in hours
    const owes = useMemo(() => {
       const m = new Map<string, DerivedPull[]>();
       for (const p of allPulls.filter(x => !parked(x) && !authorOwnsIt(x))) {
-         for (const u of p.recrBy) m.set(u, [...(m.get(u) ?? []), p]);
-         for (const u of p.reqaBy) m.set(u, [...(m.get(u) ?? []), p]);
+         if (!CR_INCOMPLETE.includes(p.status) && p.status !== 'needs_qa') continue;
+         for (const u of askedOf(p).filter(l => !p.crBy.includes(l)))
+            m.set(u, [...(m.get(u) ?? []), p]);
       }
       return m;
    }, [allPulls]);
@@ -176,8 +177,7 @@ export function Team({
       // members is rebuilt per render; its join is the stable identity
       [pulls, members.join(','), me]
    );
-   const regionMatches = home ? crSort(reviewable.filter(p => matchesRegion(p, codeRegions))) : [];
-   const owed = selectedPerson ? (owes.get(selectedPerson) ?? []) : [];
+   const owed = selectedPerson ? owes.get(selectedPerson) ?? [] : [];
    const shipping = theirs.filter(p => ['ready', 'needs_qa'].includes(p.status)).length;
 
    // the directory: busiest authors lead, hidden ones drop out unless the
@@ -200,9 +200,9 @@ export function Team({
          <span
             className="inline-flex items-center gap-0.5 text-[11px] font-semibold tabular-nums"
             style={{ color: 'var(--warn)' }}
-            title={`owes ${owes.get(login)!.length} re-stamp${
+            title={`${owes.get(login)!.length} review${
                owes.get(login)!.length === 1 ? '' : 's'
-            }`}
+            } asked of them`}
          >
             <span className="pip pip-stale" />
             {owes.get(login)!.length}
@@ -368,9 +368,9 @@ export function Team({
             <div className="mx-auto flex max-w-[440px] flex-col items-center gap-3 py-12 text-center">
                <h2 className="m-0 text-lg font-semibold text-ink">Build your team</h2>
                <p className="m-0 text-[13px] text-ink-3">
-                  Pick the people whose work you review: your review circle, not the org chart.
-                  Their combined board becomes this tab’s home, and their PRs lead your review
-                  queues. Or click anyone above to see just their work.
+                  Pick the people you work with, not the org chart. Their combined board becomes
+                  this tab’s home, and when they ask you for a review it leads your queue. Or click
+                  anyone above to see just their work.
                </p>
                <div className="w-full rounded-2xl border border-line bg-surface p-3 text-left">
                   <TeamPicker teamName={DEFAULT_TEAM_NAME} extraBots={extraBots} />
@@ -390,8 +390,8 @@ export function Team({
                <span>
                   <span className="text-base leading-snug font-semibold">
                      {selectedPerson
-                        ? (nameOf(selectedPerson) ?? selectedPerson)
-                        : (explicitTeam ?? `${selected.length} people`)}
+                        ? nameOf(selectedPerson) ?? selectedPerson
+                        : explicitTeam ?? `${selected.length} people`}
                   </span>
                   <br />
                   <span className="text-xs text-ink-3">
@@ -409,7 +409,7 @@ export function Team({
                <span className="ml-auto flex gap-4 text-center text-xs text-ink-3">
                   <span>
                      <b className="block text-base text-ink-2 tabular-nums">{reviewable.length}</b>
-                     you can review
+                     for you to review
                   </span>
                   <span>
                      <b className="block text-base text-ink-2 tabular-nums">{shipping}</b>
@@ -418,7 +418,7 @@ export function Team({
                   {selectedPerson && (
                      <span>
                         <b className="block text-base text-ink-2 tabular-nums">{owed.length}</b>
-                        {owed.length === 1 ? 're-stamp owed' : 're-stamps owed'}
+                        asked of them
                      </span>
                   )}
                </span>
@@ -436,28 +436,18 @@ export function Team({
                <EmptyState title="All clear" sub="Nothing open from your team right now." />
             )}
 
-         {codeRegions.length > 0 && regionMatches.length > 0 && (
-            <Lane
-               title="In your code regions"
-               sub={
-                  <SubDoor label="How code regions match" text="areas you flagged in Settings">
-                     <p>
-                        A PR lands here when its title, description, labels, branch, or repo
-                        contains one of your regions. Plain text, case-insensitive, no regex.
-                     </p>
-                  </SubDoor>
-               }
-               pulls={regionMatches}
-               cap={8}
-               // the lane heading already says "this is your region," so the
-               // row-level region mark would just repeat it
-               opts={{ ...opts, hideRegionMark: true }}
-            />
-         )}
          <Lane
-            title="Review queue"
+            title="For you to review"
             sub={
-               <SubDoor label="How this queue is ordered" text="best next review first">
+               <SubDoor
+                  label="What lands in For you to review"
+                  text="their PRs whose review is yours"
+               >
+                  <p>
+                     Developers review their own PRs unless they ask, so this holds only reviews
+                     that are yours: asked of you, ones you said you’d do, and PRs from outside the
+                     dev team that nobody’s on yet. Everything else they have open is below.
+                  </p>
                   <p>
                      Lightest first, so a short break fits a review. A PR that needs just one more
                      approval jumps up (yours would finish it), and PRs move up as they wait. PRs
@@ -473,7 +463,7 @@ export function Team({
              lens groups on — a live stamp of yours emerges as the "stamped"
              group instead of needing its own hand-made fold */}
          {(stamped.length > 0 || rest.length > 0 || owed.length > 0) && (
-            <RestGroup title="The rest of their work">
+            <RestGroup title="What they’re working on">
                <WordGroupRows
                   pulls={[...stamped, ...rest]}
                   opts={opts}
@@ -484,8 +474,8 @@ export function Team({
                {selectedPerson && (
                   <Fold
                      count={owed.length}
-                     label="Re-stamps they owe"
-                     gloss="Their earlier approval went stale after new commits; a fresh re-stamp from them is owed to the author."
+                     label="Reviews asked of them"
+                     gloss="Someone asked them for a review on these and they haven’t stamped yet. Requests are answered in hours."
                      id="team:owed"
                   >
                      <FoldRows list={owed} opts={opts} id="team:owed" />
diff --git a/frontend-v2/src/views/projects/Portfolio.tsx b/frontend-v2/src/views/projects/Portfolio.tsx
index 638ff518..cdfb0e0d 100644
--- a/frontend-v2/src/views/projects/Portfolio.tsx
+++ b/frontend-v2/src/views/projects/Portfolio.tsx
@@ -305,7 +305,7 @@ const COLUMNS: Column[] = [
    {
       key: 'waiting',
       label: 'In review',
-      title: 'Waiting on review: its open PRs waiting on a CR or QA',
+      title: 'In review: its open PRs still owed a CR or QA, the author’s own or someone’s they asked',
       width: 'w-14',
       hide: 'hidden 2xl:block',
       cell: i => i.waiting || '',
diff --git a/frontend-v2/src/views/projects/Work.tsx b/frontend-v2/src/views/projects/Work.tsx
index 152f5c2b..81b945f6 100644
--- a/frontend-v2/src/views/projects/Work.tsx
+++ b/frontend-v2/src/views/projects/Work.tsx
@@ -272,8 +272,7 @@ function PullItem({
    // the row shows itself (the face, a flag, the age), starting the note: a
    // login never takes a capital
    const parts: ReactNode[] = [];
-   const who =
-      live && !whoSaid ? holderWords(live, { turns: opts.turns, line: true, onRow: true }) : '';
+   const who = live && !whoSaid ? holderWords(live, { line: true, onRow: true }) : '';
    if (who) parts.push(who);
    if (late) parts.push(parts.length ? late : upperFirst(late));
    // a person's PR this page's counts leave out, the way every view does
@@ -547,9 +546,7 @@ function IssueLine({
       n(issue.prs.length, 'PR'),
       ...[...others].map(([word, count]) => `${count} ${word}`),
    ].join(', ');
-   const who = standing.pull
-      ? holderWords(standing.pull, { turns: opts.turns, ageWarnDays: opts.ageWarnDays })
-      : '';
+   const who = standing.pull ? holderWords(standing.pull, { ageWarnDays: opts.ageWarnDays }) : '';
    // anywhere on the line but its links opens or closes its PRs
    const lineClick = (e: MouseEvent) => {
       if (!has || (e.target as HTMLElement).closest('a,button,input,label')) return;

From 98459b0c530e663a5a37381f34dd24d24b8586f2 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:33:20 -0700
Subject: [PATCH 06/17] Show a review request's age on the row

Requests are answered in hours under the self-review policy, but the
"asked 3h ago" clock only lived in the state popover. Rows waiting on
someone who was asked now carry it as a flag ("asked 3h ago", or
"review asked" for a team request with no time), amber past 4 hours,
naming who was asked on hover.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/components/Row.tsx | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/frontend-v2/src/components/Row.tsx b/frontend-v2/src/components/Row.tsx
index d3ee2f05..74a89adc 100644
--- a/frontend-v2/src/components/Row.tsx
+++ b/frontend-v2/src/components/Row.tsx
@@ -12,7 +12,7 @@ import {
 } from 'lucide-react';
 import type { DerivedPull } from '../../../shared/model/status';
 import { isIterating, lastPushEpoch } from '../../../shared/model/status';
-import { askForInputHint, type Claim, rowNote } from '../model/actions';
+import { askedAgo, askForInputHint, askOverdue, type Claim, rowNote } from '../model/actions';
 import { matchedRegions } from '../model/regions';
 import { claimFor } from '../model/reviewers';
 import type { ParentRef } from '../model/stack';
@@ -181,6 +181,19 @@ function rowFlags(
               }
       );
    }
+   // a review someone was asked for runs on hours, so its clock sits on the
+   // row, amber once nobody has answered in ASK_OVERDUE_HOURS
+   if (p.askedOf.length && ['needs_cr', 'needs_recr', 'needs_qa'].includes(p.status)) {
+      const team = (p.data.requested_teams ?? []).length ? ' (through a team request)' : '';
+      flags.push({
+         key: 'asked',
+         tone: askOverdue(p) ? 'warn' : 'note',
+         label: askedAgo(p) ?? 'review asked',
+         detail: `Review asked of ${p.askedOf.join(
+            ', '
+         )}${team}. Requests get an answer within hours.`,
+      });
+   }
    if (p.mergeUnknown && p.status === 'ready')
       flags.push({
          key: 'merge',

From ca22fdc9a6eb038a841c7a19539973d89ac1f27a Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:38:12 -0700
Subject: [PATCH 07/17] Stop treating answered or unasked reviewers as owing
 work

A review found three holes in the self-review model:

1) A CR comment doesn't clear GitHub's review request, so a reviewer
   who had stamped stayed "asked": the author was told to nudge them,
   and everyone on a requested team was told to QA it. askedOf now
   drops anyone whose CR already counts.
2) Someone who stamped a self-reviewed PR without being asked was told
   to re-stamp after the next push. On a self-reviewed PR only the
   author owes a re-stamp now.
3) A team request had no time, so it never got the hours clock. The
   wire gains team_requests (slug and time); members inherit their
   team's time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/status.test.ts | 61 +++++++++++++++++++++++++---
 shared/model/status.ts               | 43 ++++++++++++++------
 shared/types.ts                      |  5 +++
 3 files changed, 91 insertions(+), 18 deletions(-)

diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index 6fd57d2f..a995202a 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -127,7 +127,11 @@ describe('status derivation precedence', () => {
    });
 
    it('an invalidated CR makes needs_recr, and names who owes the re-stamp', () => {
-      const p = withStatus({ allCR: [sig('CR', 'reviewer', false)] });
+      // asked to review, so the re-stamp is theirs (see the self-review policy)
+      const p = withStatus(
+         { allCR: [sig('CR', 'reviewer', false)] },
+         { requested_reviewers: ['reviewer'] }
+      );
       const d = derive(p, undefined, NOW);
       expect(d.status).toBe('needs_recr');
       expect(d.recrBy).toEqual(['reviewer']);
@@ -245,10 +249,13 @@ describe('status derivation precedence', () => {
    });
 
    it('tracks stale QA stamps symmetrically with stale CR', () => {
-      const p = withStatus({
-         allCR: [sig('CR', 'r', true)],
-         allQA: [sig('QA', 'tester', false)],
-      });
+      const p = withStatus(
+         {
+            allCR: [sig('CR', 'r', true)],
+            allQA: [sig('QA', 'tester', false)],
+         },
+         { requested_reviewers: ['tester'] }
+      );
       const d = derive(p, undefined, NOW);
       expect(d.status).toBe('needs_qa');
       expect(d.reqaBy).toEqual(['tester']);
@@ -467,6 +474,50 @@ describe('the self-review policy', () => {
       expect(unknown.askedOf).toEqual([]);
    });
 
+   it('a reviewer who stamped is no longer asked, though GitHub keeps the request', () => {
+      const p = withStatus(
+         { allCR: [sig('CR', 'bob', true)] },
+         {
+            requested_reviewers: ['bob', 'carol'],
+            review_requests: [
+               { login: 'bob', at: NOW - 5 * 3600, self: false },
+               { login: 'carol', at: NOW - 3600, self: false },
+            ],
+         }
+      );
+      const d = derive(p, undefined, NOW);
+      expect(d.askedOf).toEqual(['carol']);
+      expect(d.askedAt).toBe(NOW - 3600);
+   });
+
+   it("a team's members get the team's request time", () => {
+      const policy = reviewPolicy({ Store: ['a', 'b'] });
+      const d = derive(
+         pull({ requested_teams: ['store'], team_requests: [{ slug: 'store', at: NOW - 7200 }] }),
+         undefined,
+         NOW,
+         undefined,
+         undefined,
+         policy
+      );
+      expect(d.askedOf).toEqual(['a', 'b']);
+      expect(d.askedAt).toBe(NOW - 7200);
+   });
+
+   it('on a self-reviewed pull only the author owes a re-stamp', () => {
+      // carol stamped unasked, then the author pushed: nobody asked carol
+      const favor = withStatus({ allCR: [sig('CR', 'carol', false)] });
+      const d = derive(favor, undefined, NOW);
+      expect(d.status).toBe('needs_cr');
+      expect(d.recrBy).toEqual([]);
+      // but someone who was asked still owes theirs
+      const asked = withStatus(
+         { allCR: [sig('CR', 'carol', false)] },
+         { requested_reviewers: ['carol'] }
+      );
+      expect(derive(asked, undefined, NOW).recrBy).toEqual(['carol']);
+   });
+
    it("someone outside the dev team doesn't review their own", () => {
       const d = derive(pull(), undefined, NOW, undefined, undefined, OUTSIDER);
       expect(d.ownReview).toBe(false);
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 157c41c0..d60ad9ad 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -322,20 +322,31 @@ export function derive(
    const staleCr = staleUsers(st.allCR);
    const staleQa = staleUsers(st.allQA);
 
-   // who the author's side asked: people (not claims, which are a reviewer
-   // volunteering) and every member of a requested roster team
+   // who the author's side asked and hasn't answered: people (not claims,
+   // which are a reviewer volunteering) and every member of a requested
+   // roster team, minus anyone whose CR already counts. A CR comment doesn't
+   // clear GitHub's request, so without that a stamped reviewer would stay
+   // "asked" (and the author would be told to nudge them).
    const claims = new Set((pull.review_requests ?? []).filter(r => r.self).map(r => r.login));
    const requestedTeams = pull.requested_teams ?? [];
+   const teamOf = new Map<string, string>();
+   for (const t of requestedTeams)
+      for (const l of policy.teams.get(t.toLowerCase()) ?? []) teamOf.set(l, t.toLowerCase());
    const askedOf = unique([
       ...(pull.requested_reviewers ?? []).filter(l => !claims.has(l)),
-      ...requestedTeams.flatMap(t => policy.teams.get(t.toLowerCase()) ?? []),
-   ]).filter(l => l !== author);
-   const askedAt =
-      Math.min(
-         ...(pull.review_requests ?? [])
-            .filter(r => !r.self && r.at != null && askedOf.includes(r.login))
-            .map(r => r.at as number)
-      ) || null;
+      ...teamOf.keys(),
+   ]).filter(l => l.toLowerCase() !== author.toLowerCase() && !crBy.includes(l));
+   // a person's own request time, else their team's
+   const teamAt = new Map(
+      (pull.team_requests ?? []).map(t => [t.slug.toLowerCase(), t.at] as const)
+   );
+   const askedTimes = askedOf.map(
+      l =>
+         (pull.review_requests ?? []).find(r => !r.self && r.login === l)?.at ??
+         teamAt.get(teamOf.get(l) ?? '') ??
+         null
+   );
+   const askedAt = Math.min(...askedTimes.filter((t): t is number => t != null));
    const ownReview =
       isDeveloper(policy, author) &&
       !(pull.requested_reviewers ?? []).length &&
@@ -381,10 +392,16 @@ export function derive(
    // scores, the turn rotation) — must never see them as rotting
    const isParked = !!label(LABELS.cryo);
 
+   // on a self-reviewed pull only the author owes a re-stamp: anyone else's
+   // stamp there was a favor nobody asked for, so a push doesn't put them
+   // on the hook
+   const owedCr = ownReview ? staleCr.filter(u => u === author) : staleCr;
+   const owedQa = ownReview ? staleQa.filter(u => u === author) : staleQa;
+
    let status: Status;
    if (pull.draft) status = 'draft';
    else if (devBlockedBy.length) status = 'dev_block';
-   else if (!crMet && staleCr.length) status = 'needs_recr';
+   else if (!crMet && owedCr.length) status = 'needs_recr';
    else if (!crMet) status = 'needs_cr';
    else if (!qaMet) status = 'needs_qa';
    // CI gates readiness only (see the Status doc): a red or pending build
@@ -431,8 +448,8 @@ export function derive(
       qaHave,
       // a stale stamp only owes a re-stamp while the requirement is unmet —
       // once others satisfy it, nothing is asked of the stale signer
-      recrBy: crMet ? [] : staleCr,
-      reqaBy: qaMet ? [] : staleQa,
+      recrBy: crMet ? [] : owedCr,
+      reqaBy: qaMet ? [] : owedQa,
       headPushedAt: headPushedAt(pull),
       ageDays,
       signedOffAt,
diff --git a/shared/types.ts b/shared/types.ts
index 716f81b5..48526d1e 100644
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -102,6 +102,11 @@ export interface PullData {
     * (config projects.developerTeams), matched by name. Absent on older
     * servers: read as []. */
    requested_teams?: string[];
+   /** when each requested team was asked (epoch secs, null if unknown), from
+    * the review_requested webhook; a team's members inherit its time, so a
+    * team request gets the same hours clock as a personal one. Absent on
+    * older servers: read as []. */
+   team_requests?: Array<{ slug: string; at: number | null }>;
    /** areas the diff touches that usually deserve team input (ci, migrations,
     * alerting, agent-docs, deploy, dependencies), computed server-side from
     * the changed file paths. Absent until the server has looked: read as []. */

From 0ff50807221ac50f8e1dfd7cf832bcfea1dc01d3 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:44:32 -0700
Subject: [PATCH 08/17] Fix the board's review flow where review found holes

1) Being asked to review means code review: a requested reviewer sees
   "Review it" while it's in review, never "QA it". The author tests
   their own ("Stamp QA"); Needs QA holds only claims and PRs from
   outside the dev team or bots.
2) The "Starving" block in the review queue is gone. Requests of you
   come first, oldest request first, then the rest of the queue.
3) "Board's clear" only counts review that's yours.
4) Stats' "Asked" no longer counts a claim.
5) Ready to merge shows your own ready PRs, plus others' only when you
   were asked or said you'd review; the author merges. It replaces the
   Merge row in Waiting on you.
6) A team request that names nobody on the roster is in nobody's
   queue: the author sees "waiting on a review from {team}", and it
   can show under Could use your input.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/actions.test.ts     |  62 +++++++++--
 frontend-v2/src/model/actions.ts          |  77 +++++++++----
 frontend-v2/src/model/cheers.test.ts      |  29 +++++
 frontend-v2/src/model/cheers.ts           |   9 +-
 frontend-v2/src/model/repoBlocks.test.ts  |  16 +--
 frontend-v2/src/model/repoBlocks.ts       |  20 +---
 frontend-v2/src/model/reviewLanes.test.ts | 126 ++++++++++++++++++----
 frontend-v2/src/model/reviewLanes.ts      | 113 ++++++++++---------
 frontend-v2/src/model/stats.test.ts       |  13 ++-
 frontend-v2/src/model/stats.ts            |   4 +-
 frontend-v2/src/views/Review.tsx          |  73 +++++--------
 11 files changed, 355 insertions(+), 187 deletions(-)

diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index c4e4be8b..1a3252e0 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -10,6 +10,8 @@ import {
    DO_WORD,
    DO_WORD_RANK,
    reviewerMove,
+   nobodysReview,
+   qaIsMine,
    rowNote,
    reviewIsMine,
    rowWord,
@@ -28,6 +30,7 @@ function dp(o: {
    /** a claim: who said they'd review it (review_requests self === true) */
    claimedBy?: { login: string; at: number | null };
    inputHints?: string[];
+   requestedTeams?: string[];
    author?: string;
    status: Status;
    conflict?: boolean;
@@ -63,6 +66,7 @@ function dp(o: {
          },
          review_requests: o.claimedBy ? [{ ...o.claimedBy, self: true }] : [],
          input_hints: o.inputHints,
+         requested_teams: o.requestedTeams,
       },
       ownReview: o.ownReview ?? false,
       askedOf: o.askedOf ?? [],
@@ -877,7 +881,7 @@ describe('self-review: a developer CRs and QAs their own unrequested pull', () =
       });
       expect(rowNote(dp({ author: 'me', status: 'needs_qa', ownReview: true }), 'me')).toEqual({
          action: 'Stamp QA',
-         context: 'test it yourself, or request a review',
+         context: 'test it yourself, or ask someone to',
       });
       expect(rowWord(dp({ author: 'me', status: 'needs_cr', ownReview: true }), 'me')).toEqual({
          kind: 'do',
@@ -919,19 +923,19 @@ describe('self-review: a developer CRs and QAs their own unrequested pull', () =
 describe('review requests: asked of people, answered in hours', () => {
    const hoursAgo = (h: number) => Date.now() / 1000 - h * 3600;
 
-   it('asked of me: Review it (or QA it), with the request’s age', () => {
+   it('asked of me: Review it with the request’s age, and never QA it', () => {
       expect(
          rowNote(
             dp({ author: 'a', status: 'needs_cr', askedOf: ['me'], askedAt: hoursAgo(3.5) }),
             'me'
          )
       ).toEqual({ action: 'Review it', context: 'asked 3h ago' });
-      expect(
-         rowNote(
-            dp({ author: 'a', status: 'needs_qa', askedOf: ['me'], askedAt: hoursAgo(0.2) }),
-            'me'
-         )
-      ).toEqual({ action: 'QA it', context: 'asked just now' });
+      // CR is met and I'm still listed: the author tests their own
+      const qa = dp({ author: 'a', status: 'needs_qa', askedOf: ['me'], askedAt: hoursAgo(0.2) });
+      expect(rowNote(qa, 'me')).toEqual({ action: null, context: 'a tests it' });
+      expect(rowWord(qa, 'me')).toEqual({ kind: 'wait', word: 'self-review' });
+      // only an outside tester's pull (nobody asked) is anyone's QA
+      expect(rowNote(dp({ author: 'a', status: 'needs_qa' }), 'me').action).toBe('QA it');
       expect(rowNote(dp({ author: 'a', status: 'needs_cr', askedOf: ['me'] }), 'me')).toEqual({
          action: 'Review it',
          context: 'review requested',
@@ -1189,3 +1193,45 @@ describe('DO_WORD / WAIT_WORD_RANK — drift guard', () => {
       expect(WAIT_WORD_RANK).toEqual(expect.arrayContaining(produced));
    });
 });
+
+describe('the requested reviewer reviews; the author tests', () => {
+   it('the author sees Stamp QA once everyone asked has stamped and CR is met', () => {
+      const p = dp({ author: 'me', status: 'needs_qa', askedOf: [], requestedTeams: ['store'] });
+      expect(rowNote(p, 'me').action).toBe('Stamp QA');
+      // even while another asked reviewer is still listed
+      expect(rowNote(dp({ author: 'me', status: 'needs_qa', askedOf: ['bob'] }), 'me').action).toBe(
+         'Stamp QA'
+      );
+   });
+
+   it('an outside author still waits on a tester', () => {
+      expect(rowNote(dp({ author: 'me', status: 'needs_qa' }), 'me')).toEqual({
+         action: null,
+         context: 'waiting on a tester',
+      });
+   });
+
+   it('a team request naming nobody: the author waits on the team, nobody owes it', () => {
+      const p = dp({ author: 'me', status: 'needs_cr', requestedTeams: ['store-front'] });
+      expect(rowNote(p, 'me')).toEqual({
+         action: null,
+         context: 'waiting on a review from store-front',
+      });
+      expect(reviewIsMine(p, 'bob')).toBe(false);
+      expect(rowNote(p, 'bob').action).toBeNull();
+      expect(nobodysReview(p)).toBe(true);
+   });
+
+   it('QA belongs to a claimer or an outside tester, not to someone asked', () => {
+      const asked = dp({ author: 'a', status: 'needs_qa', askedOf: ['me'] });
+      expect(qaIsMine(asked, 'me')).toBe(false);
+      expect(qaIsMine(dp({ author: 'a', status: 'needs_qa' }), 'me')).toBe(true);
+      const claimed = dp({
+         author: 'a',
+         status: 'needs_qa',
+         claimedBy: { login: 'me', at: 1 },
+      });
+      expect(qaIsMine(claimed, 'me')).toBe(true);
+      expect(qaIsMine(claimed, 'bob')).toBe(false);
+   });
+});
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index 07d16331..8855b32d 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -49,12 +49,24 @@ export function askedAgo(p: DerivedPull, now?: number): string | null {
 export const askOverdue = (p: DerivedPull, now?: number): boolean =>
    (askedHours(p, now) ?? 0) >= ASK_OVERDUE_HOURS;
 
+/** A review was requested of someone (a person or a team), whether or not it
+ * still names anyone who owes it. */
+const hasRequest = (p: DerivedPull): boolean =>
+   !!(askedOf(p).length || p.data.requested_reviewers?.length || p.data.requested_teams?.length);
+
+/** Needs a reviewer from outside: the author is outside the dev team (or a
+ * bot), and nobody was asked or took it on. The only pulls where QA is not
+ * the author's own job. */
+const needsOutsideReview = (p: DerivedPull): boolean =>
+   !selfReviewed(p) && !hasRequest(p) && !claimFor(p.data);
+
 /**
- * Whether this pull is `me`'s review work: asked of me (by name or through a
- * team), or one I said I'd review; otherwise one that needs someone else and
- * that nobody was asked for or took on (an author outside the dev team, or a
- * team request naming nobody on the roster). Never my own, and never a
- * developer's own unrequested pull: its review is its author's.
+ * Whether this pull is `me`'s code review: asked of me (by name or through a
+ * team), or one I said I'd review; otherwise one from outside the dev team
+ * that nobody was asked for or took on. Never my own, never a developer's own
+ * unrequested pull (its review is its author's), and never a request that
+ * names nobody who still owes it (a team nobody on the roster is in, or
+ * everyone asked has stamped): that one shows in "Could use your input".
  */
 export function reviewIsMine(p: DerivedPull, me: string): boolean {
    if (p.data.user.login === me) return false;
@@ -62,10 +74,24 @@ export function reviewIsMine(p: DerivedPull, me: string): boolean {
    if (claim?.login === me) return true;
    const asked = askedOf(p);
    if (asked.length) return asked.includes(me);
-   if (claim) return false;
+   if (claim || hasRequest(p)) return false;
    return !selfReviewed(p);
 }
 
+/** Whether this pull's QA is `me`'s. A requested reviewer was asked for a
+ * review, not a test: under the policy the author tests their own. QA goes to
+ * a claimer, or to anyone when the pull needs an outside tester. */
+export function qaIsMine(p: DerivedPull, me: string): boolean {
+   if (p.data.user.login === me) return false;
+   const claim = claimFor(p.data);
+   return claim ? claim.login === me : needsOutsideReview(p);
+}
+
+/** Requested of a team nobody on the roster is in, or of people who have all
+ * answered: nobody's review work, but worth showing to anyone who might help. */
+export const nobodysReview = (p: DerivedPull): boolean =>
+   hasRequest(p) && !askedOf(p).length && !claimFor(p.data);
+
 const INPUT_HINT_WORDS: Record<string, string> = {
    ci: 'CI',
    migrations: 'migrations',
@@ -237,6 +263,11 @@ function authorNote(p: DerivedPull, me: string): RowNote {
    }
    if (p.status === 'needs_qa' && p.qaingLogin)
       return waitOnly(`${who([p.qaingLogin])} is testing it`);
+   // asked reviewers are for the review; QA is the author's own under the
+   // policy, so once CR is met it's yours to stamp whoever is still listed
+   const authorIsDev = selfReviewed(p) || hasRequest(p);
+   if (p.status === 'needs_qa' && authorIsDev)
+      return { action: 'Stamp QA', context: 'test it yourself, or ask someone to' };
    // you asked for a review: theirs to give, answered in hours
    const asked = askedOf(p);
    if (asked.length) {
@@ -247,10 +278,11 @@ function authorNote(p: DerivedPull, me: string): RowNote {
    }
    const claim = claimFor(d);
    if (claim) return waitOnly(`${claim.login} is reviewing it`);
-   if (selfReviewed(p))
-      return reviewing
-         ? { action: 'Stamp CR', context: 'review it yourself, or request a review' }
-         : { action: 'Stamp QA', context: 'test it yourself, or request a review' };
+   // a team request that names nobody on the roster: nobody to nudge, so wait
+   if (d.requested_teams?.length)
+      return waitOnly(`waiting on a review from ${andList(d.requested_teams)}`);
+   if (authorIsDev)
+      return { action: 'Stamp CR', context: 'review it yourself, or request a review' };
    // outside the dev team: someone else reviews it, nobody's been asked yet
    if (p.status === 'needs_recr')
       return waitOnly(`waiting on ${who(p.recrBy)} to re-stamp${pushed}`);
@@ -335,17 +367,24 @@ function reviewerNote(p: DerivedPull, me: string, extra?: { claim?: Claim | null
          const since = claim.at != null ? ` · ${ago(claim.at)} ago` : '';
          return { action: 'Finish your review', context: `you said you’d review it${since}` };
       }
-      if (asked.includes(me))
-         return { action: reviewing ? 'Review it' : 'QA it', context: when ?? 'review requested' };
+      // a request asks for a code review: never QA, which is the author's own
+      if (asked.includes(me) && reviewing)
+         return { action: 'Review it', context: when ?? 'review requested' };
       if (claim) return waitOnly(`${claim.login} is reviewing it`);
+      if (p.status === 'needs_qa') {
+         if (needsOutsideReview(p))
+            return { action: 'QA it', context: p.qaHave > 0 ? `${p.qaHave} of ${qaReq} in` : null };
+         return waitOnly(selfReviewed(p) ? 'in self-review' : `${author} tests it`);
+      }
       if (p.status === 'needs_recr') return waitOnly(`waiting on ${who(p.recrBy)}${pushed}`);
       if (asked.length) return waitOnly(`waiting on ${who(asked)}${when ? ` · ${when}` : ''}`);
       // the author reviews their own: nobody else owes it anything
       if (selfReviewed(p)) return waitOnly('in self-review');
-      // needs someone else and nobody's on it: an author outside the dev
-      // team, or a request to a team nobody on the roster is in
-      if (p.status === 'needs_qa')
-         return { action: 'QA it', context: p.qaHave > 0 ? `${p.qaHave} of ${qaReq} in` : null };
+      // a request that names nobody who still owes it: nobody's job in particular
+      if (d.requested_teams?.length)
+         return waitOnly(`waiting on a review from ${andList(d.requested_teams)}`);
+      if (hasRequest(p)) return waitOnly(`${p.crHave} of ${crReq} in`);
+      // needs someone else and nobody's on it: an author outside the dev team
       const context = p.starved
          ? `waiting ${p.ageDays}d`
          : p.crHave > 0
@@ -468,7 +507,7 @@ export function waitWord(p: DerivedPull, me: string, extra?: { claim?: Claim | n
    // who it waits on, once nobody's specifically owed a stamp by you
    const holder = () => {
       if (claim && claim.login !== me) return 'claimed';
-      if (askedOf(p).length) return 'review requested';
+      if (askedOf(p).length || hasRequest(p)) return 'review requested';
       if (selfReviewed(p)) return 'self-review';
       return null;
    };
@@ -491,7 +530,9 @@ export function waitWord(p: DerivedPull, me: string, extra?: { claim?: Claim | n
          if (p.qaBy.includes(me)) return 'stamped';
          if (p.qaingLogin) return 'in QA';
          if (isAuthor && p.reqaBy.length && !askedOf(p).length) return 'waiting on re-QA';
-         return holder() ?? 'waiting on QA';
+         // QA is the author's own unless an outside tester is needed
+         if (claim && claim.login !== me) return 'claimed';
+         return needsOutsideReview(p) ? 'waiting on QA' : 'self-review';
       case 'needs_recr':
          if (p.crBy.includes(me)) return 'stamped';
          return holder() ?? 'waiting on re-CR';
diff --git a/frontend-v2/src/model/cheers.test.ts b/frontend-v2/src/model/cheers.test.ts
index 5389f0d3..bdbe1c2c 100644
--- a/frontend-v2/src/model/cheers.test.ts
+++ b/frontend-v2/src/model/cheers.test.ts
@@ -844,6 +844,35 @@ describe('evaluateCheers — self-review', () => {
    });
 });
 
+describe('evaluateCheers — board-cleared counts only reviews that are yours', () => {
+   const open = (n: number, o: Partial<DerivedPull>, askedOf: string[] = []) =>
+      ({
+         ...pull('org/a', n, { author: 'alice', askedOf }),
+         dependent: false,
+         qaingLogin: null,
+         crHave: 0,
+         qaHave: 0,
+         changesRequestedBy: [],
+         engagedNoStamp: [],
+         ciFailing: [],
+         headPushedAt: null,
+         devBlockedBy: [],
+         deployBlockedBy: [],
+         externalBlock: false,
+         cryo: false,
+         ...o,
+      } as DerivedPull);
+
+   it('ignores a self-review, but counts a review asked of you', () => {
+      const selfReview = open(1, { ownReview: true });
+      const asked = open(2, {}, ['me']);
+      const base = (pulls: DerivedPull[]) =>
+         evaluateCheers({ pulls, me: 'me', ready: true }, EMPTY_BASELINE).next.boardQueue;
+      expect(base([selfReview])).toBe(0);
+      expect(base([selfReview, asked])).toBe(1);
+   });
+});
+
 describe('cheer catalog', () => {
    it('documents exactly every toast kind, once each', () => {
       const catalogKinds = CHEER_CATALOG.map(c => c.kind);
diff --git a/frontend-v2/src/model/cheers.ts b/frontend-v2/src/model/cheers.ts
index 23b754bf..858f48f4 100644
--- a/frontend-v2/src/model/cheers.ts
+++ b/frontend-v2/src/model/cheers.ts
@@ -1,6 +1,6 @@
 import { pullKey } from '../../../shared/format';
 import type { PullData } from '../../../shared/types';
-import { actionState, askedHours, askedOf, STALE_CLAIM_SECS } from './actions';
+import { actionState, askedHours, askedOf, reviewIsMine, STALE_CLAIM_SECS } from './actions';
 import { dealFrom, dealRank } from './deal';
 import { reviewerRanks } from './leaderboard';
 import { displayName } from './names';
@@ -406,8 +406,13 @@ function readSignals(input: CheerInput): Signals {
       });
    }
 
+   // only review that's yours: a developer's self-review waiting on its own
+   // author doesn't hold the board back
    const boardReviewable = pulls.filter(
-      p => !p.cryo && (CR_INCOMPLETE.includes(p.status) || p.status === 'needs_qa')
+      p =>
+         !p.cryo &&
+         (CR_INCOMPLETE.includes(p.status) || p.status === 'needs_qa') &&
+         reviewIsMine(p, me)
    ).length;
 
    // claims of yours gone stale that you still haven't stamped — the nudge to
diff --git a/frontend-v2/src/model/repoBlocks.test.ts b/frontend-v2/src/model/repoBlocks.test.ts
index edc5c355..54469f70 100644
--- a/frontend-v2/src/model/repoBlocks.test.ts
+++ b/frontend-v2/src/model/repoBlocks.test.ts
@@ -2,11 +2,9 @@ import { describe, expect, it } from 'vitest';
 import { repoBlocks } from './repoBlocks';
 import type { DerivedPull } from '../../../shared/model/status';
 
-const pull = (repo: string, n: number, starved = false) =>
-   ({ data: { repo, number: n }, starved }) as unknown as DerivedPull;
+const pull = (repo: string, n: number) => ({ data: { repo, number: n } } as unknown as DerivedPull);
 
 const shape = (r: ReturnType<typeof repoBlocks>) => ({
-   starved: r.starved.map(p => p.data.number),
    blocks: r.blocks.map(b => ({ repo: b.repo, nums: b.pulls.map(p => p.data.number) })),
 });
 
@@ -14,7 +12,6 @@ describe('repoBlocks', () => {
    it('partitions into contiguous blocks in priority order', () => {
       const queue = [pull('ops', 1), pull('mono', 2), pull('ops', 3), pull('mono', 4)];
       expect(shape(repoBlocks(queue, ['mono', 'ops']))).toEqual({
-         starved: [],
          blocks: [
             { repo: 'mono', nums: [2, 4] },
             { repo: 'ops', nums: [1, 3] },
@@ -27,17 +24,6 @@ describe('repoBlocks', () => {
       expect(shape(repoBlocks(queue, ['ops'])).blocks[0].nums).toEqual([9, 1, 5]);
    });
 
-   it('surfaces starved pulls as a highlight while keeping them in their own repo block', () => {
-      const queue = [pull('mono', 1), pull('ops', 2, true), pull('mono', 3, true), pull('ops', 4)];
-      expect(shape(repoBlocks(queue, ['mono', 'ops']))).toEqual({
-         starved: [2, 3],
-         blocks: [
-            { repo: 'mono', nums: [1, 3] },
-            { repo: 'ops', nums: [2, 4] },
-         ],
-      });
-   });
-
    it('unlisted repos trail the listed ones, ordered by their best pull', () => {
       const queue = [pull('tail-b', 1), pull('mono', 2), pull('tail-a', 3), pull('tail-b', 4)];
       expect(shape(repoBlocks(queue, ['mono'])).blocks.map(b => b.repo)).toEqual([
diff --git a/frontend-v2/src/model/repoBlocks.ts b/frontend-v2/src/model/repoBlocks.ts
index 13b1470d..445fc8a5 100644
--- a/frontend-v2/src/model/repoBlocks.ts
+++ b/frontend-v2/src/model/repoBlocks.ts
@@ -9,16 +9,9 @@ import type { DerivedPull } from '../../../shared/model/status';
  * reviewers receiving twenty AI-assisted producers' output must not
  * monopolize the screen).
  *
- * Two guarantees survive the partition:
- * - Starved pulls are surfaced as a highlight (returned separately, still in
- *   rank order) AND kept in their own repo block — a starved pull from a
- *   low-priority repo is never hidden by a higher-priority repo's block,
- *   unlike an earlier version that extracted starved pulls out of the
- *   blocks entirely and could bury one behind a high-volume repo's "show
- *   more" fold.
- * - Order WITHIN a block is exactly the incoming order (stable partition),
- *   so teammates still lead and the score still ranks — the priority only
- *   decides which repo's run comes first, never which pull is "best".
+ * Order WITHIN a block is exactly the incoming order (stable partition), so
+ * requests still lead and the score still ranks: the priority only decides
+ * which repo's run comes first, never which pull is "best".
  *
  * Repos in the queue but absent from the priority list trail the listed
  * ones, ordered by their best pull's rank (first appearance in the incoming
@@ -29,11 +22,7 @@ export interface RepoBlock {
    pulls: DerivedPull[];
 }
 
-export function repoBlocks(
-   queue: DerivedPull[],
-   priority: string[]
-): { starved: DerivedPull[]; blocks: RepoBlock[] } {
-   const starved = queue.filter(p => p.starved);
+export function repoBlocks(queue: DerivedPull[], priority: string[]): { blocks: RepoBlock[] } {
    const byRepo = new Map<string, DerivedPull[]>();
    for (const p of queue) {
       const list = byRepo.get(p.data.repo);
@@ -44,7 +33,6 @@ export function repoBlocks(
    // Map preserves insertion order = first appearance in rank order
    const unlisted = [...byRepo.keys()].filter(r => !priority.includes(r));
    return {
-      starved,
       blocks: [...listed, ...unlisted].map(repo => ({
          repo,
          pulls: byRepo.get(repo) ?? [],
diff --git a/frontend-v2/src/model/reviewLanes.test.ts b/frontend-v2/src/model/reviewLanes.test.ts
index c1635fc3..ae857f02 100644
--- a/frontend-v2/src/model/reviewLanes.test.ts
+++ b/frontend-v2/src/model/reviewLanes.test.ts
@@ -49,6 +49,7 @@ function dp(o: {
    branch?: string;
    reviewRequests?: { login: string; at: number | null; self: boolean }[];
    requestedReviewers?: string[];
+   requestedTeams?: string[];
 }): DerivedPull {
    return {
       data: {
@@ -76,6 +77,7 @@ function dp(o: {
          })),
          review_requests: o.reviewRequests ?? [],
          requested_reviewers: o.requestedReviewers ?? [],
+         requested_teams: o.requestedTeams ?? [],
          draft: o.draft ?? false,
       },
       status: o.status ?? 'needs_cr',
@@ -221,10 +223,12 @@ describe('buildReviewLanes — needs QA', () => {
 });
 
 describe('buildReviewLanes — waiting on you vs waiting on others', () => {
-   it('puts your own ready-to-merge pull in yourMove', () => {
+   it('leaves your own ready-to-merge pull to the Ready to merge lane, not Waiting on you', () => {
+      // the lane leads the tab; listing it in both places only duplicated the Merge row
       const mine = dp({ author: 'me', status: 'ready' });
       const lanes = buildReviewLanes(input({ pulls: [mine] }));
-      expect(lanes.yourMove).toEqual([mine]);
+      expect(lanes.ready).toEqual([mine]);
+      expect(lanes.yourMove).toEqual([]);
       expect(lanes.yoursWaiting).not.toContain(mine);
    });
 
@@ -283,7 +287,6 @@ describe('buildReviewLanes — self-review: nobody else is assigned a developer
       const ownQa = dp({ number: 2, author: 'alice', status: 'needs_qa', ownReview: true });
       const lanes = buildReviewLanes(input({ pulls: [own, ownQa] }));
       expect(lanes.queue).toEqual([]);
-      expect(lanes.queueStarved).toEqual([]);
       expect(lanes.queueOther).toEqual([]);
       expect(lanes.needsQa).toEqual([]);
       expect(lanes.needsQaOther).toEqual([]);
@@ -393,34 +396,55 @@ describe('buildReviewLanes — could use your input', () => {
 });
 
 describe('buildReviewLanes — stamped and ready lanes', () => {
-   it('places a fully signed-off human pull in ready', () => {
-      const p = dp({ author: 'alice', status: 'ready' });
+   it('places your own fully signed-off pull in ready', () => {
+      const p = dp({ author: 'me', status: 'ready' });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
       expect(lanes.ready).toEqual([p]);
    });
 
-   it('includes a ready bot PR in ready alongside human ones, oldest first', () => {
-      const human = dp({ author: 'alice', status: 'ready', ageDays: 1 });
-      const bot = dp({ author: 'dependabot[bot]', number: 2, status: 'ready', ageDays: 5 });
-      const lanes = buildReviewLanes(input({ pulls: [human], bots: [bot] }));
-      expect(lanes.ready).toEqual([bot, human]);
+   it('shows another person’s ready pull only when you were asked to review it or claimed it', () => {
+      const plain = dp({ number: 1, author: 'alice', status: 'ready' });
+      const asked = dp({ number: 2, author: 'alice', status: 'ready', requestedReviewers: ['me'] });
+      const claimed = dp({
+         number: 3,
+         author: 'alice',
+         status: 'ready',
+         requestedReviewers: ['me'],
+         reviewRequests: [{ login: 'me', at: 1, self: true }],
+      });
+      const askedOther = dp({
+         number: 4,
+         author: 'alice',
+         status: 'ready',
+         requestedReviewers: ['bob'],
+      });
+      const lanes = buildReviewLanes(input({ pulls: [plain, asked, claimed, askedOther] }));
+      expect(lanes.ready.map(p => p.data.number).sort()).toEqual([2, 3]);
+   });
+
+   it('orders ready oldest first, and leaves an unclaimed ready bot PR in the bot fold', () => {
+      const newer = dp({ number: 1, author: 'me', status: 'ready', ageDays: 1 });
+      const older = dp({ number: 2, author: 'me', status: 'ready', ageDays: 5 });
+      const bot = dp({ author: 'dependabot[bot]', number: 3, status: 'ready', ageDays: 9 });
+      const lanes = buildReviewLanes(input({ pulls: [newer, older], bots: [bot] }));
+      expect(lanes.ready).toEqual([older, newer]);
+      expect(lanes.botRest).toEqual([bot]);
    });
 
    it('draws ready’s bot portion from botsForReady, not bots, when the two differ', () => {
       // "Ignore bot PRs" empties `bots` (the queue-tail/fold pool) but
-      // botsForReady bypasses that setting — Ready-to-merge must still
-      // surface the bot PR even though it's absent from `bots`.
-      const bot = dp({ author: 'dependabot[bot]', status: 'ready' });
+      // botsForReady bypasses that setting, so a bot PR you claimed still
+      // shows in Ready-to-merge even though it's absent from `bots`.
+      const bot = dp({
+         author: 'dependabot[bot]',
+         status: 'ready',
+         requestedReviewers: ['me'],
+         reviewRequests: [{ login: 'me', at: 1, self: true }],
+      });
       const lanes = buildReviewLanes(input({ pulls: [], bots: [], botsForReady: [bot] }));
       expect(lanes.ready).toEqual([bot]);
    });
 
-   it('falls back to bots for ready when botsForReady is omitted', () => {
-      const bot = dp({ author: 'dependabot[bot]', status: 'ready' });
-      const lanes = buildReviewLanes(input({ pulls: [], bots: [bot] }));
-      expect(lanes.ready).toEqual([bot]);
-   });
-
    it('keeps a stamped (CR-incomplete, your stamp live) pull out of the queue', () => {
       const p = dp({ author: 'alice', status: 'needs_cr', crBy: ['me'], crReq: 2 });
       const lanes = buildReviewLanes(input({ pulls: [p] }));
@@ -446,7 +470,6 @@ describe('buildReviewLanes — board summary', () => {
       const bot = dp({ author: 'dependabot[bot]', status: 'ready' });
       const lanes = buildReviewLanes(input({ botsForReady: [bot] }));
       expect(lanes.empty).toBe(false);
-      expect(lanes.ready).toContain(bot);
    });
 
    it('boardIsQuiet is false once the queue has something in it', () => {
@@ -568,8 +591,8 @@ describe('buildReviewLanes — projects', () => {
       expect(
          buildReviewLanes(input({ pulls: [qaParked, qaOther], standing: parked })).needsQa
       ).toEqual([qaOther, qaParked]);
-      const readyParked = dp({ number: 1, author: 'alice', status: 'ready', ageDays: 9 });
-      const readyOther = dp({ number: 2, author: 'bob', status: 'ready', ageDays: 1 });
+      const readyParked = dp({ number: 1, author: 'me', status: 'ready', ageDays: 9 });
+      const readyOther = dp({ number: 2, author: 'me', status: 'ready', ageDays: 1 });
       const lanes = buildReviewLanes(input({ pulls: [readyParked, readyOther], standing: parked }));
       expect(lanes.ready).toEqual([readyOther, readyParked]);
       expect(lanes.whyProject(readyParked, null)).toBe('Parked project: picker');
@@ -629,3 +652,62 @@ describe('buildReviewLanes — projects', () => {
       );
    });
 });
+
+describe('buildReviewLanes — requests run on hours, and QA is the author’s', () => {
+   it('leads the queue with requests of you, oldest request first, ahead of a starving pull', () => {
+      const old = dp({
+         number: 1,
+         author: 'alice',
+         status: 'needs_cr',
+         starved: true,
+         ageDays: 30,
+      });
+      const late = dp({
+         number: 2,
+         author: 'bob',
+         status: 'needs_cr',
+         requestedReviewers: ['me'],
+         askedAt: 2000,
+      });
+      const early = dp({
+         number: 3,
+         author: 'carol',
+         status: 'needs_cr',
+         requestedReviewers: ['me'],
+         askedAt: 1000,
+         repo: 'org/elsewhere',
+      });
+      const lanes = buildReviewLanes(input({ pulls: [old, late, early] }));
+      expect(lanes.queue).toEqual([early, late, old]);
+      expect(lanes).not.toHaveProperty('queueStarved');
+   });
+
+   it('does not hand a requested reviewer the QA: only outside testers and claims reach Needs QA', () => {
+      const asked = dp({
+         number: 1,
+         author: 'alice',
+         status: 'needs_qa',
+         requestedReviewers: ['me'],
+      });
+      const outside = dp({ number: 2, author: 'zed', status: 'needs_qa' });
+      const claimed = dp({
+         number: 3,
+         author: 'alice',
+         status: 'needs_qa',
+         requestedReviewers: ['me'],
+         reviewRequests: [{ login: 'me', at: 1, self: true }],
+      });
+      const lanes = buildReviewLanes(input({ pulls: [asked, outside, claimed] }));
+      expect(lanes.needsQa).toEqual(expect.arrayContaining([outside, claimed]));
+      expect(lanes.needsQa).not.toContain(asked);
+      expect(lanes.queue).not.toContain(asked);
+   });
+
+   it('keeps a team request that names nobody out of every queue, but offers it in Could use your input', () => {
+      const p = dp({ author: 'alice', status: 'needs_cr', requestedTeams: ['ghost'] });
+      const lanes = buildReviewLanes(input({ pulls: [p], codeRegions: ['repo'] }));
+      expect(lanes.queue).toEqual([]);
+      expect(lanes.needsQa).toEqual([]);
+      expect(lanes.couldUseInput).toEqual([p]);
+   });
+});
diff --git a/frontend-v2/src/model/reviewLanes.ts b/frontend-v2/src/model/reviewLanes.ts
index cd3ca411..061d66af 100644
--- a/frontend-v2/src/model/reviewLanes.ts
+++ b/frontend-v2/src/model/reviewLanes.ts
@@ -15,6 +15,8 @@ import {
    authorOwnsIt,
    DO_WORD_RANK,
    reviewerMove,
+   nobodysReview,
+   qaIsMine,
    reviewIsMine,
    rowNote,
    rowWord,
@@ -107,12 +109,9 @@ export interface ReviewLanes {
    /** the one ranked review queue (dealRank + teamFirst) when no repo
     * priority is set */
    queue: DerivedPull[];
-   /** reviewable, non-starved pulls outside your primary repos — folded away
+   /** reviewable pulls outside your primary repos — folded away
     * in "the rest of the board" */
    queueOther: DerivedPull[];
-   /** starved pulls piercing the repo-block partition (only meaningful with
-    * repoPriority set) */
-   queueStarved: DerivedPull[];
    /** the review queue's contiguous per-repo blocks (only meaningful with
     * repoPriority set) */
    queueBlocks: RepoBlock[];
@@ -156,10 +155,10 @@ const NO_STANDING: PullStanding = { parked: new Map(), finishing: new Map() };
 
 /** Your own pulls contribute only their do-it-now verbs to the home lane:
  * under self-review your own stamps and a request gone quiet are daily work.
- * "Undraft" always stays in My work (planning, not minutes). */
+ * "Undraft" always stays in My work (planning, not minutes). "Merge it" is
+ * the Ready to merge lane's, which leads the tab. */
 const OWN_DO_NOW = [
    'Re-stamp',
-   'Merge it',
    'Fix CI',
    'Address feedback',
    'Stamp CR',
@@ -242,7 +241,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
          reviewIsMine(p, me) &&
          (p.status === 'needs_cr' || (p.status === 'needs_recr' && !p.recrBy.includes(me)))
    );
-   const nonStarved = crPool.filter(p => !p.starved);
 
    // Bot PRs (dependency bumps, mostly) are review work too — someone has to
    // move the daily ones along — just low priority. The reviewable ones join
@@ -259,9 +257,12 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
             (p.status === 'needs_cr' || (p.status === 'needs_recr' && !p.recrBy.includes(me)))
       )
       .sort(bySecurityThenAge);
+   // a ready PR is on the Ready lane only when it's yours, asked of you, or claimed
+   const readyMine = (p: DerivedPull) =>
+      p.data.user.login === me || askedOf(p).includes(me) || claimFor(p.data)?.login === me;
    const botKeys = new Set(botReviewable.map(p => pullKey(p.data)));
    const botRest = bots
-      .filter(p => !botKeys.has(pullKey(p.data)) && p.status !== 'ready')
+      .filter(p => !botKeys.has(pullKey(p.data)) && !(p.status === 'ready' && readyMine(p)))
       .sort(bySecurityThenAge);
    const isDemoted = (p: DerivedPull) => botKeys.has(pullKey(p.data));
 
@@ -286,8 +287,8 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
          p.qaingLogin !== me &&
          !p.qaBy.includes(me) &&
          !p.reqaBy.includes(me) &&
-         // a self-reviewed PR's QA is its author's
-         reviewIsMine(p, me)
+         // QA is the author's own, except for an outside tester or a claim
+         qaIsMine(p, me)
    );
    const qaSort = (list: DerivedPull[]) =>
       [...list].sort(
@@ -320,7 +321,7 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       crSort(
          others.filter(
             p =>
-               selfReviewed(p) &&
+               (selfReviewed(p) || nobodysReview(p)) &&
                !p.cryo &&
                !authorOwnsIt(p) &&
                (CR_INCOMPLETE.includes(p.status) || p.status === 'needs_qa') &&
@@ -332,54 +333,54 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       codeRegions
    );
 
-   // ONE review queue: your primary repos' reviewables, every starved pull
-   // regardless of repo (the fairness backstop rides in the ranking now, not
-   // a separate Aging lane — starveScore's uncapped age × size term floats
-   // them to the top numerically instead of positionally), and the day's bot
-   // bumps sinking to the tail. The top of this lane IS the board's best
-   // next pickup; the retired "Deal me one" button dealt this exact order,
-   // which is why the button became redundant and was removed. Non-starved
-   // work outside your primary repos still folds into "other repos" below,
-   // reachable but not in the way. A parked project's PRs sink below every
-   // other person's, teammates' included, and above the bots.
+   // ONE review queue: reviews asked of you lead, oldest request first (they
+   // are answered in hours), whatever repo they're from. Then your primary
+   // repos' other reviewables (claims, outside-dev pulls) by the deal score,
+   // the day's bot bumps sinking to the tail. The top of this lane IS the
+   // board's best next pickup. A parked project's PRs sink below every other
+   // person's, teammates' included, and above the bots.
    const dealOpts = { me, pulls, deprioritize: isDemoted, warnDays: ageWarnDays };
    const classOf = (p: DerivedPull) => (isDemoted(p) ? 2 : sunk(p) ? 1 : 0);
-   const queue = finishersFirst(
-      sinkBy(
-         teamFirst(
-            dealRank(
-               [
-                  ...nonStarved.filter(p => isPrimaryRepo(p.data.repo)),
-                  ...crPool.filter(p => p.starved),
-                  ...botReviewable,
-               ],
-               dealOpts
+   const requestedOfMe = (p: DerivedPull) => askedOf(p).includes(me);
+   const requests = crPool
+      .filter(requestedOfMe)
+      .sort((a, b) => (a.askedAt ?? Infinity) - (b.askedAt ?? Infinity));
+   const queue = [
+      ...requests,
+      ...finishersFirst(
+         sinkBy(
+            teamFirst(
+               dealRank(
+                  [
+                     ...crPool.filter(p => !requestedOfMe(p) && isPrimaryRepo(p.data.repo)),
+                     ...botReviewable,
+                  ],
+                  dealOpts
+               ),
+               team
             ),
-            team
+            classOf
          ),
-         classOf
+         // the score in days of waiting, as the why line counts them
+         p =>
+            `${classOf(p)}|${team.has(p.data.user.login)}|${Math.round(
+               dealScore(p, dealOpts) * (ageWarnDays ?? STARVE_DAYS)
+            )}`,
+         finishes
       ),
-      // the score in days of waiting, as the why line counts them
-      p =>
-         `${classOf(p)}|${team.has(p.data.user.login)}|${Math.round(
-            dealScore(p, dealOpts) * (ageWarnDays ?? STARVE_DAYS)
-         )}`,
-      finishes
-   );
-   const queueOther = crRank(nonStarved.filter(p => !isPrimaryRepo(p.data.repo)));
+   ];
+   const queueOther = crRank(crPool.filter(p => !requestedOfMe(p) && !isPrimaryRepo(p.data.repo)));
 
-   // Ready to merge is finishable work for anyone: fully signed off, green,
-   // one button-press from done. It earns a real lane in Pick up next rather
-   // than a fold — and bot PRs that reach ready join it, since a human has to
-   // land them. Longest-waiting first: the ones most likely forgotten.
-   // botsForReady (not `bots`) so this lane keeps showing merge-ready bot
-   // PRs even when "Ignore bot PRs" has emptied `bots` out of the queue
-   // tail and the bot fold below.
+   // Ready to merge: signed off, green, one press from done. Under the
+   // policy the author merges their own, so this is your own ready PRs, plus
+   // another person's only when you were asked to review it or took it on.
+   // Longest-waiting first: the ones most likely forgotten. botsForReady
+   // (not `bots`) so a bot PR you claimed still shows when "Ignore bot PRs"
+   // has emptied `bots`.
    const ready = finishersFirst(
-      [
-         ...others.filter(p => p.status === 'ready'),
-         ...botsForReady.filter(p => p.status === 'ready'),
-      ].sort((a, b) => Number(sunk(a)) - Number(sunk(b)) || b.ageDays - a.ageDays),
+      [...pulls, ...botsForReady]
+         .filter(p => p.status === 'ready' && readyMine(p))
+         .sort((a, b) => Number(sunk(a)) - Number(sunk(b)) || b.ageDays - a.ageDays),
       p => `${sunk(p)}|${days(p)}`,
       finishes
    );
@@ -404,8 +405,7 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
    // the author asked you (by name or through a team): the most concrete
    // "review this" on the board, so it leads, while it's still your move
    const requestedOfYou = others.filter(p => {
-      const action = rowNote(p, me).action;
-      return askedOf(p).includes(me) && (action === 'Review it' || action === 'QA it');
+      return askedOf(p).includes(me) && rowNote(p, me).action === 'Review it';
    });
 
    // PRs you've claimed — the coordination lane so a claim isn't just a hand
@@ -490,10 +490,10 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
          : startHereReason(p, me, false, names);
       return whyProject(p, base) ?? base;
    };
-   // the queue's repo blocks (priority order, starved pierced out front) —
+   // the queue's repo blocks (priority order) —
    // computed unconditionally, cheap; the render only reads it when a
    // priority is set
-   const { starved: queueStarved, blocks: queueBlocks } = repoBlocks(queue, repoPriority);
+   const { blocks: queueBlocks } = repoBlocks(queue, repoPriority);
 
    // Needs QA's own "why" line: that lane isn't ranked by deal-score, it's
    // sorted by qaSort (unclaimed-first, then lightest, then oldest) — reusing
@@ -549,7 +549,6 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
       changed,
       queue,
       queueOther,
-      queueStarved,
       queueBlocks,
       couldUseInput,
       needsQa,
diff --git a/frontend-v2/src/model/stats.test.ts b/frontend-v2/src/model/stats.test.ts
index c4e1cd64..47e8240c 100644
--- a/frontend-v2/src/model/stats.test.ts
+++ b/frontend-v2/src/model/stats.test.ts
@@ -328,6 +328,7 @@ function mergedPull(over: {
    cr?: string[];
    reviewers?: string[];
    teams?: string[];
+   claimedBy?: string;
 }): PullData {
    return {
       repo: 'iFixit/ifixit',
@@ -337,8 +338,8 @@ function mergedPull(over: {
       merged_at: new Date(over.at ?? NOON).toISOString(),
       user: { login: over.author ?? 'alice' },
       requested_teams: over.teams ?? [],
-      requested_reviewers: over.reviewers ?? [],
-      review_requests: [],
+      requested_reviewers: [...(over.reviewers ?? []), ...(over.claimedBy ? [over.claimedBy] : [])],
+      review_requests: over.claimedBy ? [{ login: over.claimedBy, at: 1, self: true }] : [],
       status: { allCR: (over.cr ?? []).map(l => sigAt(l, NOON)), allQA: [] },
    } as unknown as PullData;
 }
@@ -357,6 +358,14 @@ describe('selfReviewMix', () => {
       expect(mix).toMatchObject({ merged: 6, asked: 2, byOthers: 1, self: 2, unstamped: 1 });
    });
 
+   it('a claim is someone volunteering, not the author asking', () => {
+      const mix = selfReviewMix([
+         mergedPull({ n: 1, claimedBy: 'bob', cr: ['bob'] }), // bob volunteered
+         mergedPull({ n: 2, claimedBy: 'bob', reviewers: ['carol'] }), // carol was asked
+      ]);
+      expect(mix).toMatchObject({ asked: 1, byOthers: 1 });
+   });
+
    it('flags reverts and fix-ups of a self-reviewed pull within a week', () => {
       const mix = selfReviewMix([
          mergedPull({ n: 10, cr: ['alice'], at: NOON - 2 * 86_400_000 }), // self-reviewed
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index a63e7e85..3d3028de 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -345,9 +345,11 @@ export function selfReviewMix(closed: PullData[]): SelfReviewMix {
    for (const d of mergedPulls) {
       mix.merged += 1;
       const author = d.user.login;
+      // a claim is a reviewer volunteering, not the author asking
+      const claims = new Set((d.review_requests ?? []).filter(r => r.self).map(r => r.login));
       const asked =
          (d.requested_teams ?? []).length ||
-         (d.requested_reviewers ?? []).length ||
+         (d.requested_reviewers ?? []).some(l => !claims.has(l)) ||
          (d.review_requests ?? []).some(r => !r.self);
       const stampers = [...d.status.allCR, ...d.status.allQA].map(s => s.data.user.login);
       const reviewers = (d.status.unstamped_reviewers ?? []).map(r => r.login);
diff --git a/frontend-v2/src/views/Review.tsx b/frontend-v2/src/views/Review.tsx
index 6d59e53e..777a801c 100644
--- a/frontend-v2/src/views/Review.tsx
+++ b/frontend-v2/src/views/Review.tsx
@@ -139,26 +139,24 @@ export function Review({
    return (
       <>
          {codeRegions.length === 0 && <RegionHint />}
-         {/* Leads the whole lens (owner call): fully finished work — signed
-             off, green, one press from shipped. Your OWN ready PR appears in
-             "Waiting on you" as a Merge-it; this lane is everyone else's,
-             which their authors merge. */}
+         {/* Leads the whole lens (owner call): fully finished work, one press
+             from shipped. Under the self-review policy you merge your own, so
+             this is your ready PRs, plus another person's only when you were
+             asked to review it or said you would. Not repeated in "Waiting
+             on you". */}
          <Lane
             title="Ready to merge"
             sub={
                <SubDoor
                   label="Why Ready to merge leads"
-                  text="signed off and green, each author merges their own"
+                  text="your PRs that are signed off and green: merge them"
                >
                   <p>
                      Everything is done on these: code review and QA are in, CI is green, and they
-                     merge cleanly. Their authors merge them; it’s here so you can see what’s about
-                     to ship.
-                  </p>
-                  <p>
-                     Bot PRs land here too once they’re fully green: they only ship when a human
-                     merges them. Longest-waiting first.
+                     merge cleanly. Merge your own. A PR of someone else’s shows up only if you were
+                     asked to review it or said you would, so you can see it’s about to ship.
                   </p>
+                  <p>Longest-waiting first.</p>
                   {projectRule(
                      'A parked project’s PRs sink to the bottom',
                      'Between two that have waited the same days'
@@ -183,10 +181,11 @@ export function Review({
                      <p>
                         PRs someone asked you to review, first: answer those within hours. Then
                         stamps of yours that a push undid, reviews you said you’d do, feedback that
-                        needs your reply, and your own PRs to stamp, merge, fix, or rebase.
+                        needs your reply, and your own PRs to stamp, fix, or rebase. Your signed-off
+                        PRs to merge lead the tab.
                      </p>
                      <p>
-                        Each group is named for the action you’d take (Review, Re-stamp, Merge…).
+                        Each group is named for the action you’d take (Review, Re-stamp, Rebase…).
                         Review requests run oldest request first; inside every other group, the PR
                         that has been open the longest comes first.
                      </p>
@@ -281,10 +280,8 @@ export function Review({
          {repoPriority.length > 0 ? (
             // the owner's priority-and-cap model: contiguous per-repo blocks in
             // the Settings repo order, each block score-ranked inside and
-            // flood-bounded by the per-repo cap. Starving PRs lead the "Starving"
-            // fold as a highlight, but also stay in their own repo block below —
-            // the fairness backstop can't be hidden behind a repo the viewer
-            // ranked last, or "surface the other repos" becomes a lie.
+            // flood-bounded by the per-repo cap. Requests of you lead each
+            // block's incoming order, so the oldest request is still first.
             <Lane
                title="Review queue"
                sub={
@@ -302,14 +299,10 @@ export function Review({
                         few:
                      </p>
                      <p>
-                        PRs that have waited {opts.ageWarnDays ?? 4}+ days for review outrank the
-                        blocks entirely; they lead the lane whatever repo they’re from.
-                     </p>
-                     <p>
-                        Inside a block: your team’s PRs first, then repos you’ve reviewed before and
-                        small quick wins, lightest first. Bot PRs sink to each block’s bottom. The
-                        per-repo cap folds the rest behind “+N more” so one busy repo can’t take the
-                        whole screen.
+                        Inside a block: reviews asked of you first, oldest request first, then your
+                        team’s PRs, repos you’ve reviewed before and small quick wins, lightest
+                        first. Bot PRs sink to each block’s bottom. The per-repo cap folds the rest
+                        behind “+N more” so one busy repo can’t take the whole screen.
                      </p>
                      {projectRule(
                         'A parked project’s PRs sink below everyone else’s, above the bot PRs',
@@ -317,8 +310,7 @@ export function Review({
                      )}
                      <p>
                         PRs you said you’d review stay in the queue and also appear in Waiting on
-                        you. Starving PRs still show up in their repo block below; the call-out
-                        above is a copy, not a removal.
+                        you.
                      </p>
                   </SubDoor>
                }
@@ -326,18 +318,6 @@ export function Review({
                count={lanes.queue.length}
                opts={queueOpts}
             >
-               <Fold
-                  count={lanes.queueStarved.length}
-                  label="Starving"
-                  tone="do"
-                  gloss={`Waited ${
-                     opts.ageWarnDays ?? 4
-                  }+ days for review; these outrank your repo order.`}
-                  id="review:queue:starving"
-                  defaultOpen
-               >
-                  <FoldRows list={lanes.queueStarved} opts={queueOpts} id="review:queue:starving" />
-               </Fold>
                {lanes.queueBlocks.map(b => (
                   <Fold
                      key={b.repo}
@@ -372,10 +352,10 @@ export function Review({
                         that are yours: asked of you, ones you said you’d do, and PRs from outside
                         the dev team that nobody’s on yet.
                      </p>
-                     <p className="font-medium text-ink">One score ranks every card:</p>
+                     <p className="font-medium text-ink">Then one score ranks the rest:</p>
                      <p>
-                        PRs that have waited {opts.ageWarnDays ?? 4}+ days for review jump to the
-                        top, oldest and biggest first, even from repos you don’t usually review.
+                        Reviews asked of you come first, oldest request first, whatever repo they’re
+                        from: answer those within hours.
                      </p>
                      <p>
                         Your team’s PRs always come first (edit your team on the Team tab), ordered
@@ -410,8 +390,9 @@ export function Review({
                >
                   <p>
                      QA runs in parallel with CR, so a pull can sit here and in the review queue at
-                     once. Like the queue, it holds only QA that’s yours: a self-reviewed PR’s
-                     author tests it.
+                     once. Developers test their own PRs, even when they ask for a review, so this
+                     holds only PRs from outside the dev team and bots that need a tester, plus ones
+                     you said you’d review.
                   </p>
                   <p>
                      Anything QA-incomplete with green CI lands here, unless it’s a draft, blocked,
@@ -432,13 +413,13 @@ export function Review({
          {lanes.couldUseInput.length > 0 && (
             <RestGroup
                title="Could use your input"
-               sub="Nobody asked, but these touch your areas. Add yourself as a reviewer if you jump in."
+               sub="Nobody owes these a review, but they touch your areas. Add yourself as a reviewer if you jump in."
             >
                <Fold
                   count={lanes.couldUseInput.length}
                   showCount={false}
                   label="Self-reviews in your areas"
-                  gloss="Their authors review these themselves. Your code regions first, then repos you’ve reviewed in."
+                  gloss="Their authors review these themselves, or asked a team with nobody on the roster. Your code regions first, then repos you’ve reviewed in."
                   id="review:could-use-input"
                >
                   <FoldRows

From 001ebc7241a3e417373a7af80564c0047a23e479 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 17:46:39 -0700
Subject: [PATCH 09/17] Fix stamp keeping, API use and team times on the server

A review found:

1) "Update branch" on GitHub dropped every stamp until the refresh put
   them back, and sent reviewers a false "Re-stamp owed". The push
   webhook now checks the new head and skips that when it's a base
   merge.
2) The keep-the-stamp rule failed open: with no commit dated after the
   stamp, or a PR past GitHub's 250-commit list, the stamp survived any
   push. Both now drop it. A commit made before the stamp but pushed
   after still slips through; the code says so.
3) The commit list was fetched on every webhook, closed PRs included,
   whenever any old stamp predated the head, and a GitHub error failed
   the whole refresh. It's now open PRs only, newest stamp per person,
   cached per head, and errors fall back to the old behavior.
4) Team review requests now record when they were asked, so a team's
   members get the hours clock.
5) The "alerting" hint fired on any Alert* file, like AlertBanner.tsx;
   it now matches alerting directories and config files only.

The dummy board gets dated team requests and hints on your own PRs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 controllers/githubHooks.js       | 37 +++++++++++----
 frontend-v2/src/backend/dummy.ts | 29 +++++++++---
 lib/base-merge.js                | 20 ++++++---
 lib/git-manager.js               | 51 +++++++++++++++++----
 lib/input-hints.js               |  6 ++-
 models/pull.js                   | 52 ++++++++++++++++++++-
 test/base-merge.test.js          | 14 ++++++
 test/derive-model.test.js        |  8 +++-
 test/git-manager-refresh.test.js | 71 +++++++++++++++++++++++++++--
 test/hooks-synchronize.test.js   | 58 ++++++++++++++++++++++++
 test/input-hints.test.js         | 18 +++++++-
 test/team-requests.test.js       | 77 ++++++++++++++++++++++++++++++++
 12 files changed, 401 insertions(+), 40 deletions(-)
 create mode 100644 test/hooks-synchronize.test.js
 create mode 100644 test/team-requests.test.js

diff --git a/controllers/githubHooks.js b/controllers/githubHooks.js
index 37beca0a..4940fe48 100644
--- a/controllers/githubHooks.js
+++ b/controllers/githubHooks.js
@@ -13,6 +13,7 @@ import getLogin from '../lib/get-user-login.js';
 import utils from '../lib/utils.js';
 import dbManager from '../lib/db-manager.js';
 import git from '../lib/git-manager.js';
+import { isBaseMerge } from '../lib/base-merge.js';
 import { projectSettings } from '../lib/projects.js';
 import { workIssueTouched, workPullTouched } from '../lib/work.js';
 
@@ -92,11 +93,21 @@ const HooksController = {
                // Clear prior CR/QA signoffs immediately for snappy feedback. Emoji
                // CR/QA stay cleared; a carried-over GitHub *approval* is restored by
                // the full refresh below (see Signature.parseReview / git-manager).
-               preUpdate = dbManager.invalidateSignatures(
-                  body.repository.full_name,
-                  body.pull_request.number,
-                  ['QA', 'CR']
-               );
+               // Skip it for a push whose head is a merge of the base ("Update
+               // branch"): stamps survive those, and the refresh below settles
+               // the rest. Any error falls back to invalidating.
+               preUpdate = Promise.resolve(git.getCommit(body.repository.full_name, body.after))
+                  .then(commit => isBaseMerge(commit, body.pull_request.base.ref))
+                  .catch(() => false)
+                  .then(isMerge =>
+                     isMerge
+                        ? undefined
+                        : dbManager.invalidateSignatures(
+                             body.repository.full_name,
+                             body.pull_request.number,
+                             ['QA', 'CR']
+                          )
+                  );
                reconcileAfterUpdate = true;
          }
 
@@ -316,17 +327,25 @@ function handleLabelEvents(body) {
  * Record one `review_requested` / `review_request_removed` webhook's
  * metadata onto the in-memory review_requests cache (models/pull.js) --
  * memory-only, no DB write. `body.requested_reviewer` is absent for a team
- * review request, which isn't a per-reviewer clock (the team's slug rides on
- * the pull payload's requested_teams, saved with the pull), so that's a no-op.
+ * review request (`requested_team` instead); its time goes to the team cache,
+ * and the slug rides on the pull payload's requested_teams, saved with the pull.
  */
 function recordReviewRequestMetadata(body) {
    const reviewer = body.requested_reviewer;
+   const repo = body.repository.full_name;
+   const number = body.pull_request.number;
+
    if (!reviewer) {
+      // a team: only the time is kept; the slug rides on the pull payload
+      const slug = body.requested_team?.slug;
+      if (slug && body.action === 'review_request_removed') {
+         Pull.recordTeamRequestRemoved(repo, number, slug);
+      } else if (slug) {
+         Pull.recordTeamRequested(repo, number, slug, Math.floor(Date.now() / 1000));
+      }
       return Promise.resolve();
    }
 
-   const repo = body.repository.full_name;
-   const number = body.pull_request.number;
    const login = getLogin(reviewer);
 
    if (body.action === 'review_request_removed') {
diff --git a/frontend-v2/src/backend/dummy.ts b/frontend-v2/src/backend/dummy.ts
index 147a8069..4a53b539 100644
--- a/frontend-v2/src/backend/dummy.ts
+++ b/frontend-v2/src/backend/dummy.ts
@@ -288,12 +288,14 @@ const ASSIGNEE_INDEXES = new Set([6, 12]);
 // (one for a team nobody is on the roster of), requests of the viewer with a
 // clock in hours (one past four), developers' own stamped pulls, an author
 // whose own stamp went stale, and input hints from the diff's paths.
-const TEAM_REQUESTS: Record<number, string[]> = {
-   2: ['store-front'],
-   9: ['store-front'],
-   17: ['platform'],
-   20: ['community'],
-   30: ['design'],
+// [team slug, hours since it was requested]; the one at 5 is past the four
+// hours reviewers answer in
+const TEAM_REQUESTS: Record<number, Array<[string, number]>> = {
+   2: [['store-front', 3]],
+   9: [['store-front', 5]],
+   17: [['platform', 2]],
+   20: [['community', 4.5]],
+   30: [['design', 1]],
 };
 const OWN_STAMPED = new Set([3, 8, 21]);
 const OWN_STALE_STAMP = 24;
@@ -302,6 +304,10 @@ const INPUT_HINTS: Record<number, string[]> = {
    18: ['ci', 'agent-docs'],
    26: ['deploy', 'dependencies'],
    33: ['alerting'],
+   // the viewer's own open, unrequested pulls (the chain), so the author-side
+   // "worth asking for review?" hint shows on the board
+   10: ['migrations'],
+   12: ['ci', 'dependencies'],
 };
 
 function withSelfReviewDemos(pull: PullData, i: number): PullData {
@@ -321,7 +327,11 @@ function withSelfReviewDemos(pull: PullData, i: number): PullData {
    const meAsked = (pull.requested_reviewers ?? []).includes(dummyUser());
    let out: PullData = {
       ...pull,
-      requested_teams: TEAM_REQUESTS[i] ?? [],
+      requested_teams: (TEAM_REQUESTS[i] ?? []).map(([slug]) => slug),
+      team_requests: (TEAM_REQUESTS[i] ?? []).map(([slug, hoursAgo]) => ({
+         slug,
+         at: Math.floor(now / 1000 - hoursAgo * 3600),
+      })),
       input_hints: INPUT_HINTS[i] ?? [],
       // asked hours ago; the one at 7 is past the four hours reviewers answer in
       review_requests: meAsked
@@ -334,11 +344,16 @@ function withSelfReviewDemos(pull: PullData, i: number): PullData {
            ]
          : pull.review_requests,
    };
+   if (INPUT_HINTS[i] && (CHAIN_INDEXES as readonly number[]).includes(i)) {
+      // unrequested, so the hint is the only nudge to ask anyone
+      out = { ...out, requested_reviewers: [], requested_teams: [], team_requests: [] };
+   }
    if (OWN_STAMPED.has(i) || i === OWN_STALE_STAMP) {
       out = {
          ...out,
          requested_reviewers: [],
          requested_teams: [],
+         team_requests: [],
          review_requests: [],
          status: {
             ...out.status,
diff --git a/lib/base-merge.js b/lib/base-merge.js
index 661401ae..d9a53ecc 100644
--- a/lib/base-merge.js
+++ b/lib/base-merge.js
@@ -16,18 +16,26 @@ export function isBaseMerge(commit, baseRef) {
    ).test(subject);
 }
 
+// pulls.listCommits stops at 250; past that the newest commits are unseen
+const LIST_COMMITS_CAP = 250;
+
 /**
  * Whether a CR/QA stamp left at `stampAt` survives the commits since: true
- * when every commit made after it is a merge of the base into the PR, the way
- * GitHub keeps an approval across one. `commits` is pulls.listCommits output.
+ * when at least one commit came after it and every one is a merge of the base
+ * into the PR, the way GitHub keeps an approval across one. `commits` is
+ * pulls.listCommits output. Nothing dated after the stamp means the push can't
+ * be seen, so the stamp doesn't survive.
  *
  * ponytail: the message can't tell a clean merge from one that resolved
  * conflicts, so a conflict-resolving merge keeps the stamp too. Upgrade path:
  * compare the merge commit's tree with a fresh merge of its parents, or the
- * PR's file patches before and after.
+ * PR's file patches before and after. Same ceiling: committer dates can't
+ * order pushes, so a commit made before the stamp but pushed after it slips
+ * through. The real fix is recording the head sha when a stamp lands and
+ * walking from that sha.
  */
 export function stampSurvivesBaseMerges(stampAt, commits, baseRef) {
-   return commits
-      .filter(c => new Date(c.commit.committer.date) > stampAt)
-      .every(c => isBaseMerge(c, baseRef));
+   if (commits.length >= LIST_COMMITS_CAP) return false;
+   const after = commits.filter(c => new Date(c.commit.committer.date) > stampAt);
+   return after.length > 0 && after.every(c => isBaseMerge(c, baseRef));
 }
diff --git a/lib/git-manager.js b/lib/git-manager.js
index 366c8d2a..fd7a8935 100644
--- a/lib/git-manager.js
+++ b/lib/git-manager.js
@@ -146,6 +146,8 @@ export default {
 
    getBotLogin,
 
+   getCommit,
+
    // on the object too, so tests can stand in for GitHub (lib/work.js)
    graphql,
 
@@ -449,10 +451,25 @@ export default {
             new Date(signature.data.created_at) < headCommitDate;
          // A stamp also stays when every commit since is a merge of the base
          // branch into the PR (GitHub keeps approvals across one). The commit
-         // list costs a call, so only ask when a stamp actually predates the head.
-         var commits = signatures.some(predatesHead)
-            ? await getPullCommits(repo, githubPull.number)
-            : [];
+         // list costs a call, so only ask for an open pull whose newest stamp
+         // (per person and kind) predates the head. A failed fetch reads as no
+         // commits: the stamps are dropped, as before this check existed.
+         var newestStamps = new Map();
+         signatures.forEach(function (signature) {
+            var k = signature.data.type + ':' + signature.data.user.login;
+            var best = newestStamps.get(k);
+            if (!best || signature.data.created_at > best.data.created_at) {
+               newestStamps.set(k, signature);
+            }
+         });
+         var commits = [];
+         if (githubPull.state === 'open' && [...newestStamps.values()].some(predatesHead)) {
+            try {
+               commits = await getPullCommitsMemo(repo, githubPull.number, githubPull.head.sha);
+            } catch (err) {
+               console.error('Listing commits failed for %s#%s: %s', repo, githubPull.number, err);
+            }
+         }
          signatures.forEach(function (signature) {
             if (
                predatesHead(signature) &&
@@ -467,14 +484,20 @@ export default {
          });
 
          // Which areas the diff touches, refetched only when the head moved
-         // since the stored hints were computed
+         // since the stored hints were computed. A failed fetch leaves the
+         // stored hints as they were.
          if (githubPull.state === 'open') {
             var hints = recalledHints(repo, githubPull.number, githubPull.head.sha);
             if (!hints) {
-               hints = inputHints(await getPullFilePaths(repo, githubPull.number));
-               rememberHints(repo, githubPull.number, githubPull.head.sha, hints);
+               try {
+                  hints = inputHints(await getPullFilePaths(repo, githubPull.number));
+                  rememberHints(repo, githubPull.number, githubPull.head.sha, hints);
+               } catch (err) {
+                  console.error('Listing files failed for %s#%s: %s', repo, githubPull.number, err);
+                  hints = undefined;
+               }
             }
-            githubPull.input_hints = hints;
+            if (hints) githubPull.input_hints = hints;
          }
 
          // Array of Comment objects.
@@ -924,6 +947,18 @@ function getPullReviewComments(repo, number) {
    );
 }
 
+// repo#number@sha -> commit list, so repeat webhooks on one head don't refetch
+const COMMITS_MEMO_MAX = 2000;
+const commitsMemo = new Map();
+async function getPullCommitsMemo(repo, number, sha) {
+   const key = `${repo}#${number}@${sha}`;
+   if (commitsMemo.has(key)) return commitsMemo.get(key);
+   const commits = await getPullCommits(repo, number);
+   commitsMemo.set(key, commits);
+   if (commitsMemo.size > COMMITS_MEMO_MAX) commitsMemo.delete(commitsMemo.keys().next().value);
+   return commits;
+}
+
 // oldest first, with parents and committer dates; GitHub lists at most 250
 function getPullCommits(repo, number) {
    return logErrors(
diff --git a/lib/input-hints.js b/lib/input-hints.js
index de45b9b2..d1d0fe6a 100644
--- a/lib/input-hints.js
+++ b/lib/input-hints.js
@@ -4,7 +4,11 @@ const HINTS = [
       /(^|\/)(\.github|\.circleci|\.buildkite)\/|(^|\/)Jenkinsfile[^/]*$|(^|\/)lefthook[^/]*\.ya?ml$/,
    ],
    ['migrations', /(^|\/)migrations\/|(^|\/)schema\.sql$|\.sql$/i],
-   ['alerting', /(^|[/._-])(alert\w*|prometheus|grafana|datadog|pagerduty|sentry)([/._-]|$)/i],
+   [
+      'alerting',
+      // a whole path segment or file stem, so components/AlertBanner.tsx doesn't count
+      /(^|\/)(alerts?|alerting|alertmanager|prometheus|grafana|datadog|pagerduty)(\.[^/]*)?(\/|$)|(^|\/)(sentry\.[^/]*\.config\.[^/]*|\.sentryclirc|sentry\.properties)$/i,
+   ],
    ['agent-docs', /(^|\/)(AGENTS|CLAUDE)\.md$|(^|\/)\.(agents|claude|cursor|codex)\//],
    [
       'deploy',
diff --git a/models/pull.js b/models/pull.js
index 13eea6e2..6f9592d4 100644
--- a/models/pull.js
+++ b/models/pull.js
@@ -42,6 +42,15 @@ function reviewRequestsKey(repo, number) {
    return `${repo}#${number}`;
 }
 
+// "repo#number" -> Map of team slug -> epoch secs it was requested. The pull
+// payload lists teams without times, so a refresh keeps what a webhook or the
+// stored column told us (Pull.fromGithubApi reads this; getFromDB seeds it).
+const teamRequestTimes = new Map();
+
+// the stored column holds {slug, at} (old rows: plain slugs)
+const normalizeTeams = teams =>
+   (teams || []).map(t => (typeof t === 'string' ? { slug: t, at: null } : t));
+
 function getReviewRequests(repo, number, requestedReviewerLogins) {
    const known = reviewRequestsByPull.get(reviewRequestsKey(repo, number));
    return (requestedReviewerLogins || []).map(login => {
@@ -50,6 +59,25 @@ function getReviewRequests(repo, number, requestedReviewerLogins) {
    });
 }
 
+// A payload's teams with the times we know; the cache then holds exactly the
+// teams still requested.
+function teamRequests(repo, number, payloadTeams) {
+   const key = reviewRequestsKey(repo, number);
+   const known = teamRequestTimes.get(key);
+   const teams = (payloadTeams || []).map(t => ({ slug: t.slug, at: known?.get(t.slug) ?? null }));
+   teamRequestTimes.set(key, new Map(teams.filter(t => t.at !== null).map(t => [t.slug, t.at])));
+   return teams;
+}
+
+function seedTeamRequests(repo, number, stored) {
+   const teams = normalizeTeams(stored);
+   teamRequestTimes.set(
+      reviewRequestsKey(repo, number),
+      new Map(teams.filter(t => t.at != null).map(t => [t.slug, t.at]))
+   );
+   return teams;
+}
+
 class Pull {
    constructor(data, signatures, comments, reviews, commitStatuses, labels) {
       this.data = data;
@@ -157,6 +185,8 @@ class Pull {
       data.status = this.getStatus();
       data.labels = this.labels.map(label => label.data);
       delete data.input_hints_sha;
+      data.team_requests = normalizeTeams(data.requested_teams);
+      data.requested_teams = data.team_requests.map(t => t.slug);
       data.review_requests = getReviewRequests(data.repo, data.number, data.requested_reviewers);
       return data;
    }
@@ -320,7 +350,7 @@ class Pull {
          },
          assignees: (data.assignees || []).map(a => getLogin(a)),
          requested_reviewers: (data.requested_reviewers || []).map(r => getLogin(r)),
-         requested_teams: (data.requested_teams || []).map(t => t.slug),
+         requested_teams: teamRequests(data.base.repo.full_name, data.number, data.requested_teams),
          // parse() fills input_hints on a full refresh; a webhook's body
          // can't, so reuse what was computed for this same head
          input_hints:
@@ -371,6 +401,19 @@ class Pull {
       }
    }
 
+   /** A `review_requested` webhook for a team: remember when, for the
+    * fromGithubApi call that follows with the payload's team list. */
+   static recordTeamRequested(repo, number, slug, at) {
+      const key = reviewRequestsKey(repo, number);
+      const known = teamRequestTimes.get(key) || new Map();
+      known.set(slug, at);
+      teamRequestTimes.set(key, known);
+   }
+
+   static recordTeamRequestRemoved(repo, number, slug) {
+      teamRequestTimes.get(reviewRequestsKey(repo, number))?.delete(slug);
+   }
+
    /**
     * The `"repo#number"` key reviewRequestsByPull is keyed by, exposed so a
     * caller (pull-manager.js's cull, below) can compute the same keys for its
@@ -395,6 +438,11 @@ class Pull {
             reviewRequestsByPull.delete(key);
          }
       }
+      for (const key of teamRequestTimes.keys()) {
+         if (!liveKeys.has(key)) {
+            teamRequestTimes.delete(key);
+         }
+      }
    }
 
    /**
@@ -453,7 +501,7 @@ class Pull {
          // mysql2 auto-parses the JSON column, so this is already an array (or null).
          assignees: data.assignees ?? [],
          requested_reviewers: data.requested_reviewers ?? [],
-         requested_teams: data.requested_teams ?? [],
+         requested_teams: seedTeamRequests(data.repo, data.number, data.requested_teams),
          input_hints: data.input_hints?.hints ?? [],
          input_hints_sha: data.input_hints?.sha,
          cr_req: data.cr_req,
diff --git a/test/base-merge.test.js b/test/base-merge.test.js
index b5732eb2..ca9e733b 100644
--- a/test/base-merge.test.js
+++ b/test/base-merge.test.js
@@ -33,3 +33,17 @@ test('a stamp survives only when every later commit is a base merge', () => {
    assert.ok(stampSurvivesBaseMerges(stamp, [before, merge, merge], 'master'));
    assert.ok(!stampSurvivesBaseMerges(stamp, [before, merge, commit('More', ['c'])], 'master'));
 });
+
+test('a stamp with no commit dated after it does not survive', () => {
+   const stamp = new Date('2026-10-01T00:00:00Z');
+   const before = commit('Work', ['a'], '2026-09-30T00:00:00Z');
+   assert.ok(!stampSurvivesBaseMerges(stamp, [before], 'master'));
+   assert.ok(!stampSurvivesBaseMerges(stamp, [], 'master'));
+});
+
+test('a capped commit list does not keep a stamp', () => {
+   const stamp = new Date('2026-10-01T00:00:00Z');
+   const merge = commit("Merge branch 'master' into foo", ['a', 'b']);
+   assert.ok(stampSurvivesBaseMerges(stamp, Array(249).fill(merge), 'master'));
+   assert.ok(!stampSurvivesBaseMerges(stamp, Array(250).fill(merge), 'master'));
+});
diff --git a/test/derive-model.test.js b/test/derive-model.test.js
index 3e839bfb..2bd629cb 100644
--- a/test/derive-model.test.js
+++ b/test/derive-model.test.js
@@ -96,8 +96,12 @@ test('ci_red: sign-offs met but a required check failed', () => {
    assert.deepEqual(d.ciFailing, ['build']);
 });
 
-test('needs_recr: only a stale CR stamp remains', () => {
-   const d = derivePull(pullOf({ cr_req: 1, qa_req: 0 }, [crSig('bob', 0)]), NOW);
+test('needs_recr: only a stale CR stamp remains, from someone who was asked', () => {
+   // under self-review only someone asked (or the author) owes a re-stamp
+   const d = derivePull(
+      pullOf({ cr_req: 1, qa_req: 0, requested_reviewers: ['bob'] }, [crSig('bob', 0)]),
+      NOW
+   );
    assert.equal(d.status, 'needs_recr');
    assert.deepEqual(d.recrBy, ['bob']);
 });
diff --git a/test/git-manager-refresh.test.js b/test/git-manager-refresh.test.js
index e79fb91d..105a9110 100644
--- a/test/git-manager-refresh.test.js
+++ b/test/git-manager-refresh.test.js
@@ -300,13 +300,14 @@ const gitCommit = (message, parents, date) => ({
 test("parse keeps a stamp across a base merge and drops it after real work", async (t) => {
   const merge = gitCommit("Merge branch 'master' into f", ["a", "b"], "2026-09-20T10:00:00Z");
   const work = gitCommit("Fix", ["a"], "2026-09-20T09:30:00Z");
-  fakeGithub(t, stampRoutes([merge]));
-  let pull = await gitManager.parse(githubPull());
+  // distinct heads: a head's commit list is remembered
+  fakeGithub(t, headRoutes("keep1", [merge]));
+  let pull = await gitManager.parse(headed("keep1"));
   assert.equal(pull.signatures[0].data.active, true);
 
   t.mock.restoreAll();
-  fakeGithub(t, stampRoutes([merge, work]));
-  pull = await gitManager.parse(githubPull());
+  fakeGithub(t, headRoutes("drop1", [merge, work]));
+  pull = await gitManager.parse(headed("drop1"));
   assert.equal(pull.signatures[0].data.active, false);
 });
 
@@ -334,3 +335,65 @@ test("parse saves the slugs of requested teams", async (t) => {
   });
   assert.deepEqual(pull.toObject().requested_teams, ["store-front"]);
 });
+
+// Distinct heads so the commit-list memo from other tests can't answer.
+const headed = (sha, extra = {}) => ({
+  ...githubPull(),
+  head: { ...githubPull().head, sha },
+  ...extra,
+});
+function headRoutes(sha, commits, files = []) {
+  const routes = stampRoutes(commits, files);
+  routes.unshift([
+    new RegExp(`/commits/${sha}$`),
+    () => ({ body: { commit: { committer: { date: "2026-09-20T10:00:00Z" } } } }),
+  ]);
+  routes.push(
+    [new RegExp(`/commits/${sha}/status$`), () => ({ body: { statuses: [] } })],
+    [new RegExp(`/commits/${sha}/check-runs$`), () => ({ body: { total_count: 0, check_runs: [] } })]
+  );
+  return routes;
+}
+
+test("parse skips the commit list for a closed pull", async (t) => {
+  const calls = fakeGithub(t, headRoutes("closed1", []));
+  await gitManager.parse(headed("closed1", { state: "closed" }));
+  assert.ok(!calls.some((c) => c.endsWith("/pulls/3/commits")));
+});
+
+test("parse lists a head's commits once across refreshes", async (t) => {
+  const merge = gitCommit("Merge branch 'master' into f", ["a", "b"], "2026-09-20T10:00:00Z");
+  const calls = fakeGithub(t, headRoutes("memo1", [merge]));
+  await gitManager.parse(headed("memo1"));
+  await gitManager.parse(headed("memo1"));
+  assert.equal(calls.filter((c) => c.endsWith("/pulls/3/commits")).length, 1);
+});
+
+test("parse ignores a stamp superseded by a newer one when deciding to list commits", async (t) => {
+  const routes = headRoutes("newest1", []);
+  routes.unshift([
+    /\/issues\/3\/comments$/,
+    () => ({
+      body: [
+        { id: 1, body: "CR :+1:", user: { login: "rev" }, created_at: "2026-09-20T09:00:00Z" },
+        { id: 2, body: "CR :+1:", user: { login: "rev" }, created_at: "2026-09-20T11:00:00Z" },
+      ],
+    }),
+  ]);
+  const calls = fakeGithub(t, routes);
+  await gitManager.parse(headed("newest1"));
+  assert.ok(!calls.some((c) => c.endsWith("/pulls/3/commits")));
+});
+
+test("parse survives a failing commit list and file list", async (t) => {
+  const routes = headRoutes("fail1", []);
+  routes.unshift(
+    [/\/pulls\/3\/commits$/, () => ({ status: 422, body: { message: "boom" } })],
+    [/\/pulls\/3\/files$/, () => ({ status: 422, body: { message: "boom" } })]
+  );
+  fakeGithub(t, routes);
+  t.mock.method(console, "error", () => {});
+  const pull = await gitManager.parse(headed("fail1"));
+  assert.equal(pull.signatures[0].data.active, false);
+  assert.equal(pull.toObject().input_hints, undefined);
+});
diff --git a/test/hooks-synchronize.test.js b/test/hooks-synchronize.test.js
new file mode 100644
index 00000000..1e19c8eb
--- /dev/null
+++ b/test/hooks-synchronize.test.js
@@ -0,0 +1,58 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import HooksController from '../controllers/githubHooks.js';
+import dbManager from '../lib/db-manager.js';
+import git from '../lib/git-manager.js';
+import refresh from '../lib/refresh.js';
+
+const merge = {
+   parents: [{ sha: 'a' }, { sha: 'b' }],
+   commit: { message: "Merge branch 'master' into f" },
+};
+
+async function push(t, getCommit) {
+   const invalidated = [];
+   t.mock.method(git, 'getCommit', getCommit);
+   t.mock.method(dbManager, 'invalidateSignatures', async (...args) => invalidated.push(args));
+   t.mock.method(dbManager, 'updatePull', async () => {});
+   t.mock.method(refresh, 'pull', async () => {});
+   const body = {
+      action: 'synchronize',
+      after: 'newhead',
+      repository: { full_name: 'o/r' },
+      pull_request: {
+         number: 3,
+         base: { ref: 'master', repo: { full_name: 'o/r' } },
+         head: { ref: 'f', sha: 'newhead', repo: { owner: { login: 'o' } } },
+         user: { login: 'u' },
+         labels: [],
+      },
+   };
+   const req = {
+      query: { secret: 'test-hook-secret' },
+      headers: { 'content-type': 'application/json' },
+      body,
+      get: () => 'pull_request',
+   };
+   await new Promise(resolve => {
+      const res = { status: () => res, send: resolve, sendStatus: resolve, end: resolve };
+      HooksController.main(req, res);
+   });
+   return invalidated;
+}
+
+test('a push whose head merges the base keeps the stamps for now', async t => {
+   assert.equal((await push(t, async () => merge)).length, 0);
+});
+
+test('a plain push invalidates the stamps', async t => {
+   const plain = { parents: [{ sha: 'a' }], commit: { message: 'Fix' } };
+   assert.deepEqual(await push(t, async () => plain), [['o/r', 3, ['QA', 'CR']]]);
+});
+
+test('a failed commit lookup invalidates the stamps', async t => {
+   const invalidated = await push(t, async () => {
+      throw new Error('503');
+   });
+   assert.equal(invalidated.length, 1);
+});
diff --git a/test/input-hints.test.js b/test/input-hints.test.js
index 28280767..a34b5458 100644
--- a/test/input-hints.test.js
+++ b/test/input-hints.test.js
@@ -19,7 +19,16 @@ test('each area matches its paths', () => {
    const cases = {
       ci: ['.circleci/config.yml', 'Jenkinsfile', 'lefthook-local.yml', '.buildkite/p.yml'],
       migrations: ['db/migrations/1.php', 'migrations/schema.sql', 'x/y.sql'],
-      alerting: ['ops/alerts/db.yml', 'grafana/dash.json', 'lib/sentry.js', 'Prometheus.yml'],
+      alerting: [
+         'ops/alerts/db.yml',
+         'grafana/dash.json',
+         'Prometheus.yml',
+         'prometheus.yml',
+         'ops/alertmanager/a.yml',
+         'sentry.client.config.ts',
+         '.sentryclirc',
+         'sentry.properties',
+      ],
       'agent-docs': ['AGENTS.md', 'a/b/CLAUDE.md', '.agents/x.md', '.cursor/r', '.codex/c'],
       deploy: [
          'Dockerfile',
@@ -45,6 +54,13 @@ test('each area matches its paths', () => {
    }
 });
 
+test('alert-named components are not alerting config', () => {
+   assert.deepEqual(
+      inputHints(['src/components/AlertBanner.tsx', 'AlertDialog.tsx', 'lib/sentry.js']),
+      []
+   );
+});
+
 test('ordinary files get no hint', () => {
    assert.deepEqual(inputHints(['src/app.js', 'README.md', 'docs/package-notes.md']), []);
 });
diff --git a/test/team-requests.test.js b/test/team-requests.test.js
new file mode 100644
index 00000000..075b68f4
--- /dev/null
+++ b/test/team-requests.test.js
@@ -0,0 +1,77 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import Pull from '../models/pull.js';
+import DBPull from '../models/db_pull.js';
+
+const payload = (number, teams) => ({
+   number,
+   state: 'open',
+   title: 't',
+   body: '',
+   created_at: '2026-09-19T00:00:00Z',
+   updated_at: '2026-09-20T10:01:00Z',
+   user: { login: 'author' },
+   head: { ref: 'f', sha: 'abc', repo: { name: 'r', owner: { login: 'o' } } },
+   base: { ref: 'master', repo: { full_name: 'o/r' } },
+   requested_reviewers: [],
+   requested_teams: teams.map(slug => ({ slug })),
+});
+const wire = pull => {
+   const o = pull.toObject();
+   return [o.requested_teams, o.team_requests];
+};
+
+test('a team request webhook gives the team a time, a removal drops it', () => {
+   Pull.recordTeamRequested('o/r', 20, 'platform', 1000);
+   assert.deepEqual(wire(Pull.fromGithubApi(payload(20, ['platform']))), [
+      ['platform'],
+      [{ slug: 'platform', at: 1000 }],
+   ]);
+   Pull.recordTeamRequestRemoved('o/r', 20, 'platform');
+   assert.deepEqual(wire(Pull.fromGithubApi(payload(20, []))), [[], []]);
+   // asked again with no webhook seen: no time
+   assert.deepEqual(wire(Pull.fromGithubApi(payload(20, ['platform'])))[1], [
+      { slug: 'platform', at: null },
+   ]);
+});
+
+test('a refresh keeps known times and adds new teams without one', () => {
+   Pull.recordTeamRequested('o/r', 21, 'platform', 1000);
+   Pull.fromGithubApi(payload(21, ['platform']));
+   const [slugs, requests] = wire(Pull.fromGithubApi(payload(21, ['platform', 'design'])));
+   assert.deepEqual(slugs, ['platform', 'design']);
+   assert.deepEqual(requests, [
+      { slug: 'platform', at: 1000 },
+      { slug: 'design', at: null },
+   ]);
+});
+
+test('the times survive the database round trip; old string rows read as no time', () => {
+   Pull.recordTeamRequested('o/r', 22, 'design', 5000);
+   const pull = Pull.fromGithubApi(payload(22, ['design']));
+   const stored = JSON.parse(new DBPull(pull).data.requested_teams);
+   assert.deepEqual(stored, [{ slug: 'design', at: 5000 }]);
+
+   const row = n => ({
+      repo: 'o/r',
+      number: n,
+      state: 'open',
+      title: 't',
+      body: '',
+      draft: 0,
+      date: 1753200000,
+      date_updated: 1753300000,
+      head_branch: 'f',
+      head_sha: 'abc',
+      base_branch: 'master',
+      owner: 'author',
+      assignees: [],
+      requested_reviewers: [],
+      cr_req: 2,
+      qa_req: 1,
+   });
+   const back = Pull.getFromDB({ ...row(22), requested_teams: stored }, [], [], [], [], []);
+   assert.deepEqual(wire(back), [['design'], [{ slug: 'design', at: 5000 }]]);
+   const old = Pull.getFromDB({ ...row(23), requested_teams: ['design'] }, [], [], [], [], []);
+   assert.deepEqual(wire(old), [['design'], [{ slug: 'design', at: null }]]);
+});

From 3e16ec7c5bff0ecd6a61c4fc35adb4048ff805e7 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 18:30:24 -0700
Subject: [PATCH 10/17] Fix what the review of the self-review branch found

1) A push of real work followed by a merge of master kept its stamps
   until the refresh ran, and for good if the refresh failed. The push
   webhook now keeps stamps only when the push is that single merge,
   and gives up on GitHub after 3 seconds.
2) Changing the developer roster on the Projects tab didn't reach open
   boards, so they and the API disagreed on who self-reviews until a
   reconnect. Saving the roster now tells every board.
3) Stats counted the CI review bot as "reviewed by someone else", and
   listed requests on drafts and PRs already signed off.
4) The commit-list cache kept whole GitHub responses; it keeps only
   what the stamp rule reads.
5) Roadmap status used the default policy instead of the board's.
6) The "waiting for review" toast said "worth a nudge?" when nobody
   had been asked; it suggests asking now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 controllers/githubHooks.js           | 30 +++++++++++++++++++++++-----
 controllers/settings.js              |  6 +++++-
 frontend-v2/src/app.tsx              |  2 +-
 frontend-v2/src/backend/socket.ts    | 14 +++++++++++++
 frontend-v2/src/model/cheers.test.ts | 14 +++++++++++++
 frontend-v2/src/model/cheers.ts      |  2 +-
 frontend-v2/src/model/roadmapData.ts | 14 +++++++------
 frontend-v2/src/model/stats.test.ts  | 21 +++++++++++++++++++
 frontend-v2/src/model/stats.ts       | 26 ++++++++++++++++++------
 frontend-v2/src/store.test.ts        | 18 ++++++++++++++++-
 frontend-v2/src/store.ts             | 10 ++++++++++
 frontend-v2/src/views/Stats.tsx      |  5 ++++-
 lib/git-manager.js                   | 10 +++++++++-
 lib/pull-manager.js                  |  8 ++++++++
 test/hooks-synchronize.test.js       | 18 ++++++++++++++++-
 test/settings.test.js                | 12 +++++++++++
 16 files changed, 186 insertions(+), 24 deletions(-)

diff --git a/controllers/githubHooks.js b/controllers/githubHooks.js
index 4940fe48..b0f291cf 100644
--- a/controllers/githubHooks.js
+++ b/controllers/githubHooks.js
@@ -14,6 +14,16 @@ import utils from '../lib/utils.js';
 import dbManager from '../lib/db-manager.js';
 import git from '../lib/git-manager.js';
 import { isBaseMerge } from '../lib/base-merge.js';
+
+// how long a push waits on GitHub to say what its head commit is
+const COMMIT_LOOKUP_MS = 3000;
+function withTimeout(promise, ms) {
+   let timer;
+   const late = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error('timed out')), ms);
+   });
+   return Promise.race([promise, late]).finally(() => clearTimeout(timer));
+}
 import { projectSettings } from '../lib/projects.js';
 import { workIssueTouched, workPullTouched } from '../lib/work.js';
 
@@ -93,11 +103,21 @@ const HooksController = {
                // Clear prior CR/QA signoffs immediately for snappy feedback. Emoji
                // CR/QA stay cleared; a carried-over GitHub *approval* is restored by
                // the full refresh below (see Signature.parseReview / git-manager).
-               // Skip it for a push whose head is a merge of the base ("Update
-               // branch"): stamps survive those, and the refresh below settles
-               // the rest. Any error falls back to invalidating.
-               preUpdate = Promise.resolve(git.getCommit(body.repository.full_name, body.after))
-                  .then(commit => isBaseMerge(commit, body.pull_request.base.ref))
+               // Skip it only for a push that is nothing but a merge of the base
+               // ("Update branch"): stamps survive those, and the refresh below
+               // settles the rest. A merge on top of other new commits (its first
+               // parent isn't the old head) carries real code, so it invalidates.
+               // The lookup is capped so a slow GitHub can't hold the reply; any
+               // error or timeout falls back to invalidating.
+               preUpdate = withTimeout(
+                  Promise.resolve(git.getCommit(body.repository.full_name, body.after)),
+                  COMMIT_LOOKUP_MS
+               )
+                  .then(
+                     commit =>
+                        commit.parents[0]?.sha === body.before &&
+                        isBaseMerge(commit, body.pull_request.base.ref)
+                  )
                   .catch(() => false)
                   .then(isMerge =>
                      isMerge
diff --git a/controllers/settings.js b/controllers/settings.js
index 411f6598..5c82069e 100644
--- a/controllers/settings.js
+++ b/controllers/settings.js
@@ -1,4 +1,5 @@
 import { projectSettings } from '../lib/projects.js';
+import pullManager from '../lib/pull-manager.js';
 import { saveSetting } from '../lib/settings.js';
 import {
    checkDecideRotation,
@@ -91,7 +92,10 @@ export default {
       if (has(body, 'developer_teams')) {
          const checked = checkDeveloperTeams(body.developer_teams);
          if (checked.error) return res.status(400).json({ error: checked.error });
-         saves.push(() => saveSetting('developer_teams', checked.teams, req.roadmapLogin));
+         saves.push(async () => {
+            await saveSetting('developer_teams', checked.teams, req.roadmapLogin);
+            pullManager.developerTeamsChanged();
+         });
       }
       if (has(body, 'ongoing_projects')) {
          const checked = checkOngoingProjects(body.ongoing_projects);
diff --git a/frontend-v2/src/app.tsx b/frontend-v2/src/app.tsx
index 338a9eaa..37e4fd0c 100644
--- a/frontend-v2/src/app.tsx
+++ b/frontend-v2/src/app.tsx
@@ -1415,7 +1415,7 @@ export function App() {
                </Suspense>
             )}
             {initialized && !searching && lens === 'stats' && (
-               <Stats pulls={humans} closed={closed} me={me} onPerson={onPerson} />
+               <Stats pulls={humans} closed={closed} bots={extraBots} me={me} onPerson={onPerson} />
             )}
          </main>
       </>
diff --git a/frontend-v2/src/backend/socket.ts b/frontend-v2/src/backend/socket.ts
index 11d5b839..ddca799e 100644
--- a/frontend-v2/src/backend/socket.ts
+++ b/frontend-v2/src/backend/socket.ts
@@ -45,6 +45,9 @@ export interface Backend {
     * server (a roadmap write, an issue added, a setting, a sync), so open
     * boards fetch it again; returns the unsubscribe. */
    onProjectsChanged: (handler: () => void) => () => void;
+   /** Calls `handler` with the new developer roster when someone saves it,
+    * so open boards re-derive who owes a review; returns the unsubscribe. */
+   onDeveloperTeams: (handler: (teams: Record<string, string[]> | undefined) => void) => () => void;
 }
 
 function liveBackend(): Backend {
@@ -175,6 +178,15 @@ function liveBackend(): Backend {
             s.off('projectsChanged', handler);
          };
       },
+      onDeveloperTeams(handler) {
+         const s = getSocket();
+         const heard = (data: { developerTeams?: Record<string, string[]> }) =>
+            handler(data.developerTeams);
+         s.on('developerTeamsChanged', heard);
+         return () => {
+            s.off('developerTeamsChanged', heard);
+         };
+      },
       onConnection(handler) {
          onState = handler;
          const s = getSocket();
@@ -245,6 +257,8 @@ function dummyBackend(): Backend {
          window.addEventListener('pd:projectsChanged', handler);
          return () => window.removeEventListener('pd:projectsChanged', handler);
       },
+      // the dummy roster never changes
+      onDeveloperTeams: () => () => undefined,
       whoami: () => Promise.resolve(dummyUser()),
       onPulls(handler) {
          emit = handler;
diff --git a/frontend-v2/src/model/cheers.test.ts b/frontend-v2/src/model/cheers.test.ts
index bdbe1c2c..0a03e92e 100644
--- a/frontend-v2/src/model/cheers.test.ts
+++ b/frontend-v2/src/model/cheers.test.ts
@@ -556,6 +556,20 @@ describe('diffCheers — author-side toasts', () => {
       );
    });
 
+   it('pr-starving does not say nudge when nobody was asked', () => {
+      const key = 'org/a#6';
+      const p = pull('org/a', 6, { author: 'me', starved: true, ageDays: 5 });
+      const base = primed(sig({ authorPrs: new Map([[key, prState()]]) }));
+      const { toasts } = diffCheers(
+         sig({ authorPrs: new Map([[key, prState({ starved: true })]]), pulls: [p] }),
+         'me',
+         base
+      );
+      const t = toasts.find(x => x.dedupeKey === `starve:${key}`);
+      expect(t?.body).toMatch(/asking for a review/);
+      expect(t?.body).not.toMatch(/nudge/);
+   });
+
    it('does not fire for a brand-new PR that appears already green', () => {
       const key = 'org/a#5';
       const p = pull('org/a', 5, { author: 'me', status: 'ready' });
diff --git a/frontend-v2/src/model/cheers.ts b/frontend-v2/src/model/cheers.ts
index 858f48f4..83a09f84 100644
--- a/frontend-v2/src/model/cheers.ts
+++ b/frontend-v2/src/model/cheers.ts
@@ -1135,7 +1135,7 @@ export function diffCheers(
                title: `Waiting ${p.ageDays}d for review`,
                body: askedOf(p).length
                   ? `Asked of ${askedOf(p).join(', ')}, worth a nudge?`
-                  : 'Your PR, worth a nudge?',
+                  : 'Nobody asked yet, worth asking for a review?',
                pull: pullRef(p),
                dedupeKey: `starve:${key}`,
             },
diff --git a/frontend-v2/src/model/roadmapData.ts b/frontend-v2/src/model/roadmapData.ts
index c9a04476..2352aaf6 100644
--- a/frontend-v2/src/model/roadmapData.ts
+++ b/frontend-v2/src/model/roadmapData.ts
@@ -19,7 +19,7 @@ import {
    type RoadmapUpdate,
 } from '../../../shared/model/roadmap';
 import { buildToday, dayStart, utcDay, type Project } from '../../../shared/model/projects';
-import { derive } from '../../../shared/model/status';
+import { derive, reviewPolicy } from '../../../shared/model/status';
 import { isBotLogin } from '../../../shared/model/visibility';
 import { dummyWorkInputs } from './workData';
 
@@ -173,14 +173,16 @@ let dummyFacts: { at: number; bySlug: Map<string, PlanLately> } | null = null;
 async function dummyLately(plans: readonly RoadmapItem[]): Promise<Map<string, PlanLately>> {
    if (dummyFacts && Date.now() - dummyFacts.at < 60_000) return dummyFacts.bySlug;
    const now = Date.now() / 1000;
-   const [{ pulls, bots = [], projectLabelPrefix }, { attached, linked }] = await Promise.all([
-      loadDummy(),
-      dummyWorkInputs(plans),
-   ]);
+   const [{ pulls, bots = [], projectLabelPrefix, developerTeams }, { attached, linked }] =
+      await Promise.all([loadDummy(), dummyWorkInputs(plans)]);
+   // the board's own roster, so a project's status here matches the board's
+   const policy = reviewPolicy(developerTeams, bots);
    const people = pulls.filter(p => !isBotLogin(p.user.login, new Set(bots)));
    const today = buildToday(
       DUMMY_PROJECTS,
-      people.filter(p => p.state === 'open').map(p => derive(p, undefined, now)),
+      people
+         .filter(p => p.state === 'open')
+         .map(p => derive(p, undefined, now, undefined, undefined, policy)),
       people.filter(p => p.state !== 'open'),
       projectLabelPrefix ?? 'project:',
       now,
diff --git a/frontend-v2/src/model/stats.test.ts b/frontend-v2/src/model/stats.test.ts
index 47e8240c..40a585cb 100644
--- a/frontend-v2/src/model/stats.test.ts
+++ b/frontend-v2/src/model/stats.test.ts
@@ -142,6 +142,7 @@ function full(over: {
    title?: string;
    body?: string;
    requested?: string[];
+   draft?: boolean;
    requests?: { login: string; at: number | null; self: boolean }[];
    reviews?: { login: string; date: number }[];
    conflict?: boolean;
@@ -162,6 +163,8 @@ function full(over: {
       reqaBy: over.reqaBy ?? [],
       qaingLogin: over.qaing ?? null,
       ownReview: over.ownReview ?? true,
+      askedOf: (over.requests ?? []).filter(r => !r.self).map(r => r.login),
+      askedAt: null,
       conflict: over.conflict ?? false,
       deployBlockedBy: over.deployBlockedBy ?? [],
       devBlockedBy: over.devBlockedBy ?? [],
@@ -172,6 +175,7 @@ function full(over: {
          number: over.n ?? 1,
          title: over.title ?? 't',
          body: over.body ?? '',
+         draft: over.draft ?? false,
          requested_reviewers: over.requested ?? [],
          review_requests: over.requests ?? [],
          additions: over.additions === undefined ? 100 : over.additions,
@@ -306,6 +310,8 @@ describe('waitingOnSomeone', () => {
             full({ n: 4, ownReview: false, ageDays: 9, requested: ['bob'] }), // asked: not outside
             full({ n: 5, ageDays: 20 }), // own review: nobody owes it
             full({ n: 6, ownReview: false, ageDays: 1, status: 'ready' }), // not short of CR
+            full({ n: 7, requests: [ask('erin', 9)], draft: true }), // a draft isn't waiting
+            full({ n: 8, requests: [ask('fay', 9)], status: 'needs_qa' }), // CR already met
          ],
          AT
       );
@@ -358,6 +364,21 @@ describe('selfReviewMix', () => {
       expect(mix).toMatchObject({ merged: 6, asked: 2, byOthers: 1, self: 2, unstamped: 1 });
    });
 
+   it('leaves bot reviews out of "reviewed by someone else"', () => {
+      const bot = { ...mergedPull({ n: 1 }) } as PullData;
+      bot.status = {
+         allCR: [],
+         allQA: [],
+         unstamped_reviewers: [{ login: 'review-bot' }, { login: 'ci[bot]' }],
+      } as unknown as PullData['status'];
+      expect(selfReviewMix([bot], new Set(['review-bot']))).toMatchObject({
+         byOthers: 0,
+         unstamped: 1,
+      });
+      // with no bot list, only the [bot] suffix is known
+      expect(selfReviewMix([bot])).toMatchObject({ byOthers: 1 });
+   });
+
    it('a claim is someone volunteering, not the author asking', () => {
       const mix = selfReviewMix([
          mergedPull({ n: 1, claimedBy: 'bob', cr: ['bob'] }), // bob volunteered
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index 3d3028de..f7622da3 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -9,6 +9,7 @@ import {
    WEIGHT_ORDER,
    reviewWeight,
 } from '../../../shared/model/status';
+import { isBotLogin } from '../../../shared/model/visibility';
 
 /**
  * The Stats lens's aggregation layer: pure reductions over the same open pool
@@ -296,9 +297,15 @@ export function waitingOnSomeone(pulls: DerivedPull[], now: number): WaitingOnSo
    for (const p of pulls) {
       const d = p.data;
       const ref = { repo: d.repo, number: d.number, title: d.title };
-      for (const r of openedRequests(d)) {
-         if (answersBy(d, r.login).some(t => t >= r.at)) continue;
-         requests.push({ ...ref, login: r.login, hours: Math.max(0, (now - r.at) / 3600) });
+      // askedOf is who is still being waited on (claims, the author and people
+      // who already stamped left out); a draft or a pull whose CR is met has
+      // nobody left to wait for
+      const open = !d.draft && CR_INCOMPLETE.includes(p.status);
+      for (const login of open ? p.askedOf ?? [] : []) {
+         const at =
+            (d.review_requests ?? []).find(r => !r.self && r.login === login)?.at ?? p.askedAt;
+         if (at == null || answersBy(d, login).some(t => t >= at)) continue;
+         requests.push({ ...ref, login, hours: Math.max(0, (now - at) / 3600) });
       }
       const asked = (d.requested_reviewers ?? []).length || (d.requested_teams ?? []).length;
       if (!p.ownReview && !asked && CR_INCOMPLETE.includes(p.status))
@@ -337,7 +344,10 @@ const WEEK_SECS = 7 * 86400;
  * "Reverts #n" of a self-reviewed pull in the same repo merged up to a week
  * before it. It sees only what the title and description say.
  */
-export function selfReviewMix(closed: PullData[]): SelfReviewMix {
+export function selfReviewMix(
+   closed: PullData[],
+   bots: ReadonlySet<string> = new Set()
+): SelfReviewMix {
    const mergedAt = (d: PullData) => sec(d.merged_at);
    const mix = { merged: 0, asked: 0, byOthers: 0, self: 0, unstamped: 0 };
    const selfMerged = new Map<string, number>();
@@ -351,8 +361,12 @@ export function selfReviewMix(closed: PullData[]): SelfReviewMix {
          (d.requested_teams ?? []).length ||
          (d.requested_reviewers ?? []).some(l => !claims.has(l)) ||
          (d.review_requests ?? []).some(r => !r.self);
-      const stampers = [...d.status.allCR, ...d.status.allQA].map(s => s.data.user.login);
-      const reviewers = (d.status.unstamped_reviewers ?? []).map(r => r.login);
+      // a bot's comment (the CI review bot is on most pulls) isn't a person's review
+      const human = (l: string) => !isBotLogin(l, bots);
+      const stampers = [...d.status.allCR, ...d.status.allQA]
+         .map(s => s.data.user.login)
+         .filter(human);
+      const reviewers = (d.status.unstamped_reviewers ?? []).map(r => r.login).filter(human);
       const others = [...stampers, ...reviewers].some(l => l !== author);
       if (asked) mix.asked += 1;
       else if (others) mix.byOthers += 1;
diff --git a/frontend-v2/src/store.test.ts b/frontend-v2/src/store.test.ts
index f5d3a414..5cfaa7fc 100644
--- a/frontend-v2/src/store.test.ts
+++ b/frontend-v2/src/store.test.ts
@@ -1,7 +1,14 @@
 import { describe, expect, it } from 'vitest';
 import { pullKey } from '../../shared/format';
 import type { PullData } from '../../shared/types';
-import { isNewBuild, isSnoozed, refreshAllText, type SnoozeRecord } from './store';
+import {
+   currentPolicy,
+   isNewBuild,
+   isSnoozed,
+   refreshAllText,
+   setDeveloperTeams,
+   type SnoozeRecord,
+} from './store';
 
 // isSnoozed reads only repo/number/updated_at and a few status counts, so a
 // minimal pull is enough; the outer cast keeps the fixture to what it touches.
@@ -201,3 +208,12 @@ describe('isNewBuild', () => {
       expect(isNewBuild('a', undefined)).toBe(false);
    });
 });
+
+describe('setDeveloperTeams', () => {
+   it('rebuilds the review policy from a roster saved after connect', () => {
+      expect(currentPolicy().developers.size).toBe(0);
+      setDeveloperTeams({ Store: ['Alice'] });
+      expect([...currentPolicy().developers]).toEqual(['alice']);
+      expect(currentPolicy().teams.get('store')).toEqual(['Alice']);
+   });
+});
diff --git a/frontend-v2/src/store.ts b/frontend-v2/src/store.ts
index fd639fd1..5db611db 100644
--- a/frontend-v2/src/store.ts
+++ b/frontend-v2/src/store.ts
@@ -304,6 +304,14 @@ function schedulePublish() {
    }, 250);
 }
 
+/** Rebuild who owes a review from a freshly saved roster and re-derive. */
+export function setDeveloperTeams(teams: Record<string, string[]> | undefined): void {
+   policy = reviewPolicy(teams, [...extraBots]);
+   schedulePublish();
+}
+/** The roster-derived policy the board is deriving with (for tests). */
+export const currentPolicy = (): ReviewPolicy => policy;
+
 let started = false;
 function start() {
    if (started) return;
@@ -344,6 +352,8 @@ function start() {
       schedulePublish();
    });
    backend.onRefreshAll(setRefreshProgress);
+   // a saved roster reaches open boards here, not only at connect
+   backend.onDeveloperTeams(setDeveloperTeams);
    backend.onConnection(state => {
       connection = state;
       schedulePublish();
diff --git a/frontend-v2/src/views/Stats.tsx b/frontend-v2/src/views/Stats.tsx
index 60771497..d14b7f6e 100644
--- a/frontend-v2/src/views/Stats.tsx
+++ b/frontend-v2/src/views/Stats.tsx
@@ -65,11 +65,14 @@ function Group({ title, children }: { title: string; children: ReactNode }) {
 export function Stats({
    pulls,
    closed,
+   bots,
    me,
    onPerson,
 }: {
    pulls: DerivedPull[];
    closed: PullData[];
+   /** config bots beyond the [bot] suffix */
+   bots: ReadonlySet<string>;
    me: string;
    onPerson: (login: string) => void;
 }) {
@@ -86,7 +89,7 @@ export function Stats({
    // flow — the closed window plus stamp timestamps
    const perDay = useMemo(() => mergedPerDay(closed, WINDOW_DAYS, Date.now()), [closed]);
    const answer = useMemo(() => requestAnswerTimes(pulls, closed), [pulls, closed]);
-   const selfMix = useMemo(() => selfReviewMix(closed), [closed]);
+   const selfMix = useMemo(() => selfReviewMix(closed, bots), [closed, bots]);
    const pulse = useMemo(
       () => stampsPerDay(pulls, closed, WINDOW_DAYS, Date.now()),
       [pulls, closed]
diff --git a/lib/git-manager.js b/lib/git-manager.js
index fd7a8935..df358219 100644
--- a/lib/git-manager.js
+++ b/lib/git-manager.js
@@ -953,7 +953,15 @@ const commitsMemo = new Map();
 async function getPullCommitsMemo(repo, number, sha) {
    const key = `${repo}#${number}@${sha}`;
    if (commitsMemo.has(key)) return commitsMemo.get(key);
-   const commits = await getPullCommits(repo, number);
+   // keep only what stampSurvivesBaseMerges reads: listCommits objects run to
+   // several KB each, and this holds up to 2000 heads x 250 commits
+   const commits = (await getPullCommits(repo, number)).map(c => ({
+      parents: (c.parents ?? []).map(() => ({})),
+      commit: {
+         message: String(c.commit?.message ?? '').split('\n')[0],
+         committer: { date: c.commit?.committer?.date },
+      },
+   }));
    commitsMemo.set(key, commits);
    if (commitsMemo.size > COMMITS_MEMO_MAX) commitsMemo.delete(commitsMemo.keys().next().value);
    return commits;
diff --git a/lib/pull-manager.js b/lib/pull-manager.js
index 47129983..658288f1 100644
--- a/lib/pull-manager.js
+++ b/lib/pull-manager.js
@@ -68,6 +68,14 @@ pullManager.projectsChanged = function () {
    });
 };
 
+/**
+ * The developer roster was saved: open boards rebuild who owes a review from
+ * it, rather than keep the roster they were handed at connect.
+ */
+pullManager.developerTeamsChanged = function () {
+   pullManager.broadcast('developerTeamsChanged', { developerTeams: developerTeams() });
+};
+
 function sendInitialData(socket) {
    pmDebug('Emitting `initialize`: %s pulls altogether', pulls.length);
    socket.emit('initialize', {
diff --git a/test/hooks-synchronize.test.js b/test/hooks-synchronize.test.js
index 1e19c8eb..13dbfc48 100644
--- a/test/hooks-synchronize.test.js
+++ b/test/hooks-synchronize.test.js
@@ -10,7 +10,7 @@ const merge = {
    commit: { message: "Merge branch 'master' into f" },
 };
 
-async function push(t, getCommit) {
+async function push(t, getCommit, before = 'a') {
    const invalidated = [];
    t.mock.method(git, 'getCommit', getCommit);
    t.mock.method(dbManager, 'invalidateSignatures', async (...args) => invalidated.push(args));
@@ -18,6 +18,7 @@ async function push(t, getCommit) {
    t.mock.method(refresh, 'pull', async () => {});
    const body = {
       action: 'synchronize',
+      before,
       after: 'newhead',
       repository: { full_name: 'o/r' },
       pull_request: {
@@ -56,3 +57,18 @@ test('a failed commit lookup invalidates the stamps', async t => {
    });
    assert.equal(invalidated.length, 1);
 });
+
+test('a base merge on top of new code invalidates: only a lone merge keeps stamps', async t => {
+   // the merge's first parent is the code commit, not the head before the push
+   const invalidated = await push(t, async () => merge, 'older-head');
+   assert.equal(invalidated.length, 1);
+});
+
+test('a slow commit lookup is cut off and invalidates', async t => {
+   t.mock.timers.enable({ apis: ['setTimeout'] });
+   const pending = push(t, () => new Promise(() => {}));
+   // let the handler reach its timer, then run it out
+   await new Promise(resolve => setImmediate(resolve));
+   t.mock.timers.tick(3000);
+   assert.equal((await pending).length, 1);
+});
diff --git a/test/settings.test.js b/test/settings.test.js
index 8d91f91b..864f3cb1 100644
--- a/test/settings.test.js
+++ b/test/settings.test.js
@@ -6,6 +6,7 @@ import config from '../lib/config-loader.js';
 import db from '../lib/db.js';
 import { projectSettings } from '../lib/projects.js';
 import { _resetSettings, loadSettings } from '../lib/settings.js';
+import pullManager from '../lib/pull-manager.js';
 import settingsController from '../controllers/settings.js';
 import { canWrite } from '../controllers/roadmap.js';
 import { mondayOf, utcDay } from '../shared/dist/index.js';
@@ -153,3 +154,14 @@ test('a login on two teams, or a missing field, is a 400 that says why', async (
    assert.equal((await patch({})).status, 400);
    assert.equal(table.size, 0);
 });
+
+test('saving the teams tells open boards the new roster', async t => {
+   const heard = [];
+   t.mock.method(pullManager, 'broadcast', (event, payload) => heard.push([event, payload]));
+   await patch({ ongoing_projects: ['docs'] });
+   assert.deepEqual(heard, []);
+   await patch({ developer_teams: { Store: ['alice', 'bo'] } });
+   assert.deepEqual(heard, [
+      ['developerTeamsChanged', { developerTeams: { Store: ['alice', 'bo'] } }],
+   ]);
+});

From 0585efce53060e4b54739ed03330e44d126efb60 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 18:31:05 -0700
Subject: [PATCH 11/17] Count an unnamed team request as every developer

A review request to a GitHub team the roster doesn't name, like
@iFixit/coders, became nobody's work: no queue, no alert, no nudge.
The policy says a request asks everyone listed, and the team people
actually request is usually the whole dev team, so a team the roster
doesn't name now asks every developer on it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/status.test.ts | 4 ++--
 shared/model/status.ts               | 6 +++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index a995202a..ed999da0 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -461,7 +461,7 @@ describe('the self-review policy', () => {
       );
       expect(d.askedOf).toEqual(['a', 'b']);
       expect(d.ownReview).toBe(false);
-      // a team the roster doesn't know still counts as asking for review
+      // a team the roster doesn't name (say @iFixit/coders) asks every developer
       const unknown = derive(
          pull({ requested_teams: ['infra'] }),
          undefined,
@@ -471,7 +471,7 @@ describe('the self-review policy', () => {
          policy
       );
       expect(unknown.ownReview).toBe(false);
-      expect(unknown.askedOf).toEqual([]);
+      expect(unknown.askedOf).toEqual(['a', 'b', 'c']);
    });
 
    it('a reviewer who stamped is no longer asked, though GitHub keeps the request', () => {
diff --git a/shared/model/status.ts b/shared/model/status.ts
index d60ad9ad..39aaebb9 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -329,9 +329,13 @@ export function derive(
    // "asked" (and the author would be told to nudge them).
    const claims = new Set((pull.review_requests ?? []).filter(r => r.self).map(r => r.login));
    const requestedTeams = pull.requested_teams ?? [];
+   // a team the roster doesn't name (say @iFixit/coders, the whole dev
+   // team) asks every developer on the roster
+   const everyone = [...policy.teams.values()].flat();
    const teamOf = new Map<string, string>();
    for (const t of requestedTeams)
-      for (const l of policy.teams.get(t.toLowerCase()) ?? []) teamOf.set(l, t.toLowerCase());
+      for (const l of policy.teams.get(t.toLowerCase()) ?? everyone)
+         if (!teamOf.has(l)) teamOf.set(l, t.toLowerCase());
    const askedOf = unique([
       ...(pull.requested_reviewers ?? []).filter(l => !claims.has(l)),
       ...teamOf.keys(),

From e6d821b3451790c0877c4af3ac49623ead22620c Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 18:43:20 -0700
Subject: [PATCH 12/17] Show request clocks only while a review is owed

A review of the self-review branch found:

1) The amber "asked 5h ago" flag stayed on after CR was met (say, by
   the author's own stamp), though nothing waited on the people asked
   any more. It now shows only while CR is still short.
2) The Waiting card dated a team member's wait from the pull's oldest
   request, so someone asked an hour ago through a team showed as
   waiting three days when another person was asked by name back then.
   derive now gives each asked person their own time (askedAtBy).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/components/Row.tsx   |  6 ++++--
 frontend-v2/src/model/stats.test.ts  | 15 +++++++++++++++
 frontend-v2/src/model/stats.ts       |  6 +++++-
 frontend-v2/src/model/status.test.ts |  1 +
 shared/model/status.ts               |  4 ++++
 5 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/frontend-v2/src/components/Row.tsx b/frontend-v2/src/components/Row.tsx
index 74a89adc..dcd1c6f8 100644
--- a/frontend-v2/src/components/Row.tsx
+++ b/frontend-v2/src/components/Row.tsx
@@ -11,7 +11,7 @@ import {
    RefreshCw,
 } from 'lucide-react';
 import type { DerivedPull } from '../../../shared/model/status';
-import { isIterating, lastPushEpoch } from '../../../shared/model/status';
+import { CR_INCOMPLETE, isIterating, lastPushEpoch } from '../../../shared/model/status';
 import { askedAgo, askForInputHint, askOverdue, type Claim, rowNote } from '../model/actions';
 import { matchedRegions } from '../model/regions';
 import { claimFor } from '../model/reviewers';
@@ -183,7 +183,9 @@ function rowFlags(
    }
    // a review someone was asked for runs on hours, so its clock sits on the
    // row, amber once nobody has answered in ASK_OVERDUE_HOURS
-   if (p.askedOf.length && ['needs_cr', 'needs_recr', 'needs_qa'].includes(p.status)) {
+   // only while the review is still owed: once CR is met (the author's own
+   // stamp counts), nothing waits on the people asked
+   if (p.askedOf.length && CR_INCOMPLETE.includes(p.status)) {
       const team = (p.data.requested_teams ?? []).length ? ' (through a team request)' : '';
       flags.push({
          key: 'asked',
diff --git a/frontend-v2/src/model/stats.test.ts b/frontend-v2/src/model/stats.test.ts
index 40a585cb..6b4bb1a6 100644
--- a/frontend-v2/src/model/stats.test.ts
+++ b/frontend-v2/src/model/stats.test.ts
@@ -323,6 +323,21 @@ describe('waitingOnSomeone', () => {
          { repo: 'iFixit/ifixit', number: 3, title: 't', author: 'zed', days: 6 },
       ]);
    });
+
+   it("dates a team member's wait from their team's request, not the pull's oldest", () => {
+      // bob was asked by name 72h ago; gil only through a team, 1h ago
+      const pull = {
+         ...full({ n: 1, requests: [ask('bob', 72)], allCR: [] }),
+         askedOf: ['bob', 'gil'],
+         askedAt: ask('bob', 72).at,
+         askedAtBy: { bob: ask('bob', 72).at, gil: ask('gil', 1).at },
+      };
+      const w = waitingOnSomeone([pull], AT);
+      expect(w.requests.map(r => [r.login, r.hours])).toEqual([
+         ['bob', 72],
+         ['gil', 1],
+      ]);
+   });
 });
 
 function mergedPull(over: {
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index f7622da3..4785bc68 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -303,7 +303,11 @@ export function waitingOnSomeone(pulls: DerivedPull[], now: number): WaitingOnSo
       const open = !d.draft && CR_INCOMPLETE.includes(p.status);
       for (const login of open ? p.askedOf ?? [] : []) {
          const at =
-            (d.review_requests ?? []).find(r => !r.self && r.login === login)?.at ?? p.askedAt;
+            // their own request, else their team's (derive's askedAtBy); the
+            // pull's earliest only when neither is known
+            (d.review_requests ?? []).find(r => !r.self && r.login === login)?.at ??
+            p.askedAtBy?.[login] ??
+            p.askedAt;
          if (at == null || answersBy(d, login).some(t => t >= at)) continue;
          requests.push({ ...ref, login, hours: Math.max(0, (now - at) / 3600) });
       }
diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index ed999da0..88c23bd0 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -502,6 +502,7 @@ describe('the self-review policy', () => {
       );
       expect(d.askedOf).toEqual(['a', 'b']);
       expect(d.askedAt).toBe(NOW - 7200);
+      expect(d.askedAtBy).toEqual({ a: NOW - 7200, b: NOW - 7200 });
    });
 
    it('on a self-reviewed pull only the author owes a re-stamp', () => {
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 39aaebb9..007a28cd 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -95,6 +95,9 @@ export interface DerivedPull {
    /** epoch secs of the earliest open request in askedOf; null if none or
     * unknown. Requests are answered in hours, so this clock drives the nudge */
    askedAt: number | null;
+   /** when each login in askedOf was asked: their own request, else their
+    * team's; null when unknown. Optional so older fixtures still type */
+   askedAtBy?: Record<string, number | null>;
    starveScore: number;
    weight: Weight;
    /** mergeable === false: shows as a flag everywhere, gates "ready" */
@@ -473,6 +476,7 @@ export function derive(
       ownReview,
       askedOf,
       askedAt: Number.isFinite(askedAt) ? askedAt : null,
+      askedAtBy: Object.fromEntries(askedOf.map((l, i) => [l, askedTimes[i]])),
    };
 }
 

From 278bde689040b9df9ec1f92b39b4f2799a6f5e5e Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 18:50:21 -0700
Subject: [PATCH 13/17] Say that team requests need a roster to route

A review noted that with no developer roster a team-only request asks
nobody in particular. That's the only honest answer when nobody can be
named; the comment now says so where a team request is resolved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 shared/model/status.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/shared/model/status.ts b/shared/model/status.ts
index 007a28cd..9691ffb0 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -333,7 +333,9 @@ export function derive(
    const claims = new Set((pull.review_requests ?? []).filter(r => r.self).map(r => r.login));
    const requestedTeams = pull.requested_teams ?? [];
    // a team the roster doesn't name (say @iFixit/coders, the whole dev
-   // team) asks every developer on the roster
+   // team) asks every developer on the roster. With no roster there's
+   // nobody to name, so a team request asks nobody in particular: it shows
+   // under Could use your input, and team requests need a roster to route.
    const everyone = [...policy.teams.values()].flat();
    const teamOf = new Map<string, string>();
    for (const t of requestedTeams)

From d64807a00cb6003aabff26d90ff64fc98bef2689 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 19:07:40 -0700
Subject: [PATCH 14/17] Route a non-developer's PR once its reviewer has
 answered

Asking for a review was taken as proof the author is a developer. Once
the reviewer stamped, they left askedOf (a CR comment doesn't clear
GitHub's request), so a contractor's PR fell into nobody's queue and
the board told its author to stamp CR and QA themselves.

derive now says whether the author is a developer (authorIsDeveloper,
also on /api/v1 as review.author_is_developer). A non-developer's PR
with nobody left to answer goes back to the open queue and Needs QA,
and its author isn't told to self-review. Developers' PRs work as
before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 controllers/api.js                        |  7 +++-
 frontend-v2/src/model/actions.test.ts     | 46 ++++++++++++++++++++++-
 frontend-v2/src/model/actions.ts          | 15 ++++----
 frontend-v2/src/model/deal.test.ts        |  1 +
 frontend-v2/src/model/reviewLanes.test.ts |  8 ++++
 frontend-v2/src/model/sort.test.ts        |  1 +
 frontend-v2/src/model/stack.test.ts       |  1 +
 frontend-v2/src/model/stage.test.ts       |  1 +
 frontend-v2/src/model/stats.test.ts       | 13 +++++++
 frontend-v2/src/model/stats.ts            |  6 ++-
 frontend-v2/src/model/status.test.ts      | 12 ++++++
 frontend-v2/src/model/team.test.ts        |  1 +
 shared/model/status.ts                    |  5 +++
 test/api.test.js                          |  7 +++-
 14 files changed, 113 insertions(+), 11 deletions(-)

diff --git a/controllers/api.js b/controllers/api.js
index 3f04a27c..a06808de 100644
--- a/controllers/api.js
+++ b/controllers/api.js
@@ -34,7 +34,12 @@ function toRecord(d) {
          cr: { req: p.status.cr_req, have: d.crHave, by: d.crBy, recr_by: d.recrBy },
          qa: { req: p.status.qa_req, have: d.qaHave, by: d.qaBy },
       },
-      review: { own: d.ownReview, asked_of: d.askedOf, asked_at: d.askedAt },
+      review: {
+         own: d.ownReview,
+         author_is_developer: d.authorIsDeveloper,
+         asked_of: d.askedOf,
+         asked_at: d.askedAt,
+      },
       dev_blocked_by: d.devBlockedBy,
       deploy_blocked_by: d.deployBlockedBy,
       head_sha: p.head.sha,
diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index 1a3252e0..197ff5d6 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -25,6 +25,8 @@ import {
  * `ownReview: true` is a developer's own unrequested pull. */
 function dp(o: {
    ownReview?: boolean;
+   /** on the dev roster; defaults to own review or having asked someone */
+   authorIsDeveloper?: boolean;
    askedOf?: string[];
    askedAt?: number | null;
    /** a claim: who said they'd review it (review_requests self === true) */
@@ -69,6 +71,9 @@ function dp(o: {
          requested_teams: o.requestedTeams,
       },
       ownReview: o.ownReview ?? false,
+      authorIsDeveloper:
+         o.authorIsDeveloper ??
+         (!!o.ownReview || !!o.askedOf?.length || !!o.requestedTeams?.length),
       askedOf: o.askedOf ?? [],
       askedAt: o.askedAt ?? null,
       status: o.status,
@@ -914,7 +919,12 @@ describe('self-review: a developer CRs and QAs their own unrequested pull', () =
    });
 
    it('a bot is never a developer, whatever ownReview says', () => {
-      const bot = dp({ author: 'dependabot[bot]', status: 'needs_cr', ownReview: true });
+      const bot = dp({
+         author: 'dependabot[bot]',
+         status: 'needs_cr',
+         ownReview: true,
+         authorIsDeveloper: false,
+      });
       expect(rowNote(bot, 'me').action).toBe('Review it');
       expect(reviewIsMine(bot, 'me')).toBe(true);
    });
@@ -1204,6 +1214,40 @@ describe('the requested reviewer reviews; the author tests', () => {
       );
    });
 
+   // GitHub keeps a reviewer in requested_reviewers after their CR comment, so
+   // a request stays on record (here a team) once askedOf is empty
+   it('a contractor who asked someone, once they stamped, is back to needing an outside tester', () => {
+      const p = dp({
+         author: 'con',
+         status: 'needs_qa',
+         requestedTeams: ['store'],
+         authorIsDeveloper: false,
+      });
+      expect(qaIsMine(p, 'bob')).toBe(true);
+      expect(qaIsMine(p, 'con')).toBe(false);
+      expect(rowNote(p, 'con').action).not.toBe('Stamp QA');
+   });
+
+   it('a contractor with CR still short after one stamp stays in the open review queue', () => {
+      const p = dp({
+         author: 'con',
+         status: 'needs_cr',
+         crReq: 2,
+         crHave: 1,
+         requestedTeams: ['store'],
+         authorIsDeveloper: false,
+      });
+      expect(reviewIsMine(p, 'alice')).toBe(true);
+      expect(nobodysReview(p)).toBe(false);
+      expect(rowNote(p, 'con').action).not.toBe('Stamp CR');
+   });
+
+   it('a developer who asked and was answered by someone else still self-QAs', () => {
+      const p = dp({ author: 'dev', status: 'needs_qa', requestedTeams: ['store'] });
+      expect(qaIsMine(p, 'bob')).toBe(false);
+      expect(rowNote(p, 'dev').action).toBe('Stamp QA');
+   });
+
    it('an outside author still waits on a tester', () => {
       expect(rowNote(dp({ author: 'me', status: 'needs_qa' }), 'me')).toEqual({
          action: null,
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index 8855b32d..247ce97a 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -55,10 +55,12 @@ const hasRequest = (p: DerivedPull): boolean =>
    !!(askedOf(p).length || p.data.requested_reviewers?.length || p.data.requested_teams?.length);
 
 /** Needs a reviewer from outside: the author is outside the dev team (or a
- * bot), and nobody was asked or took it on. The only pulls where QA is not
- * the author's own job. */
+ * bot), and nobody who was asked still owes it, nor took it on. A request on
+ * record doesn't count: GitHub keeps a reviewer listed after they stamp, so
+ * once everyone asked has answered it is back in the open queue. The only
+ * pulls where QA is not the author's own job. */
 const needsOutsideReview = (p: DerivedPull): boolean =>
-   !selfReviewed(p) && !hasRequest(p) && !claimFor(p.data);
+   !p.authorIsDeveloper && !selfReviewed(p) && !askedOf(p).length && !claimFor(p.data);
 
 /**
  * Whether this pull is `me`'s code review: asked of me (by name or through a
@@ -74,8 +76,7 @@ export function reviewIsMine(p: DerivedPull, me: string): boolean {
    if (claim?.login === me) return true;
    const asked = askedOf(p);
    if (asked.length) return asked.includes(me);
-   if (claim || hasRequest(p)) return false;
-   return !selfReviewed(p);
+   return needsOutsideReview(p);
 }
 
 /** Whether this pull's QA is `me`'s. A requested reviewer was asked for a
@@ -90,7 +91,7 @@ export function qaIsMine(p: DerivedPull, me: string): boolean {
 /** Requested of a team nobody on the roster is in, or of people who have all
  * answered: nobody's review work, but worth showing to anyone who might help. */
 export const nobodysReview = (p: DerivedPull): boolean =>
-   hasRequest(p) && !askedOf(p).length && !claimFor(p.data);
+   p.authorIsDeveloper && hasRequest(p) && !askedOf(p).length && !claimFor(p.data);
 
 const INPUT_HINT_WORDS: Record<string, string> = {
    ci: 'CI',
@@ -265,7 +266,7 @@ function authorNote(p: DerivedPull, me: string): RowNote {
       return waitOnly(`${who([p.qaingLogin])} is testing it`);
    // asked reviewers are for the review; QA is the author's own under the
    // policy, so once CR is met it's yours to stamp whoever is still listed
-   const authorIsDev = selfReviewed(p) || hasRequest(p);
+   const authorIsDev = p.authorIsDeveloper;
    if (p.status === 'needs_qa' && authorIsDev)
       return { action: 'Stamp QA', context: 'test it yourself, or ask someone to' };
    // you asked for a review: theirs to give, answered in hours
diff --git a/frontend-v2/src/model/deal.test.ts b/frontend-v2/src/model/deal.test.ts
index 931902f1..534eb727 100644
--- a/frontend-v2/src/model/deal.test.ts
+++ b/frontend-v2/src/model/deal.test.ts
@@ -44,6 +44,7 @@ function dp(o: {
       sizeKnown: o.sizeKnown ?? true,
       headPushedAt: o.headPushedAt ?? null,
       ownReview: o.ownReview ?? false,
+      authorIsDeveloper: o.ownReview ?? false,
    } as unknown as DerivedPull;
 }
 
diff --git a/frontend-v2/src/model/reviewLanes.test.ts b/frontend-v2/src/model/reviewLanes.test.ts
index ae857f02..1fcd6955 100644
--- a/frontend-v2/src/model/reviewLanes.test.ts
+++ b/frontend-v2/src/model/reviewLanes.test.ts
@@ -13,6 +13,8 @@ import { buildReviewLanes, type ReviewLanesInput } from './reviewLanes';
  * requestedReviewers minus claims, as derive() builds it. */
 function dp(o: {
    ownReview?: boolean;
+   /** on the dev roster; defaults to own review or having asked someone */
+   authorIsDeveloper?: boolean;
    askedOf?: string[];
    askedAt?: number | null;
    repo?: string;
@@ -106,6 +108,12 @@ function dp(o: {
       changesRequestedBy: o.changesRequestedBy ?? [],
       engagedNoStamp: o.engagedNoStamp ?? [],
       ownReview: o.ownReview ?? false,
+      authorIsDeveloper:
+         o.authorIsDeveloper ??
+         (!!o.ownReview ||
+            !!o.askedOf?.length ||
+            !!o.requestedReviewers?.length ||
+            !!o.requestedTeams?.length),
       askedOf:
          o.askedOf ??
          (o.requestedReviewers ?? []).filter(
diff --git a/frontend-v2/src/model/sort.test.ts b/frontend-v2/src/model/sort.test.ts
index 16a6cbe0..c6f2487d 100644
--- a/frontend-v2/src/model/sort.test.ts
+++ b/frontend-v2/src/model/sort.test.ts
@@ -19,6 +19,7 @@ function fake(over: {
       crHave: over.crHave ?? 0,
       crBy: over.crBy ?? Array.from({ length: over.crHave ?? 0 }, (_, i) => `reviewer${i}`),
       ownReview: over.ownReview ?? false,
+      authorIsDeveloper: over.ownReview ?? false,
       weight: over.weight ?? 'S',
       sizeKnown: over.sizeKnown ?? true,
       data: {
diff --git a/frontend-v2/src/model/stack.test.ts b/frontend-v2/src/model/stack.test.ts
index 341cfb75..63196229 100644
--- a/frontend-v2/src/model/stack.test.ts
+++ b/frontend-v2/src/model/stack.test.ts
@@ -79,6 +79,7 @@ function dp(
       changesRequestedBy: [],
       engagedNoStamp: [],
       ownReview: false,
+      authorIsDeveloper: false,
       askedOf: [],
       askedAt: null,
    };
diff --git a/frontend-v2/src/model/stage.test.ts b/frontend-v2/src/model/stage.test.ts
index 556e1b04..2e85b792 100644
--- a/frontend-v2/src/model/stage.test.ts
+++ b/frontend-v2/src/model/stage.test.ts
@@ -69,6 +69,7 @@ function dp(
       reqaBy: [],
       engagedNoStamp: [],
       ownReview: o.ownReview ?? false,
+      authorIsDeveloper: o.ownReview ?? false,
       askedOf: o.askedOf ?? [],
       askedAt: o.askedAt ?? null,
    } as unknown as DerivedPull;
diff --git a/frontend-v2/src/model/stats.test.ts b/frontend-v2/src/model/stats.test.ts
index 6b4bb1a6..95820eb0 100644
--- a/frontend-v2/src/model/stats.test.ts
+++ b/frontend-v2/src/model/stats.test.ts
@@ -139,6 +139,7 @@ function full(over: {
    reqaBy?: string[];
    qaing?: string | null;
    ownReview?: boolean;
+   authorIsDeveloper?: boolean;
    title?: string;
    body?: string;
    requested?: string[];
@@ -163,6 +164,8 @@ function full(over: {
       reqaBy: over.reqaBy ?? [],
       qaingLogin: over.qaing ?? null,
       ownReview: over.ownReview ?? true,
+      authorIsDeveloper:
+         over.authorIsDeveloper ?? ((over.ownReview ?? true) || !!over.requested?.length),
       askedOf: (over.requests ?? []).filter(r => !r.self).map(r => r.login),
       askedAt: null,
       conflict: over.conflict ?? false,
@@ -312,6 +315,15 @@ describe('waitingOnSomeone', () => {
             full({ n: 6, ownReview: false, ageDays: 1, status: 'ready' }), // not short of CR
             full({ n: 7, requests: [ask('erin', 9)], draft: true }), // a draft isn't waiting
             full({ n: 8, requests: [ask('fay', 9)], status: 'needs_qa' }), // CR already met
+            // a contractor whose asked reviewer already stamped (GitHub still lists them)
+            full({
+               n: 9,
+               ownReview: false,
+               authorIsDeveloper: false,
+               requested: ['bob'],
+               ageDays: 3,
+               author: 'con',
+            }),
          ],
          AT
       );
@@ -321,6 +333,7 @@ describe('waitingOnSomeone', () => {
       ]);
       expect(w.outside).toEqual([
          { repo: 'iFixit/ifixit', number: 3, title: 't', author: 'zed', days: 6 },
+         { repo: 'iFixit/ifixit', number: 9, title: 't', author: 'con', days: 3 },
       ]);
    });
 
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index 4785bc68..29e40f21 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -311,7 +311,11 @@ export function waitingOnSomeone(pulls: DerivedPull[], now: number): WaitingOnSo
          if (at == null || answersBy(d, login).some(t => t >= at)) continue;
          requests.push({ ...ref, login, hours: Math.max(0, (now - at) / 3600) });
       }
-      const asked = (d.requested_reviewers ?? []).length || (d.requested_teams ?? []).length;
+      // a developer who asked is waiting on those people (counted above); a
+      // non-developer is outside until nobody asked still owes a review
+      const asked = p.authorIsDeveloper
+         ? (d.requested_reviewers ?? []).length || (d.requested_teams ?? []).length
+         : p.askedOf.length;
       if (!p.ownReview && !asked && CR_INCOMPLETE.includes(p.status))
          outside.push({ ...ref, author: d.user.login, days: p.ageDays });
    }
diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index 88c23bd0..abc25318 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -522,6 +522,18 @@ describe('the self-review policy', () => {
    it("someone outside the dev team doesn't review their own", () => {
       const d = derive(pull(), undefined, NOW, undefined, undefined, OUTSIDER);
       expect(d.ownReview).toBe(false);
+      expect(d.authorIsDeveloper).toBe(false);
+      // asking for a review doesn't make the author a developer
+      const asked = derive(
+         pull({ requested_reviewers: ['r'] }),
+         undefined,
+         NOW,
+         undefined,
+         undefined,
+         OUTSIDER
+      );
+      expect(asked.authorIsDeveloper).toBe(false);
+      expect(derive(pull(), undefined, NOW).authorIsDeveloper).toBe(true);
       expect(isDeveloper(OUTSIDER, 'R')).toBe(true);
    });
 
diff --git a/frontend-v2/src/model/team.test.ts b/frontend-v2/src/model/team.test.ts
index 1b11289e..3c3e477b 100644
--- a/frontend-v2/src/model/team.test.ts
+++ b/frontend-v2/src/model/team.test.ts
@@ -31,6 +31,7 @@ function dp(o: {
       sizeKnown: o.sizeKnown ?? true,
       crHave: o.crHave ?? 0,
       ownReview: o.ownReview ?? false,
+      authorIsDeveloper: o.ownReview ?? false,
       askedOf: o.askedOf ?? [],
    } as unknown as DerivedPull;
 }
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 9691ffb0..43ab0bad 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -88,6 +88,10 @@ export interface DerivedPull {
     * person, no team, no claim). Its CR and QA are the author's own to do,
     * and nobody else owes it anything */
    ownReview: boolean;
+   /** the author is on the dev roster (and not a bot), whether or not they
+    * asked for a review. A request on record doesn't prove it: contractors
+    * ask too, and their pull still needs someone else's CR and QA */
+   authorIsDeveloper: boolean;
    /** logins asked to review it by the author's side: requested reviewers
     * (claims excluded) plus every member of a requested roster team; never
     * the author */
@@ -476,6 +480,7 @@ export function derive(
       changesRequestedBy,
       engagedNoStamp,
       ownReview,
+      authorIsDeveloper: isDeveloper(policy, author),
       askedOf,
       askedAt: Number.isFinite(askedAt) ? askedAt : null,
       askedAtBy: Object.fromEntries(askedOf.map((l, i) => [l, askedTimes[i]])),
diff --git a/test/api.test.js b/test/api.test.js
index f2a3f5cc..be601397 100644
--- a/test/api.test.js
+++ b/test/api.test.js
@@ -153,7 +153,12 @@ test('serves the board classified server-side (/pulls)', async () => {
    assert.equal(rec.signoffs.cr.req, 2);
    assert.equal(rec.signoffs.cr.have, 0);
    assert.equal(rec.url, 'https://github.com/test/repo-a/pull/42');
-   assert.deepEqual(rec.review, { own: true, asked_of: [], asked_at: null });
+   assert.deepEqual(rec.review, {
+      own: true,
+      author_is_developer: true,
+      asked_of: [],
+      asked_at: null,
+   });
    assert.equal(rec.is_bot, false); // bob isn't a configured bot
    const botRec = body.pulls.find(p => p.id === 'test/repo-a#43');
    assert.equal(botRec.is_bot, true); // fixture-bot is, via config.js bots

From 8b62f1b506a60c681ab5492168f9f0c0485efac2 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 19:21:38 -0700
Subject: [PATCH 15/17] Remember answered review requests, and fix the Ready
 lane
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A review walking each PR's lifecycle found:

1) A signed-off PR from an outside contributor or a bot was on nobody's
   Ready lane. It's on everyone's again, reading "ready · merge it",
   since its author usually can't.
2) GitHub clears a review request as soon as the reviewer submits any
   review, with no event saying so (checked on #63534 and #63360). So
   after the author's next push the PR read as self-review: the author
   was told to stamp CR, and the reviewer wasn't asked to re-stamp.
   The server now reads answered requests from the PR's timeline, and
   a PR that ever asked someone stays theirs to answer.
3) Stats listed a claimed outside PR as waiting on a first review.
4) An own PR whose next step was "Answer the review" or "Unblock"
   showed in neither Review lane.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/actions.test.ts     |  8 +++-
 frontend-v2/src/model/actions.ts          | 12 +++++-
 frontend-v2/src/model/reviewLanes.test.ts | 50 ++++++++++++++++++++---
 frontend-v2/src/model/reviewLanes.ts      | 22 ++++++++--
 frontend-v2/src/model/reviewers.ts        |  4 +-
 frontend-v2/src/model/stats.ts            |  3 +-
 frontend-v2/src/model/status.test.ts      | 17 ++++++++
 lib/git-manager.js                        | 21 ++++++++--
 models/pull.js                            | 18 ++++++--
 shared/model/status.ts                    |  5 ++-
 shared/types.ts                           |  7 +++-
 test/derive-review-requests.test.js       | 15 +++++++
 12 files changed, 157 insertions(+), 25 deletions(-)

diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index 197ff5d6..ab69a245 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -697,11 +697,15 @@ describe('rowNote — the non-author matrix', () => {
       });
    });
 
-   it('ready: its author merges it', () => {
-      expect(note({ author, status: 'ready' }, me)).toEqual({
+   it('ready: its developer author merges it; an outside one is left for you', () => {
+      expect(note({ author, status: 'ready', authorIsDeveloper: true }, me)).toEqual({
          action: null,
          context: 'ready · auth merges it',
       });
+      expect(note({ author, status: 'ready' }, me)).toEqual({
+         action: null,
+         context: 'ready · merge it',
+      });
    });
 
    it('an external block overrides a wait note, same as for the author', () => {
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index 247ce97a..5338659d 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -52,7 +52,12 @@ export const askOverdue = (p: DerivedPull, now?: number): boolean =>
 /** A review was requested of someone (a person or a team), whether or not it
  * still names anyone who owes it. */
 const hasRequest = (p: DerivedPull): boolean =>
-   !!(askedOf(p).length || p.data.requested_reviewers?.length || p.data.requested_teams?.length);
+   !!(
+      askedOf(p).length ||
+      p.data.requested_reviewers?.length ||
+      p.data.requested_teams?.length ||
+      p.data.review_requests?.some(r => r.answered)
+   );
 
 /** Needs a reviewer from outside: the author is outside the dev team (or a
  * bot), and nobody who was asked still owes it, nor took it on. A request on
@@ -399,7 +404,10 @@ function reviewerNote(p: DerivedPull, me: string, extra?: { claim?: Claim | null
    if (p.status === 'unmergeable')
       return waitOnly(p.conflict ? 'conflicts · author rebases' : 'lands with its parent');
    if (p.status === 'ci_pending') return waitOnly('all stamps in, waiting on green');
-   if (p.status === 'ready') return waitOnly(`ready · ${author} merges it`);
+   // an outside contributor or bot usually can't merge their own, so it is
+   // left for whoever can
+   if (p.status === 'ready')
+      return waitOnly(p.authorIsDeveloper ? `ready · ${author} merges it` : 'ready · merge it');
 
    return waitOnly(FALLBACK_STATUS_LABEL[p.status]);
 }
diff --git a/frontend-v2/src/model/reviewLanes.test.ts b/frontend-v2/src/model/reviewLanes.test.ts
index 1fcd6955..67fb0211 100644
--- a/frontend-v2/src/model/reviewLanes.test.ts
+++ b/frontend-v2/src/model/reviewLanes.test.ts
@@ -49,7 +49,7 @@ function dp(o: {
    body?: string;
    labels?: string[];
    branch?: string;
-   reviewRequests?: { login: string; at: number | null; self: boolean }[];
+   reviewRequests?: { login: string; at: number | null; self: boolean; answered?: boolean }[];
    requestedReviewers?: string[];
    requestedTeams?: string[];
 }): DerivedPull {
@@ -403,6 +403,43 @@ describe('buildReviewLanes — could use your input', () => {
    });
 });
 
+describe('buildReviewLanes — outside and answered pulls', () => {
+   it("shows an outside contributor's or bot's ready pull to everyone, not a developer's", () => {
+      const outside = dp({
+         number: 1,
+         author: 'stranger',
+         status: 'ready',
+         authorIsDeveloper: false,
+      });
+      const theirs = dp({ number: 2, author: 'alice', status: 'ready', authorIsDeveloper: true });
+      const bot = dp({ number: 3, author: 'dependabot[bot]', status: 'ready' });
+      const lanes = buildReviewLanes(input({ pulls: [outside, theirs], botsForReady: [bot] }));
+      expect(lanes.ready).toEqual([outside, bot]);
+   });
+
+   it('does not offer you a pull whose request you already answered', () => {
+      const p = dp({
+         author: 'alice',
+         ownReview: false,
+         authorIsDeveloper: true,
+         requestedReviewers: [],
+         askedOf: [],
+         reviewRequests: [{ login: 'me', at: 1, self: false, answered: true }],
+         changesRequestedBy: ['me'],
+         title: 'Rework the Shopify sync',
+      });
+      expect(
+         buildReviewLanes(input({ pulls: [p], codeRegions: ['Shopify'] })).couldUseInput
+      ).toEqual([]);
+   });
+
+   it('shows your own pull with a review to answer in Waiting on you', () => {
+      const p = dp({ author: 'me', authorIsDeveloper: true, status: 'needs_cr' });
+      p.data.status.unstamped_reviewers = [{ login: 'bob', state: 'COMMENTED', date: 1 }];
+      expect(buildReviewLanes(input({ pulls: [p] })).yourMove).toEqual([p]);
+   });
+});
+
 describe('buildReviewLanes — stamped and ready lanes', () => {
    it('places your own fully signed-off pull in ready', () => {
       const p = dp({ author: 'me', status: 'ready' });
@@ -410,8 +447,8 @@ describe('buildReviewLanes — stamped and ready lanes', () => {
       expect(lanes.ready).toEqual([p]);
    });
 
-   it('shows another person’s ready pull only when you were asked to review it or claimed it', () => {
-      const plain = dp({ number: 1, author: 'alice', status: 'ready' });
+   it('shows another person’s ready pull only when you were asked to review it or claimed it (outside authors go to everyone)', () => {
+      const plain = dp({ number: 1, author: 'alice', status: 'ready', authorIsDeveloper: true });
       const asked = dp({ number: 2, author: 'alice', status: 'ready', requestedReviewers: ['me'] });
       const claimed = dp({
          number: 3,
@@ -424,19 +461,20 @@ describe('buildReviewLanes — stamped and ready lanes', () => {
          number: 4,
          author: 'alice',
          status: 'ready',
+         authorIsDeveloper: true,
          requestedReviewers: ['bob'],
       });
       const lanes = buildReviewLanes(input({ pulls: [plain, asked, claimed, askedOther] }));
       expect(lanes.ready.map(p => p.data.number).sort()).toEqual([2, 3]);
    });
 
-   it('orders ready oldest first, and leaves an unclaimed ready bot PR in the bot fold', () => {
+   it('orders ready oldest first, and puts a ready bot PR there too (nobody else can merge it)', () => {
       const newer = dp({ number: 1, author: 'me', status: 'ready', ageDays: 1 });
       const older = dp({ number: 2, author: 'me', status: 'ready', ageDays: 5 });
       const bot = dp({ author: 'dependabot[bot]', number: 3, status: 'ready', ageDays: 9 });
       const lanes = buildReviewLanes(input({ pulls: [newer, older], bots: [bot] }));
-      expect(lanes.ready).toEqual([older, newer]);
-      expect(lanes.botRest).toEqual([bot]);
+      expect(lanes.ready).toEqual([bot, older, newer]);
+      expect(lanes.botRest).toEqual([]);
    });
 
    it('draws ready’s bot portion from botsForReady, not bots, when the two differ', () => {
diff --git a/frontend-v2/src/model/reviewLanes.ts b/frontend-v2/src/model/reviewLanes.ts
index 061d66af..b2961631 100644
--- a/frontend-v2/src/model/reviewLanes.ts
+++ b/frontend-v2/src/model/reviewLanes.ts
@@ -165,9 +165,14 @@ const OWN_DO_NOW = [
    'Stamp QA',
    'Lift your block',
    'Rebase',
+   'Answer the review',
+   'Unblock',
 ];
 function ownVerb(p: DerivedPull): string | null {
-   const verb = authorMove(p);
+   // 'Answer the review' and the external-block 'Unblock' come from rowNote
+   // (they sit above authorNote there), so authorMove alone never sees them
+   const shown = rowNote(p, p.data.user.login).action;
+   const verb = shown === 'Answer the review' || shown === 'Unblock' ? shown : authorMove(p);
    if (!verb) return null;
    if (verb.startsWith('Nudge ')) return 'Nudge';
    return OWN_DO_NOW.includes(verb) ? verb : null;
@@ -257,9 +262,14 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
             (p.status === 'needs_cr' || (p.status === 'needs_recr' && !p.recrBy.includes(me)))
       )
       .sort(bySecurityThenAge);
-   // a ready PR is on the Ready lane only when it's yours, asked of you, or claimed
+   // a ready PR is on the Ready lane when it's yours, asked of you, claimed, or
+   // from outside the dev team (an outside contributor or a bot has no
+   // author-developer to merge it, so it's everyone's)
    const readyMine = (p: DerivedPull) =>
-      p.data.user.login === me || askedOf(p).includes(me) || claimFor(p.data)?.login === me;
+      p.data.user.login === me ||
+      !p.authorIsDeveloper ||
+      askedOf(p).includes(me) ||
+      claimFor(p.data)?.login === me;
    const botKeys = new Set(botReviewable.map(p => pullKey(p.data)));
    const botRest = bots
       .filter(p => !botKeys.has(pullKey(p.data)) && !(p.status === 'ready' && readyMine(p)))
@@ -326,6 +336,9 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
                !authorOwnsIt(p) &&
                (CR_INCOMPLETE.includes(p.status) || p.status === 'needs_qa') &&
                !p.crBy.includes(me) &&
+               // you were asked and answered (GitHub cleared the request):
+               // it's the author's move or yours to re-review, not an offer
+               !p.data.review_requests?.some(r => r.answered && r.login === me) &&
                (matchesRegion(p, codeRegions) || reviewedIn.has(p.data.repo))
          ),
          sunk
@@ -373,7 +386,8 @@ export function buildReviewLanes(input: ReviewLanesInput): ReviewLanes {
 
    // Ready to merge: signed off, green, one press from done. Under the
    // policy the author merges their own, so this is your own ready PRs, plus
-   // another person's only when you were asked to review it or took it on.
+   // another person's when you were asked to review it or took it on, or when its
+   // author isn't a developer (outside contributors and bots).
    // Longest-waiting first: the ones most likely forgotten. botsForReady
    // (not `bots`) so a bot PR you claimed still shows when "Ignore bot PRs"
    // has emptied `bots`.
diff --git a/frontend-v2/src/model/reviewers.ts b/frontend-v2/src/model/reviewers.ts
index dce706e6..cdd3bca9 100644
--- a/frontend-v2/src/model/reviewers.ts
+++ b/frontend-v2/src/model/reviewers.ts
@@ -19,6 +19,8 @@ import type { PullData } from '../../../shared/types';
  * number. The one claim predicate: rows, the deal, cheers, and desktop
  * notifications all read this, not private copies. */
 export function claimFor(pull: PullData): { login: string; at: number | null } | null {
-   const entry = (pull.review_requests ?? []).find(r => r.self && r.login !== pull.user.login);
+   const entry = (pull.review_requests ?? []).find(
+      r => r.self && !r.answered && r.login !== pull.user.login
+   );
    return entry ? { login: entry.login, at: entry.at } : null;
 }
diff --git a/frontend-v2/src/model/stats.ts b/frontend-v2/src/model/stats.ts
index 29e40f21..883d1e72 100644
--- a/frontend-v2/src/model/stats.ts
+++ b/frontend-v2/src/model/stats.ts
@@ -9,6 +9,7 @@ import {
    WEIGHT_ORDER,
    reviewWeight,
 } from '../../../shared/model/status';
+import { claimFor } from './reviewers';
 import { isBotLogin } from '../../../shared/model/visibility';
 
 /**
@@ -316,7 +317,7 @@ export function waitingOnSomeone(pulls: DerivedPull[], now: number): WaitingOnSo
       const asked = p.authorIsDeveloper
          ? (d.requested_reviewers ?? []).length || (d.requested_teams ?? []).length
          : p.askedOf.length;
-      if (!p.ownReview && !asked && CR_INCOMPLETE.includes(p.status))
+      if (!p.ownReview && !asked && !claimFor(d) && CR_INCOMPLETE.includes(p.status))
          outside.push({ ...ref, author: d.user.login, days: p.ageDays });
    }
    return {
diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index abc25318..a00751c4 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -490,6 +490,23 @@ describe('the self-review policy', () => {
       expect(d.askedAt).toBe(NOW - 3600);
    });
 
+   it('a request GitHub cleared after the reviewer reviewed keeps the pull out of self-review', () => {
+      // alice asked bob, bob reviewed (GitHub dropped the request), alice pushed
+      const p = withStatus(
+         { allCR: [sig('CR', 'bob', false)] },
+         { review_requests: [{ login: 'bob', at: NOW - 86400, self: false, answered: true }] }
+      );
+      const d = derive(p, undefined, NOW);
+      expect(d.ownReview).toBe(false);
+      expect(d.status).toBe('needs_recr');
+      expect(d.recrBy).toEqual(['bob']);
+      expect(d.askedOf).toEqual([]);
+   });
+
+   it("a fresh unrequested pull with no answered request is still the author's own", () => {
+      expect(derive(pull(), undefined, NOW).ownReview).toBe(true);
+   });
+
    it("a team's members get the team's request time", () => {
       const policy = reviewPolicy({ Store: ['a', 'b'] });
       const d = derive(
diff --git a/lib/git-manager.js b/lib/git-manager.js
index 27a25727..4adb71b0 100644
--- a/lib/git-manager.js
+++ b/lib/git-manager.js
@@ -820,6 +820,10 @@ function getLabelsFromEvents(events, ghIssue) {
  * claimed the review" rather than someone else asking them to look at it.
  * `botLogin` is whatever getBotLogin() resolved to; null (lookup failed, or
  * hasn't resolved yet) just means the bot-request case never matches.
+ *
+ * A login whose request was made, never removed by the author
+ * (review_request_removed means withdrawn), and is no longer open is appended
+ * with `answered: true`: GitHub drops a request when the reviewer reviews.
  */
 export function deriveReviewRequests(events, requestedReviewerLogins, botLogin) {
    const relevant = _.filter(
@@ -848,9 +852,20 @@ export function deriveReviewRequests(events, requestedReviewerLogins, botLogin)
       });
    });
 
-   return requestedReviewerLogins.map(
-      login => activeByLogin.get(login) || { login, at: null, self: false }
-   );
+   const open = new Set(requestedReviewerLogins);
+   // GitHub clears a request the moment the reviewer submits any review, so a
+   // request that was made, never withdrawn, and is no longer open was
+   // answered. Without remembering it, a push would read as a PR nobody asked
+   // anyone about.
+   const answered = [...activeByLogin.values()]
+      .filter(r => !open.has(r.login))
+      .map(r => ({ ...r, answered: true }));
+   return [
+      ...requestedReviewerLogins.map(
+         login => activeByLogin.get(login) || { login, at: null, self: false }
+      ),
+      ...answered,
+   ];
 }
 
 /**
diff --git a/models/pull.js b/models/pull.js
index 6f9592d4..bb1149f1 100644
--- a/models/pull.js
+++ b/models/pull.js
@@ -53,10 +53,17 @@ const normalizeTeams = teams =>
 
 function getReviewRequests(repo, number, requestedReviewerLogins) {
    const known = reviewRequestsByPull.get(reviewRequestsKey(repo, number));
-   return (requestedReviewerLogins || []).map(login => {
+   const open = new Set(requestedReviewerLogins || []);
+   const current = [...open].map(login => {
       const entry = known && known.get(login);
       return entry ? { login, at: entry.at, self: entry.self } : { login, at: null, self: false };
    });
+   // requests GitHub has since cleared because the reviewer answered; a
+   // re-request puts the login back in `open`, which supersedes the old answer
+   const answered = [...(known?.entries() ?? [])]
+      .filter(([login, e]) => e.answered && !open.has(login))
+      .map(([login, e]) => ({ login, at: e.at, self: e.self, answered: true }));
+   return [...current, ...answered];
 }
 
 // A payload's teams with the times we know; the cache then holds exactly the
@@ -366,7 +373,12 @@ class Pull {
       if (reviewRequests) {
          reviewRequestsByPull.set(
             reviewRequestsKey(data.repo, data.number),
-            new Map(reviewRequests.map(r => [r.login, { at: r.at, self: r.self }]))
+            new Map(
+               reviewRequests.map(r => [
+                  r.login,
+                  { at: r.at, self: r.self, answered: Boolean(r.answered) },
+               ])
+            )
          );
       }
 
@@ -383,7 +395,7 @@ class Pull {
    static recordReviewRequested(repo, number, login, { at, self }) {
       const key = reviewRequestsKey(repo, number);
       const known = reviewRequestsByPull.get(key) || new Map();
-      known.set(login, { at, self });
+      known.set(login, { at, self, answered: false });
       reviewRequestsByPull.set(key, known);
    }
 
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 43ab0bad..2bb4bac7 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -363,7 +363,10 @@ export function derive(
    const ownReview =
       isDeveloper(policy, author) &&
       !(pull.requested_reviewers ?? []).length &&
-      !requestedTeams.length;
+      !requestedTeams.length &&
+      // GitHub clears a request once the reviewer reviews; that request was
+      // still made, so the PR isn't self-review after a push
+      !(pull.review_requests ?? []).some(r => r.answered);
 
    // a lifted block deactivates its signature, same as a stale CR stamp
    const devBlockedBy = activeUsers(st.dev_block);
diff --git a/shared/types.ts b/shared/types.ts
index 48526d1e..19cfb66d 100644
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -94,8 +94,11 @@ export interface PullData {
     * GitHub-UI self-request) rather than being asked by someone else. A CLAIM
     * is any entry with self === true. Best-effort and additive: older servers
     * omit the field entirely, so read as [] when absent — requested_reviewers
-    * stays the authoritative list of who's requested either way. */
-   review_requests?: Array<{ login: string; at: number | null; self: boolean }>;
+    * stays the authoritative list of who's requested either way.
+    * `answered` marks a request GitHub has since cleared because the reviewer
+    * reviewed (never one the author withdrew); such a login is NOT in
+    * requested_reviewers. It keeps a push from reading as self-review. */
+   review_requests?: Array<{ login: string; at: number | null; self: boolean; answered?: boolean }>;
    /** GitHub team slugs the PR asks a review from (the pull's
     * requested_teams). Under the self-review policy a request means everyone
     * listed; derive() turns a slug into people through the roster teams
diff --git a/test/derive-review-requests.test.js b/test/derive-review-requests.test.js
index aef453ce..2a3eddd7 100644
--- a/test/derive-review-requests.test.js
+++ b/test/derive-review-requests.test.js
@@ -49,6 +49,21 @@ test('a request followed by its removal nets to nothing even when requested_revi
    assert.deepEqual(result, [{ login: 'bob', at: null, self: false }]);
 });
 
+test('a request GitHub cleared (reviewer reviewed) is kept as answered', () => {
+   const events = [requestedEvent({ at: '2024-01-01T00:00:00Z', actor: 'alice', reviewer: 'bob' })];
+
+   const result = deriveReviewRequests(events, [], 'pulldasher-bot');
+
+   assert.deepEqual(result, [
+      {
+         login: 'bob',
+         at: Math.floor(Date.parse('2024-01-01T00:00:00Z') / 1000),
+         self: false,
+         answered: true,
+      },
+   ]);
+});
+
 test('self is true for a GitHub-UI self-request (actor === reviewer)', () => {
    const events = [
       requestedEvent({ at: '2024-01-01T00:00:00Z', actor: 'carol', reviewer: 'carol' }),

From 9a4abe22248313473fca582799ad547f6c1bb7f8 Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 19:34:56 -0700
Subject: [PATCH 16/17] Finish remembering answered review requests

The last change remembered answered requests but a review found three
gaps:

1) While the reviewer owed a re-stamp, the author was still told
   "Stamp CR", and the PR showed under everyone's Could use your
   input. The author now waits on the reviewer instead.
2) A webhook that wasn't a push (a label, an edit) rebuilt the
   requests without the answered ones, so the PR read as self-review
   until the next push. A login that left the request list is now
   answered, since withdrawals are removed on their own.
3) An answered request never expired, so after the reviewer left the
   roster, or when the reviewer was a bot, every push asked them to
   re-stamp. Only a developer's answered request keeps the PR theirs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/actions.test.ts | 28 ++++++++++++++++++++++++++-
 frontend-v2/src/model/actions.ts      | 11 ++++++++++-
 frontend-v2/src/model/status.test.ts  | 23 ++++++++++++++++++++++
 models/pull.js                        |  8 +++++---
 shared/model/status.ts                | 15 +++++++++++---
 test/review-requests.test.js          | 26 +++++++++++++++++++++++++
 6 files changed, 103 insertions(+), 8 deletions(-)
 create mode 100644 test/review-requests.test.js

diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index ab69a245..5911f3b6 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -31,6 +31,8 @@ function dp(o: {
    askedAt?: number | null;
    /** a claim: who said they'd review it (review_requests self === true) */
    claimedBy?: { login: string; at: number | null };
+   /** people asked whose request GitHub has since cleared (they reviewed) */
+   answeredBy?: string[];
    inputHints?: string[];
    requestedTeams?: string[];
    author?: string;
@@ -66,7 +68,15 @@ function dp(o: {
             qa_req: o.qaReq ?? 1,
             unstamped_reviewers: o.unstampedReviewers,
          },
-         review_requests: o.claimedBy ? [{ ...o.claimedBy, self: true }] : [],
+         review_requests: [
+            ...(o.claimedBy ? [{ ...o.claimedBy, self: true }] : []),
+            ...(o.answeredBy ?? []).map(login => ({
+               login,
+               at: null,
+               self: false,
+               answered: true,
+            })),
+         ],
          input_hints: o.inputHints,
          requested_teams: o.requestedTeams,
       },
@@ -956,6 +966,22 @@ describe('review requests: asked of people, answered in hours', () => {
       });
    });
 
+   it('the author waits on the reviewer who owes a re-stamp, and nobody else is invited in', () => {
+      const p = dp({
+         author: 'me',
+         status: 'needs_recr',
+         authorIsDeveloper: true,
+         recrBy: ['bob'],
+         answeredBy: ['bob'],
+         headPushedAt: hoursAgo(2),
+      });
+      expect(rowNote(p, 'me')).toEqual({
+         action: null,
+         context: 'waiting on bob to re-stamp · last commit 2h ago',
+      });
+      expect(nobodysReview(p)).toBe(false);
+   });
+
    it('asked of someone else: theirs, so I just see who', () => {
       const p = dp({
          author: 'a',
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index 5338659d..d7cfb18b 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -96,7 +96,12 @@ export function qaIsMine(p: DerivedPull, me: string): boolean {
 /** Requested of a team nobody on the roster is in, or of people who have all
  * answered: nobody's review work, but worth showing to anyone who might help. */
 export const nobodysReview = (p: DerivedPull): boolean =>
-   p.authorIsDeveloper && hasRequest(p) && !askedOf(p).length && !claimFor(p.data);
+   p.authorIsDeveloper &&
+   hasRequest(p) &&
+   !askedOf(p).length &&
+   !claimFor(p.data) &&
+   // a reviewer who owes a re-stamp is somebody's review work
+   !p.recrBy.length;
 
 const INPUT_HINT_WORDS: Record<string, string> = {
    ci: 'CI',
@@ -287,6 +292,10 @@ function authorNote(p: DerivedPull, me: string): RowNote {
    // a team request that names nobody on the roster: nobody to nudge, so wait
    if (d.requested_teams?.length)
       return waitOnly(`waiting on a review from ${andList(d.requested_teams)}`);
+   // a push undid a reviewer's stamp: the re-stamp is theirs, not the author's
+   // to give (their own re-stamp under self-review is the Stamp CR below)
+   if (p.status === 'needs_recr' && p.recrBy.some(l => l !== d.user.login))
+      return waitOnly(`waiting on ${who(p.recrBy)} to re-stamp${pushed}`);
    if (authorIsDev)
       return { action: 'Stamp CR', context: 'review it yourself, or request a review' };
    // outside the dev team: someone else reviews it, nobody's been asked yet
diff --git a/frontend-v2/src/model/status.test.ts b/frontend-v2/src/model/status.test.ts
index a00751c4..f711713f 100644
--- a/frontend-v2/src/model/status.test.ts
+++ b/frontend-v2/src/model/status.test.ts
@@ -503,6 +503,29 @@ describe('the self-review policy', () => {
       expect(d.askedOf).toEqual([]);
    });
 
+   it('an answered request from someone off the roster no longer holds the pull', () => {
+      // bob asked, reviewed, then left the roster (or was a bot like Copilot)
+      const roster = reviewPolicy({ Devs: ['author', 'alice'] });
+      const p = withStatus(
+         { allCR: [sig('CR', 'bob', false)] },
+         { review_requests: [{ login: 'bob', at: NOW - 86400, self: false, answered: true }] }
+      );
+      const d = derive(p, undefined, NOW, undefined, undefined, roster);
+      expect(d.ownReview).toBe(true);
+      expect(d.recrBy).toEqual([]);
+      // a developer's answered request still does
+      const kept = reviewPolicy({ Devs: ['author', 'bob'] });
+      const k = derive(p, undefined, NOW, undefined, undefined, kept);
+      expect(k.ownReview).toBe(false);
+      expect(k.recrBy).toEqual(['bob']);
+      const bot = withStatus(
+         { allCR: [sig('CR', 'Copilot', false)] },
+         { review_requests: [{ login: 'Copilot', at: 1, self: false, answered: true }] }
+      );
+      const botPolicy = reviewPolicy(undefined, ['Copilot']);
+      expect(derive(bot, undefined, NOW, undefined, undefined, botPolicy).ownReview).toBe(true);
+   });
+
    it("a fresh unrequested pull with no answered request is still the author's own", () => {
       expect(derive(pull(), undefined, NOW).ownReview).toBe(true);
    });
diff --git a/models/pull.js b/models/pull.js
index bb1149f1..b6b0ea85 100644
--- a/models/pull.js
+++ b/models/pull.js
@@ -58,10 +58,12 @@ function getReviewRequests(repo, number, requestedReviewerLogins) {
       const entry = known && known.get(login);
       return entry ? { login, at: entry.at, self: entry.self } : { login, at: null, self: false };
    });
-   // requests GitHub has since cleared because the reviewer answered; a
-   // re-request puts the login back in `open`, which supersedes the old answer
+   // requests GitHub has since cleared because the reviewer answered (no pull
+   // update says so, so a cached entry still marked unanswered is one too); a
+   // re-request puts the login back in `open`, which supersedes the old answer,
+   // and a withdrawal deletes its entry
    const answered = [...(known?.entries() ?? [])]
-      .filter(([login, e]) => e.answered && !open.has(login))
+      .filter(([login]) => !open.has(login))
       .map(([login, e]) => ({ login, at: e.at, self: e.self, answered: true }));
    return [...current, ...answered];
 }
diff --git a/shared/model/status.ts b/shared/model/status.ts
index 2bb4bac7..173e1edf 100644
--- a/shared/model/status.ts
+++ b/shared/model/status.ts
@@ -365,8 +365,15 @@ export function derive(
       !(pull.requested_reviewers ?? []).length &&
       !requestedTeams.length &&
       // GitHub clears a request once the reviewer reviews; that request was
-      // still made, so the PR isn't self-review after a push
-      !(pull.review_requests ?? []).some(r => r.answered);
+      // still made, so the PR isn't self-review after a push. Only a developer
+      // counts: a reviewer who left the roster, or a bot, doesn't hold it.
+      !(pull.review_requests ?? []).some(r => r.answered && isDeveloper(policy, r.login));
+   // an answered reviewer off the roster owes no re-stamp either
+   const offRoster = new Set(
+      (pull.review_requests ?? [])
+         .filter(r => r.answered && !isDeveloper(policy, r.login))
+         .map(r => r.login)
+   );
 
    // a lifted block deactivates its signature, same as a stale CR stamp
    const devBlockedBy = activeUsers(st.dev_block);
@@ -411,7 +418,9 @@ export function derive(
    // on a self-reviewed pull only the author owes a re-stamp: anyone else's
    // stamp there was a favor nobody asked for, so a push doesn't put them
    // on the hook
-   const owedCr = ownReview ? staleCr.filter(u => u === author) : staleCr;
+   const owedCr = ownReview
+      ? staleCr.filter(u => u === author)
+      : staleCr.filter(u => !offRoster.has(u));
    const owedQa = ownReview ? staleQa.filter(u => u === author) : staleQa;
 
    let status: Status;
diff --git a/test/review-requests.test.js b/test/review-requests.test.js
new file mode 100644
index 00000000..ebd16ac8
--- /dev/null
+++ b/test/review-requests.test.js
@@ -0,0 +1,26 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import Pull from '../models/pull.js';
+
+const payload = (number, reviewers) => ({
+   number,
+   state: 'open',
+   title: 't',
+   body: '',
+   created_at: '2026-09-19T00:00:00Z',
+   updated_at: '2026-09-20T10:01:00Z',
+   user: { login: 'author' },
+   head: { ref: 'f', sha: 'abc', repo: { name: 'r', owner: { login: 'o' } } },
+   base: { ref: 'master', repo: { full_name: 'o/r' } },
+   requested_reviewers: reviewers.map(login => ({ login })),
+   requested_teams: [],
+});
+const requests = pull => pull.toObject().review_requests.map(r => [r.login, Boolean(r.answered)]);
+
+test('a webhook-only update keeps a request GitHub cleared after the review', () => {
+   // bob was asked, then reviewed: GitHub drops him from requested_reviewers
+   // with no pull update, so the cache still has him as unanswered
+   Pull.recordReviewRequested('o/r', 30, 'bob', { at: 1000, self: false });
+   Pull.fromGithubApi(payload(30, ['bob']));
+   assert.deepEqual(requests(Pull.fromGithubApi(payload(30, []))), [['bob', true]]);
+});

From 2a3e5ea27d0d2d6c3eab41352a509206e4d728ea Mon Sep 17 00:00:00 2001
From: Jarred Stelfox <jarstelfox@mac.com>
Date: Fri, 9 Oct 2026 19:40:59 -0700
Subject: [PATCH 17/17] Don't count the author's own stale stamp as others'
 review

"Could use your input" left out any PR with a re-stamp owed, the
author's own included, so a PR whose reviewer answered without a
stamp dropped out of everyone's view once the author pushed over
their own stamp. Only someone else's owed re-stamp takes it out now,
matching the author's note.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 frontend-v2/src/model/actions.test.ts | 12 ++++++++++++
 frontend-v2/src/model/actions.ts      |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/frontend-v2/src/model/actions.test.ts b/frontend-v2/src/model/actions.test.ts
index 5911f3b6..a6742d17 100644
--- a/frontend-v2/src/model/actions.test.ts
+++ b/frontend-v2/src/model/actions.test.ts
@@ -982,6 +982,18 @@ describe('review requests: asked of people, answered in hours', () => {
       expect(nobodysReview(p)).toBe(false);
    });
 
+   it("the author's own stale stamp keeps a PR open to input from others", () => {
+      // bob answered without a stamp; the author stamped, then pushed
+      const p = dp({
+         author: 'me',
+         status: 'needs_recr',
+         authorIsDeveloper: true,
+         recrBy: ['me'],
+         answeredBy: ['bob'],
+      });
+      expect(nobodysReview(p)).toBe(true);
+   });
+
    it('asked of someone else: theirs, so I just see who', () => {
       const p = dp({
          author: 'a',
diff --git a/frontend-v2/src/model/actions.ts b/frontend-v2/src/model/actions.ts
index d7cfb18b..645fa7db 100644
--- a/frontend-v2/src/model/actions.ts
+++ b/frontend-v2/src/model/actions.ts
@@ -101,7 +101,7 @@ export const nobodysReview = (p: DerivedPull): boolean =>
    !askedOf(p).length &&
    !claimFor(p.data) &&
    // a reviewer who owes a re-stamp is somebody's review work
-   !p.recrBy.length;
+   !p.recrBy.some(l => l !== p.data.user.login);
 
 const INPUT_HINT_WORDS: Record<string, string> = {
    ci: 'CI',