limn-review 0.1.176 → 0.1.178

package/dist/api/plugins/rate-limit.js

@@ -804,10 +804,17 @@ function tierFor(method, path) {
     // `getAccessToken` on line 35 of github/reviewer-suggest.ts. When in doubt, follow the token.
     // Genuinely DB-only and correctly left on `read`: `/bot-behaviour`, `/bot-dedup`,
     // `/mention-candidates`, `/claude-review` (retrieval).
-    const prGithubGet = /^\/api\/prs\/\d+(\/(merge-options|files|files\/content|files\/diff|suggested-reviewers|checks\/[^/]+\/logs))?$/;
+    //   `/reviewer-candidate`       "Ask someone else": the same suggestion pipeline as
+    //                               `/suggested-reviewers` (CODEOWNERS + team history), on a click.
+    const prGithubGet = /^\/api\/prs\/\d+(\/(merge-options|files|files\/content|files\/diff|suggested-reviewers|reviewer-candidate|checks\/[^/]+\/logs))?$/;
     if (!mutating && prGithubGet.test(path)) {
         return [TIERS.prDetail, TIERS.read];
     }
+    // GET /api/prs/<id>/review-waits — the PR pane's review waits against the target: two indexed
+    // selects and a calendar fold, no GitHub, no model. `read`, DECIDED (spelled exactly) rather than
+    // inherited from the blanket.
+    if (!mutating && /^\/api\/prs\/\d+\/review-waits$/.test(path))
+        return [TIERS.read];
     // GET /api/threads/<id> hydrates the same way.
     if (!mutating && /^\/api\/threads\/\d+$/.test(path))
         return [TIERS.prDetail, TIERS.read];

package/dist/api/routes/open-prs.js

@@ -1,5 +1,6 @@
 import { getOpenPrs, resolveWorkspaceScope } from '../../db/queries.js';
 import { accountIdOf } from '../plugins/auth.js';
+import { attachPrChips } from '../../db/pr-chips.js';
 // `repoIds` → the `narrow` argument of `resolveWorkspaceScope`, never a scope in its own right.
 // Empty/absent → null = no narrowing (every repo in the workspace).
 function parseIntList(raw) {
@@ -29,6 +30,8 @@ export async function openPrsRoutes(app) {
             repoIds: scope.repoIds,
             userIds: parseIntList(q.userIds),
         });
+        // PR CHIPS (db/pr-chips.ts): the stack and the criteria — on this list only, never the timeline.
+        await attachPrChips(accountId, prs, (p) => p.id);
         return { prs };
     });
 }

package/dist/api/routes/prs.js

@@ -3,9 +3,10 @@ import { REQUEST_CHANGES_DEFAULT_BODY, WITHDRAW_APPROVAL_MESSAGE, mergeStateWith
 import { accountGithubLogin } from '../../db/review-threads-for-review.js';
 import { config } from '../../config.js';
 import { stampPrMergeQueueStateNonFatal } from '../../db/pr-merge-queue-stamp.js';
+import { prFlakyChecks } from '../../db/flaky-checks.js';
 import { getAccessToken, getAccountUserId } from '../../auth/account.js';
 import { fetchActionsJobLog } from '../../github/actions-logs.js';
-import { disarmAutoMerge, getAutoMergeRequest, listAutoMergeRequests, getMentionCandidates, getPrDetail, getPrBotBehaviour, getPrFilesContext, getPrWriteContext, getReviewerLogins, getResolvableBotThreads, getSuggestedReviewersBasis, getUsersByLogins, clearOwnReviewRequest, markAllViewed, markPrClosedLocally, markPrMergedLocally, markPrReopenedLocally, markPrViewed, stampReviewRequests, markLocalReviewDismissed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
+import { disarmAutoMerge, getAutoMergeRequest, listAutoMergeRequests, getMentionCandidates, getPrDetail, getPrBotBehaviour, getPrFilesContext, getPrWriteContext, getReviewerLogins, getResolvableBotThreads, getSuggestedReviewersBasis, getPrReviewWaits, getReviewerCandidate, getUsersByLogins, clearOwnReviewRequest, markAllViewed, markPrClosedLocally, markPrMergedLocally, markPrReopenedLocally, markPrViewed, stampReviewRequests, markLocalReviewDismissed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
 import { resolveArmedQueues, withArmedQueueFields } from '../../db/merge-queue.js';
 // The watcher's live marks (yields + queue-disabled fallbacks). Read-only, and the reason this
 // import is not a layering smell: every one of them is a LIVE observation of GitHub made inside
@@ -25,6 +26,7 @@ import { getPrSettleFacts, notePrChangedForPr, schedulePrSettle, } from '../../s
 import { noteMergeLanded } from '../../sync/unsettled-prs.js';
 import { resolveThreadsOnGitHub } from '../../bot-triage/resolve.js';
 import { accountIdOf } from '../plugins/auth.js';
+import { prChipsFor } from '../../db/pr-chips.js';
 // GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its
 // path (matches db/queries.ts + hydrate-detail.ts's diffAnchorId).
 function diffAnchorId(path) {
@@ -297,6 +299,15 @@ export async function prRoutes(app) {
         // caches the result in IndexedDB keyed by updatedAt so unchanged PRs don't refetch.
         // (Suggested reviewers are NOT here — they're a separate live query, see below — so the
         // cached detail never freezes a stale suggestion.)
+        // The FLAKY failing checks at the synced head (db/flaky-checks.ts) — stored rows only, so the
+        // Checks row needs no fetch of its own. [] when none (or the head is not red).
+        pr.flakyChecks = (await prFlakyChecks(accountId, [pr])).get(pr.id)?.checks ?? [];
+        // PR CHIPS (db/pr-chips.ts): the stack (open PRs only) and the criteria, DB only.
+        const chips = (await prChipsFor(accountId, [{ id: pr.id, repoId: pr.repoId }])).get(pr.id);
+        if (chips != null) {
+            pr.branchStack = pr.state === 'open' ? chips.branchStack : null;
+            pr.criteria = chips.criteria;
+        }
         return hydratePrDetail(pr, accountId);
     });
     // Live PR-detail freshness: the SPA polls this every ~5s while a PR is open AND visible,
@@ -1604,8 +1615,35 @@ export async function prRoutes(app) {
             };
         }
     });
+    // How long each outstanding review request on the PR has waited, in working hours, against the
+    // workspace's review target — the PR pane's reviewers area ("Over the 4h review target", Nudge).
+    // DB only (tier `read`, decided in tierFor). Contract row in docs/API.md.
+    app.get('/api/prs/:id/review-waits', { schema: idParamSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const resp = await getPrReviewWaits(id, accountIdOf(req));
+        if (!resp) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        const out = resp;
+        return out;
+    });
+    // "Ask someone else": the one suggested reviewer to ask — the least loaded of the PR's suggested
+    // people not already asked. Fetched on the reader's CLICK, never on mount: it reads CODEOWNERS
+    // (network), so `prDetail` + `read` in tierFor. Asking is then the reader's confirm, through
+    // POST …/request-reviewers below. Contract row in docs/API.md.
+    app.get('/api/prs/:id/reviewer-candidate', { schema: idParamSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const resp = await getReviewerCandidate(id, accountIdOf(req));
+        if (!resp) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        const out = resp;
+        return out;
+    });
     // Request reviewers on a PR (powers each Pending routing card's per-suggestion "Assign"
-    // button, one reviewer per request — contract row in docs/API.md). Server
+    // button, a waiting row's "Nudge" / "Ask someone else" and the PR pane's, one reviewer per request — contract row in docs/API.md). Server
     // re-checks write access (WRITE/MAINTAIN/ADMIN — push-style, no author exclusion:
     // an author may request reviewers on their own PR). The given user ids are resolved
     // to GitHub logins (the PR author + bots + unknown ids dropped); GitHub itself gates
@@ -1654,6 +1692,10 @@ export async function prRoutes(app) {
             await stampReviewRequests(ctx.prId, resolved.map((r) => r.userId), teams.map((slug) => `${ctx.owner}/${slug}`));
             // The stamp moves the routing card; signal it before replying. Never throws.
             await notePrChangedForPr(accountId, ctx.prId);
+            // ONE re-read shortly after (no expectation: the ladder stops at its first read), so the
+            // NEW request event — a "Nudge" re-asks someone already on the hook — reaches the stored
+            // history and restarts that reviewer's wait (db/review-waits.ts). Fire-and-forget.
+            schedulePrSettle(accountId, ctx.prId, asSyncLogger(req.log));
             const result = {
                 status: 'ok',
                 requestedLogins: logins,

package/dist/db/daily-brief.js

@@ -282,7 +282,8 @@ async function computeBriefCounts(accountId, workspaceId) {
     // The fourth is housekeeping — an update, not something waiting on you. (`security` IS counted,
     // below, off `kindTotals` like the other survey lines.) This allow-list and the route's deny-list
     // are the two hand-maintained spellings of "which kinds count"; daily-brief.test.ts compares them
-    // per kind, so an omission here is a CI failure, not a silence.
+    // per kind, so an omission here is a CI failure, not a silence. `waiting_on_others` never reaches
+    // it at all: it is built only for the live board (`withFailingChecks`), and counted only there.
     for (const c of insights.cards) {
         if (c.kind === 'ci_failing')
             ciFailing += 1;

package/dist/db/flaky-checks.js

@@ -0,0 +1,148 @@
+// ── FLAKY CHECKS — which failing checks are probably not the PR's fault (CORE, no AI, no GitHub) ──
+//
+// docs/MERGE-CI-TRUNK.md § Flaky checks. A failing check at a PR's CURRENT head is FLAKY when:
+//
+//   (a) `passed_and_failed` — the PR's stored CI log (`ci_status_events`) holds a row AT THAT HEAD
+//       whose rollup was `success` (every check passed on this commit), and the check fails on it
+//       now. ⚠ The log stores the FAILING names only, never per-check passes, so a `success` row is
+//       the one stored proof that a check passed. A red row that merely omits a name is NOT one —
+//       the check may be re-running (pending) or cancelled.
+//   (b) `ci_review_infra` — the latest SUCCEEDED CI review AT THAT HEAD diagnosed the check
+//       `flaky_or_infra`. An older head's review never counts: it explained different code.
+//
+// ⚠ ONE PURE FUNCTION decides (`classifyFlakyChecks`); the loader below only gathers its inputs, in
+// three account-scoped reads for the whole board. Nothing fetches; nothing is stored.
+// ⚠ A FLAKY CHECK IS STILL A FAILURE: no count, no CI label, no merge verdict and no card depends on
+// this. It is DISPLAY ONLY — never in a `detail`, a work-plan fact, a hash or a model payload.
+// ⚠ `limn/` statuses are never CI (`isLimnStatusContext`): never a failing check, never flaky.
+import { and, eq, inArray } from 'drizzle-orm';
+import { isLimnStatusContext, } from '../shared/index.js';
+import { db, schema } from './client.js';
+import { isRedCiStatus } from './pending-classify.js';
+import { summariseFailingChecks } from './failing-checks.js';
+const { ciStatusEvents, ciReviews, ciReviewItems } = schema;
+/** A name as the failing-check list spells it (trimmed, sliced) — one spelling for both sides. */
+function normaliseNames(names) {
+    return (summariseFailingChecks(names, Number.POSITIVE_INFINITY)?.failingChecks ?? []).filter((n) => !isLimnStatusContext(n));
+}
+/**
+ * THE RULE. `failing` = every check failing at `headSha` now (uncapped); `log` = the PR's stored CI
+ * log rows (any head — rows for other heads are ignored here); `ciReviewItems` = the items of the
+ * latest succeeded CI review AT `headSha`, or null when there is none. null when nothing is flaky.
+ */
+export function classifyFlakyChecks(input) {
+    const failing = normaliseNames(input.failing);
+    if (failing.length === 0)
+        return null;
+    const passedOnHead = input.log.some((r) => r.headSha === input.headSha && r.status === 'success');
+    const infra = new Set(normaliseNames((input.ciReviewItems ?? [])
+        .filter((i) => i.status === 'diagnosed' && i.category === 'flaky_or_infra')
+        .map((i) => i.checkName)));
+    const checks = [];
+    for (const name of failing) {
+        const reasons = [];
+        if (passedOnHead)
+            reasons.push('passed_and_failed');
+        if (infra.has(name))
+            reasons.push('ci_review_infra');
+        if (reasons.length > 0)
+            checks.push({ name, reasons });
+    }
+    if (checks.length === 0)
+        return null;
+    return { checks, allFailing: checks.length === failing.length };
+}
+/**
+ * Each RED PR's flaky checks at its CURRENT head, keyed by PR id (absent = none flaky, or not red).
+ * The failing set is the NEWEST log row at the head — the row `prFailingChecks` names — and only
+ * while that row is red. Three reads: the log rows, the succeeded CI reviews at those heads, their
+ * items. Every `IN × IN` predicate over-matches, so rows are kept only for a requested PAIR.
+ */
+export async function prFlakyChecks(accountId, prs) {
+    const out = new Map();
+    const asked = new Map();
+    for (const p of prs) {
+        if (p.headSha != null && isRedCiStatus(p.ciStatus))
+            asked.set(p.id, p.headSha);
+    }
+    if (asked.size === 0)
+        return out;
+    const prIds = [...asked.keys()];
+    const shas = [...new Set(asked.values())];
+    const rows = await db
+        .select({
+        id: ciStatusEvents.id,
+        prId: ciStatusEvents.prId,
+        headSha: ciStatusEvents.headSha,
+        status: ciStatusEvents.status,
+        failingChecks: ciStatusEvents.failingChecks,
+        observedAt: ciStatusEvents.observedAt,
+    })
+        .from(ciStatusEvents)
+        .where(and(eq(ciStatusEvents.accountId, accountId), inArray(ciStatusEvents.prId, prIds), inArray(ciStatusEvents.headSha, shas)))
+        .execute();
+    const logByPr = new Map();
+    for (const r of rows) {
+        if (asked.get(r.prId) !== r.headSha)
+            continue;
+        const list = logByPr.get(r.prId) ?? [];
+        list.push(r);
+        logByPr.set(r.prId, list);
+    }
+    // The latest SUCCEEDED CI review at each asked head (highest id wins, the persist layer's rule).
+    const runs = await db
+        .select({ id: ciReviews.id, prId: ciReviews.prId, headSha: ciReviews.headSha })
+        .from(ciReviews)
+        .where(and(eq(ciReviews.accountId, accountId), inArray(ciReviews.prId, prIds), inArray(ciReviews.headSha, shas), eq(ciReviews.status, 'succeeded')))
+        .execute();
+    const latestRun = new Map();
+    for (const r of runs) {
+        if (asked.get(r.prId) !== r.headSha)
+            continue;
+        if ((latestRun.get(r.prId) ?? 0) < r.id)
+            latestRun.set(r.prId, r.id);
+    }
+    const itemsByRun = new Map();
+    if (latestRun.size > 0) {
+        const items = await db
+            .select({
+            ciReviewId: ciReviewItems.ciReviewId,
+            checkName: ciReviewItems.checkName,
+            status: ciReviewItems.status,
+            category: ciReviewItems.category,
+        })
+            .from(ciReviewItems)
+            .where(and(eq(ciReviewItems.accountId, accountId), inArray(ciReviewItems.ciReviewId, [...latestRun.values()])))
+            .execute();
+        for (const i of items) {
+            const list = itemsByRun.get(i.ciReviewId) ?? [];
+            list.push(i);
+            itemsByRun.set(i.ciReviewId, list);
+        }
+    }
+    for (const [prId, headSha] of asked) {
+        const log = logByPr.get(prId) ?? [];
+        // The newest row at the head (observedAt, then id) — the failing set the card names.
+        let newest;
+        for (const r of log) {
+            if (newest == null ||
+                r.observedAt.getTime() > newest.observedAt.getTime() ||
+                (r.observedAt.getTime() === newest.observedAt.getTime() && r.id > newest.id)) {
+                newest = r;
+            }
+        }
+        if (newest == null || !isRedCiStatus(newest.status))
+            continue;
+        const runId = latestRun.get(prId);
+        const verdict = classifyFlakyChecks({
+            headSha,
+            failing: newest.failingChecks ?? [],
+            log,
+            ciReviewItems: runId != null ? (itemsByRun.get(runId) ?? []) : null,
+        });
+        if (verdict != null)
+            out.set(prId, { headSha, ...verdict });
+    }
+    return out;
+}
+//# sourceMappingURL=flaky-checks.js.map

package/dist/db/flow-detail.js

@@ -169,6 +169,28 @@ function budgetRow(measure, values, settings) {
     }
     return { measure, good, ok, prs: n, p50: r2(p50), p75: r2(p75), p90: r2(p90), verdict, sentence };
 }
+// ── The review target headline ──────────────────────────────────────────────────────────────
+/**
+ * "86% of first reviews arrived within 4 working hours" — the share of measured PRs whose first look
+ * came within the first-look budget's "good" value (THE review target; no second setting). Over the
+ * same values as the first-look budget row, so the two cannot disagree about the population.
+ * ⚠ UNKNOWN IS NEVER ZERO: null under `FLOW_BUDGET_MIN_PRS` first looks — the budget row beside it
+ * already says how few there were.
+ */
+function reviewTargetOf(worked, settings) {
+    const looks = worked.map((w) => w.firstLookWork).filter((v) => v != null);
+    if (looks.length < FLOW_BUDGET_MIN_PRS)
+        return null;
+    const targetHours = settings.budgets.firstLook.good;
+    const within = looks.filter((v) => v <= targetHours).length;
+    const share = Math.round((within / looks.length) * 100);
+    return {
+        targetHours,
+        within,
+        prs: looks.length,
+        sentence: `${share}% of first reviews arrived within ${fmtWork(targetHours, 0)}`,
+    };
+}
 const share = (rows, pred) => rows.length === 0 ? 0 : rows.filter(pred).length / rows.length;
 const SIGNALS = [
     {
@@ -615,6 +637,7 @@ export function buildFlowDetail(facts, cal, settings, minRepoPrs) {
         concentration: concentrationOf(worked, minRepoPrs),
         requests: requestsOf(worked, dayHours),
         prFigures: prFiguresOf(worked, dayHours),
+        reviewTarget: reviewTargetOf(worked, settings),
     };
 }
 // ── Ticket keys ─────────────────────────────────────────────────────────────────────────────

package/dist/db/migrations/0163_pr_cross_repository.sql

@@ -0,0 +1,5 @@
+-- STACKED PRs (docs/FRONTEND.md § Stacked PRs). Additive; no data to move.
+--
+--   pull_requests.is_cross_repository   GraphQL `isCrossRepository`: the head branch lives in a fork.
+--                                       NULL = not observed yet; written only from a received boolean.
+ALTER TABLE `pull_requests` ADD `is_cross_repository` integer;

package/dist/db/migrations/meta/_journal.json

@@ -1142,6 +1142,13 @@
       "when": 1792224068016,
       "tag": "0162_dependency_ai_fix",
       "breakpoints": true
+    },
+    {
+      "idx": 163,
+      "version": "6",
+      "when": 1792224069016,
+      "tag": "0163_pr_cross_repository",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/pending-first-landing.js

@@ -24,7 +24,7 @@
 //                        is built until the reader presses Add.
 //
 // ⚠ LIVE STATE, like the board: nothing here may enter a payload hash.
-import { PENDING_OWN_PRS_SHOWN, PENDING_SUMMARY_DAYS, } from '../shared/index.js';
+import { PENDING_OWN_PRS_SHOWN, PENDING_TABS, PENDING_SUMMARY_DAYS, } from '../shared/index.js';
 import { and, count, desc, eq, inArray, isNotNull, min, sql } from 'drizzle-orm';
 import { db, schema } from './client.js';
 import { ownRunsOnly } from './teammate-reviews.js';
@@ -39,9 +39,11 @@ export function summaryWindowOpen(firstOnboardingAt, now) {
         return false;
     return now - firstOnboardingAt.getTime() < PENDING_SUMMARY_DAYS * DAY_MS;
 }
-/** Is every tab empty? The tabs' totals are the board's populations (review load is not counted). */
+/** Is every tab empty? The tabs' totals are the board's populations (review load is not counted).
+ *  ⚠ "Waiting on others" (`byWait`) is not asked: it is information about the reader's own PRs, not
+ *  something to do — and the empty board lists those same PRs, with what blocks each. */
 export function boardIsEmpty(tabs) {
-    return tabs.every((t) => t.total === 0);
+    return tabs.every((t) => t.total === 0 || PENDING_TABS.find((d) => d.key === t.key)?.byWait === true);
 }
 /** May the suggestion show at all? Pure — the PR pick is separate. */
 export function reviewSuggestionAllowed(f) {

package/dist/db/pending-tabs.js

@@ -1,10 +1,12 @@
 // ── THE PENDING BOARD'S TABS (CORE, deterministic, no AI) ───────────────────────────────────
 //
-// Seven tabs (`PENDING_TABS` in packages/shared/src/pending-rules.ts), each a scored list: every PR
+// Eight tabs (`PENDING_TABS` in packages/shared/src/pending-rules.ts), each a scored list: every PR
 // card is scored by the one Do next scorer (`scoreCards`, db/work-plan.ts), with the READER's
 // weights (Settings → My Turn), and each tab lists its cards highest score first — except the two
 // STRICT-GROUP tabs, whose groups come first: My turn by card type in the READER's order
 // (`groupByReason`) and Dependencies security before bumps (`groupByKind`), each scored within.
+// The one UNSCORED tab, "Waiting on others" (`byWait`), lists the longest wait first instead
+// (`listByWait`): the reader cannot act on it, so there is nothing to score.
 // There is no severity-first sort and no cross-kind spread rule — a card competes only with the
 // cards in its own tab (and group), and a PR with two jobs appears once per job, in each job's tab.
 //
@@ -34,6 +36,7 @@ import { getWorkspaceInsights, mapUser, resolveWorkspaceScope, suggestRoutingRev
 import { scoreCards } from './work-plan.js';
 import { getMyTurnSettings, rankRulesOf } from './my-turn-settings.js';
 import { getPendingFirstLanding } from './pending-first-landing.js';
+import { attachPrChips } from './pr-chips.js';
 /** Highest score first; ties go to the longer wait, then the lower PR id, then the card id — a
  *  total order, so two polls of unchanged data list the same cards in the same order. */
 export function compareScored(a, b) {
@@ -95,6 +98,29 @@ export function listTab(def, scored, byId, myTurnOrderIdx) {
     }
     return out;
 }
+/** THE LISTING RULE FOR AN UNSCORED TAB (`byWait` — "Waiting on others"): its cards, longest wait
+ *  first (then the lower PR id, then the card id — a total order), each list group cut to
+ *  `boardListCap`. ⚠ No score: these are read-only rows the reader cannot act on next, so the Do
+ *  next scorer has nothing to rank, and the work plan may never name one (`listedCardIds` lists
+ *  scored cards only). */
+export function listByWait(def, cards) {
+    const waitOf = (c) => (c.kind === 'waiting_on_others' ? c.waitHours : -1);
+    const prOf = (c) => ('prId' in c && c.prId != null ? c.prId : Number.MAX_SAFE_INTEGER);
+    const inTab = cards
+        .filter((c) => pendingTabHolds(def, c))
+        .sort((a, b) => waitOf(b) - waitOf(a) || prOf(a) - prOf(b) || a.id.localeCompare(b.id));
+    const perGroup = new Map();
+    const out = [];
+    for (const c of inTab) {
+        const group = listGroupOf(c);
+        const n = perGroup.get(group) ?? 0;
+        if (n >= PENDING_LIMITS.boardListCap)
+            continue;
+        perGroup.set(group, n + 1);
+        out.push(c);
+    }
+    return out;
+}
 /** Every card id any tab lists, for these cards, scores and My turn type order — the population
  *  the Pro work plan may name. A plan row whose card the board does not list would put its
  *  sentence on a card the reader cannot find. */
@@ -135,11 +161,19 @@ opts = {}) {
         // Every scored card of the tab's kinds — in a strict-group tab by group first — highest score
         // first, then listed per list group to the cap (`listTab`, the one listing rule).
         const ids = [];
-        for (const s of listTab(def, scored, byId, orderIdx)) {
-            ids.push(s.cardId);
-            listed.push(byId.get(s.cardId));
-            const { cardId: _cardId, prId: _prId, ...score } = s;
-            scores[s.cardId] = score;
+        if (def.byWait === true) {
+            for (const c of listByWait(def, insights.cards)) {
+                ids.push(c.id);
+                listed.push(c);
+            }
+        }
+        else {
+            for (const s of listTab(def, scored, byId, orderIdx)) {
+                ids.push(s.cardId);
+                listed.push(byId.get(s.cardId));
+                const { cardId: _cardId, prId: _prId, ...score } = s;
+                scores[s.cardId] = score;
+            }
         }
         if (def.key === 'review') {
             routingTop = ids
@@ -216,6 +250,9 @@ export async function buildPendingBoard(accountId, workspace, opts = {}) {
     const insights = await getWorkspaceInsights(accountId, undefined, scope, {
         uncapped: true,
         withFailingChecks: live,
+        // "Waiting on others" — the reader's own PRs held by someone else. The route's alone: the
+        // Slack snapshot (a TEAM digest) never builds it.
+        withWaiting: live,
         ...(live ? { boardFacts } : {}),
     });
     const board = await rankPendingTabs(accountId, scope, insights, opts.now ?? Date.now(), {
@@ -235,6 +272,14 @@ export async function buildPendingBoard(accountId, workspace, opts = {}) {
     const firstLanding = live
         ? await getPendingFirstLanding(accountId, scope, board.tabs, opts.now ?? Date.now())
         : null;
+    // PR CHIPS (db/pr-chips.ts) — the stack and the criteria, on the LISTED PR cards, live only (the
+    // Slack snapshot shows neither). DB only; the board still may not fetch.
+    if (live) {
+        await attachPrChips(accountId, board.cards.filter((c) => typeof c.repoId === 'number'), (c) => {
+            const id = c.prId;
+            return typeof id === 'number' ? id : null;
+        });
+    }
     return {
         ...(firstLanding ?? {}),
         workspaceId: scope.workspaceId,

package/dist/db/pr-chips.js

@@ -0,0 +1,32 @@
+import { branchStacksFor } from './pr-stacks.js';
+import { prCriteriaFor } from './pr-criteria.js';
+/** Both chips for these PRs. A PR that is not open gets `branchStack: null` (stacks are open PRs). */
+export async function prChipsFor(accountId, prs) {
+    const out = new Map();
+    if (prs.length === 0)
+        return out;
+    const repoIds = [...new Set(prs.map((p) => p.repoId))];
+    const [stacks, criteria] = await Promise.all([
+        branchStacksFor(accountId, repoIds),
+        prCriteriaFor(accountId, prs.map((p) => p.id)),
+    ]);
+    for (const p of prs) {
+        out.set(p.id, { branchStack: stacks.get(p.id) ?? null, criteria: criteria.get(p.id) ?? [] });
+    }
+    return out;
+}
+/** Copy the chips onto rows that carry `id` (or `prId`) in place. */
+export async function attachPrChips(accountId, rows, idOf) {
+    const prs = rows.flatMap((r) => {
+        const id = idOf(r);
+        return id != null ? [{ id, repoId: r.repoId }] : [];
+    });
+    const chips = await prChipsFor(accountId, prs);
+    for (const r of rows) {
+        const id = idOf(r);
+        const c = id != null ? chips.get(id) : undefined;
+        if (c != null)
+            Object.assign(r, c);
+    }
+}
+//# sourceMappingURL=pr-chips.js.map

package/dist/db/pr-criteria.js

@@ -0,0 +1,119 @@
+// THE "Criteria 3/4" CHIP (docs/FRONTEND.md § PR chips; docs/CLAUDE-REVIEW.md § Ticket review).
+// CORE, DB only — never a model, tracker or GitHub call.
+//
+// For each PR, per TICKET: the latest SUCCEEDED ticket review (Story check) of that ticket that had
+// this PR as a MEMBER, and its criteria verdicts. "Met" is `status === 'met'` only — `partly_met`,
+// `not_met`, `unclear` and `not_checked` are not met (shared `PrCriteriaCheck`). A check whose
+// assessment lists no criteria is NO chip (unknown is never zero), and a PR never checked has none.
+//
+// `olderHead`: the run read this PR at a head other than its current synced head.
+//
+// BATCHED: three queries whatever the number of PRs — the members (no JSON), the chosen runs'
+// assessments, the PRs' current heads.
+//
+// ⚠ PURE AT IMPORT: the DB client is reached LAZILY (the fold is unit-tested without one).
+const CHUNK = 400;
+/** Per PR, per ticket ident: the newest run (highest id) that had the PR as a member. Pure. */
+export function latestRunPerTicket(rows) {
+    const out = new Map();
+    for (const r of rows) {
+        const byIdent = out.get(r.prId) ?? new Map();
+        const prev = byIdent.get(r.ident);
+        if (prev == null || r.runId > prev.runId)
+            byIdent.set(r.ident, r);
+        out.set(r.prId, byIdent);
+    }
+    return out;
+}
+/** One chip's figures from one run, or null when the run judged no criteria. Pure. */
+export function criteriaCheckOf(member, run, currentHeadSha) {
+    const criteria = run?.assessment?.criteria;
+    if (run == null || !Array.isArray(criteria) || criteria.length === 0)
+        return null;
+    let met = 0;
+    let partlyMet = 0;
+    let notMet = 0;
+    let unsettled = 0;
+    for (const c of criteria) {
+        if (c.status === 'met')
+            met += 1;
+        else if (c.status === 'partly_met')
+            partlyMet += 1;
+        else if (c.status === 'not_met')
+            notMet += 1;
+        else
+            unsettled += 1;
+    }
+    return {
+        ident: member.ident,
+        key: run.key,
+        title: run.title,
+        reviewId: run.id,
+        met,
+        partlyMet,
+        notMet,
+        unsettled,
+        total: criteria.length,
+        checkedAt: (run.completedAt ?? new Date(0)).toISOString(),
+        // An unknown current head is not "older" — say nothing rather than guess.
+        olderHead: currentHeadSha != null && currentHeadSha !== '' && currentHeadSha !== member.headSha,
+    };
+}
+/** Order on the chip row: by key (numerically), pasted stories last. Pure. */
+export function compareCriteriaChecks(a, b) {
+    if (a.key == null || b.key == null)
+        return a.key == null ? (b.key == null ? a.reviewId - b.reviewId : 1) : -1;
+    return a.key.localeCompare(b.key, undefined, { numeric: true });
+}
+const asDate = (d) => (d instanceof Date ? d : d == null ? null : new Date(d));
+/** Every listed PR's criteria chips (this account only). Every asked id gets an entry ([] = none). */
+export async function prCriteriaFor(accountId, prIds) {
+    const ids = [...new Set(prIds)];
+    const out = new Map(ids.map((id) => [id, []]));
+    if (ids.length === 0)
+        return out;
+    const { and, eq, inArray } = await import('drizzle-orm');
+    const { db, schema } = await import('./client.js');
+    const { ticketReviews: tr, ticketReviewMembers: trm, pullRequests: pr } = schema;
+    const memberRows = [];
+    const heads = new Map();
+    for (let i = 0; i < ids.length; i += CHUNK) {
+        const slice = ids.slice(i, i + CHUNK);
+        memberRows.push(...(await db
+            .select({ prId: trm.prId, runId: tr.id, ident: tr.ticketIdent, headSha: trm.headSha })
+            .from(trm)
+            .innerJoin(tr, and(eq(tr.id, trm.ticketReviewId), eq(tr.accountId, trm.accountId)))
+            .where(and(eq(trm.accountId, accountId), inArray(trm.prId, slice), eq(tr.status, 'succeeded')))
+            .execute()));
+        const headRows = (await db
+            .select({ id: pr.id, headSha: pr.headSha })
+            .from(pr)
+            .where(and(eq(pr.accountId, accountId), inArray(pr.id, slice)))
+            .execute());
+        for (const h of headRows)
+            heads.set(h.id, h.headSha);
+    }
+    const latest = latestRunPerTicket(memberRows);
+    const runIds = [...new Set([...latest.values()].flatMap((m) => [...m.values()].map((r) => r.runId)))];
+    const runs = new Map();
+    for (let i = 0; i < runIds.length; i += CHUNK) {
+        const rows = (await db
+            .select({ id: tr.id, key: tr.ticketKey, title: tr.ticketTitle, assessment: tr.assessment, completedAt: tr.completedAt })
+            .from(tr)
+            .where(and(eq(tr.accountId, accountId), inArray(tr.id, runIds.slice(i, i + CHUNK))))
+            .execute());
+        for (const r of rows)
+            runs.set(r.id, { ...r, completedAt: asDate(r.completedAt) });
+    }
+    for (const [prId, byIdent] of latest) {
+        const chips = [];
+        for (const m of byIdent.values()) {
+            const c = criteriaCheckOf(m, runs.get(m.runId), heads.get(prId));
+            if (c != null)
+                chips.push(c);
+        }
+        out.set(prId, chips.sort(compareCriteriaChecks));
+    }
+    return out;
+}
+//# sourceMappingURL=pr-criteria.js.map